Add with Carry (immediate) adds an immediate value and the Carry flag value to a register value, and writes the result to the destination register.
If the destination register is not the PC, the ADCS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Add with Carry (register) adds a register value, the Carry flag value, and an optionally-shifted register value, and writes the result to the destination register.
If the destination register is not the PC, the ADCS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Add with Carry (register-shifted register) adds a register value, the Carry flag value, and a register-shifted register value. It writes the result to the destination register, and can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "ADD": case "ADDS": return { "tooltip": "Add (immediate) adds an immediate value to a register value, and writes the result to the destination register.", "html": "Add (immediate) adds an immediate value to a register value, and writes the result to the destination register.
If the destination register is not the PC, the ADDS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Add (register) adds a register value and an optionally-shifted register value, and writes the result to the destination register.
If the destination register is not the PC, the ADDS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Add (register-shifted register) adds a register value and a register-shifted register value. It writes the result to the destination register, and can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "ADD": case "ADDS": return { "tooltip": "Add to SP (immediate) adds an immediate value to the SP value, and writes the result to the destination register.", "html": "Add to SP (immediate) adds an immediate value to the SP value, and writes the result to the destination register.
If the destination register is not the PC, the ADDS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Add to SP (register) adds an optionally-shifted register value to the SP value, and writes the result to the destination register.
If the destination register is not the PC, the ADDS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Form PC-relative address adds an immediate value to the PC value to form a PC-relative address, and writes the result to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "AESD": return { "tooltip": "AES single round decryption.", "html": "AES single round decryption.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "AESE": return { "tooltip": "AES single round encryption.", "html": "AES single round encryption.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "AESIMC": return { "tooltip": "AES inverse mix columns.", "html": "AES inverse mix columns.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "AESMC": return { "tooltip": "AES mix columns.", "html": "AES mix columns.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "AND": case "ANDS": return { "tooltip": "Bitwise AND (immediate) performs a bitwise AND of a register value and an immediate value, and writes the result to the destination register.", "html": "Bitwise AND (immediate) performs a bitwise AND of a register value and an immediate value, and writes the result to the destination register.
If the destination register is not the PC, the ANDS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Bitwise AND (register) performs a bitwise AND of a register value and an optionally-shifted register value, and writes the result to the destination register.
If the destination register is not the PC, the ANDS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Bitwise AND (register-shifted register) performs a bitwise AND of a register value and a register-shifted register value. It writes the result to the destination register, and can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "ASR": return { "tooltip": "Arithmetic Shift Right (immediate) shifts a register value right by an immediate number of bits, shifting in copies of its sign bit, and writes the result to the destination register.", "html": "Arithmetic Shift Right (immediate) shifts a register value right by an immediate number of bits, shifting in copies of its sign bit, and writes the result to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "ASRS": return { "tooltip": "Arithmetic Shift Right, setting flags (immediate) shifts a register value right by an immediate number of bits, shifting in copies of its sign bit, and writes the result to the destination register.", "html": "Arithmetic Shift Right, setting flags (immediate) shifts a register value right by an immediate number of bits, shifting in copies of its sign bit, and writes the result to the destination register.
If the destination register is not the PC, this instruction updates the condition flags based on the result.
The field descriptions for
Branch causes a branch to a target address.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "BFC": return { "tooltip": "Bit Field Clear clears any number of adjacent bits at any position in a register, without affecting the other bits in the register.", "html": "Bit Field Clear clears any number of adjacent bits at any position in a register, without affecting the other bits in the register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "BFI": return { "tooltip": "Bit Field Insert copies any number of low order bits from a register into the same number of adjacent bits at any position in the destination register.", "html": "Bit Field Insert copies any number of low order bits from a register into the same number of adjacent bits at any position in the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "BIC": case "BICS": return { "tooltip": "Bitwise Bit Clear (immediate) performs a bitwise AND of a register value and the complement of an immediate value, and writes the result to the destination register.", "html": "Bitwise Bit Clear (immediate) performs a bitwise AND of a register value and the complement of an immediate value, and writes the result to the destination register.
If the destination register is not the PC, the BICS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Bitwise Bit Clear (register) performs a bitwise AND of a register value and the complement of an optionally-shifted register value, and writes the result to the destination register.
If the destination register is not the PC, the BICS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Bitwise Bit Clear (register-shifted register) performs a bitwise AND of a register value and the complement of a register-shifted register value. It writes the result to the destination register, and can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "BKPT": return { "tooltip": "Breakpoint causes a Breakpoint Instruction exception.", "html": "Breakpoint causes a Breakpoint Instruction exception.
Breakpoint is always unconditional, even when inside an IT block.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "BL": case "BLX": return { "tooltip": "Branch with Link calls a subroutine at a PC-relative address, and setting LR to the return address.", "html": "Branch with Link calls a subroutine at a PC-relative address, and setting LR to the return address.
Branch with Link and Exchange Instruction Sets (immediate) calls a subroutine at a PC-relative address, setting LR to the return address, and changes the instruction set from A32 to T32, or from T32 to A32.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "BLX": return { "tooltip": "Branch with Link and Exchange (register) calls a subroutine at an address specified in the register, and if necessary changes to the instruction set indicated by bit[0] of the register value. If the value in bit[0] is 0, the instruction set after the branch will be A32. If the value in bit[0] is 1, the instruction set after the branch will be T32.", "html": "Branch with Link and Exchange (register) calls a subroutine at an address specified in the register, and if necessary changes to the instruction set indicated by bit[0] of the register value. If the value in bit[0] is 0, the instruction set after the branch will be A32. If the value in bit[0] is 1, the instruction set after the branch will be T32.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "BX": return { "tooltip": "Branch and Exchange causes a branch to an address and instruction set specified by a register.", "html": "Branch and Exchange causes a branch to an address and instruction set specified by a register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "BXJ": return { "tooltip": "Branch and Exchange, previously Branch and Exchange Jazelle.", "html": "Branch and Exchange, previously Branch and Exchange Jazelle.
Compare and Branch on Nonzero and Compare and Branch on Zero compare the value in a register with zero, and conditionally branch forward a constant value. They do not affect the condition flags.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "CLRBHB": return { "tooltip": "Clear Branch History clears the branch history for the current context to the extent that branch history information created before the CLRBHB instruction cannot be used by code before the CLRBHB instruction to exploitatively control the execution of any indirect branches in code in the current context that appear in program order after the instruction.", "html": "Clear Branch History clears the branch history for the current context to the extent that branch history information created before the
Clear-Exclusive clears the local monitor of the executing PE.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "CLZ": return { "tooltip": "Count Leading Zeros returns the number of binary zero bits before the first binary one bit in a value.", "html": "Count Leading Zeros returns the number of binary zero bits before the first binary one bit in a value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "CMN": return { "tooltip": "Compare Negative (immediate) adds a register value and an immediate value. It updates the condition flags based on the result, and discards the result.", "html": "Compare Negative (immediate) adds a register value and an immediate value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "CMN": return { "tooltip": "Compare Negative (register) adds a register value and an optionally-shifted register value. It updates the condition flags based on the result, and discards the result.", "html": "Compare Negative (register) adds a register value and an optionally-shifted register value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "CMN": return { "tooltip": "Compare Negative (register-shifted register) adds a register value and a register-shifted register value. It updates the condition flags based on the result, and discards the result.", "html": "Compare Negative (register-shifted register) adds a register value and a register-shifted register value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "CMP": return { "tooltip": "Compare (immediate) subtracts an immediate value from a register value. It updates the condition flags based on the result, and discards the result.", "html": "Compare (immediate) subtracts an immediate value from a register value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "CMP": return { "tooltip": "Compare (register) subtracts an optionally-shifted register value from a register value. It updates the condition flags based on the result, and discards the result.", "html": "Compare (register) subtracts an optionally-shifted register value from a register value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "CMP": return { "tooltip": "Compare (register-shifted register) subtracts a register-shifted register value from a register value. It updates the condition flags based on the result, and discards the result.", "html": "Compare (register-shifted register) subtracts a register-shifted register value from a register value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "CPS": case "CPSID": case "CPSIE": return { "tooltip": "Change PE State changes one or more of the PSTATE.{A, I, F} interrupt mask bits and, optionally, the PSTATE.M mode field, without changing any other PSTATE bits.", "html": "Change PE State changes one or more of the
The PE checks whether the value being written to PSTATE.M is legal. See
In an Armv8.0 implementation, this is an
In an Armv8.0 implementation, this is an
Consumption of Speculative Data Barrier is a memory barrier that controls speculative execution and data value prediction.
No instruction other than branch instructions and instructions that write to the PC appearing in program order after the CSDB can be speculatively executed using the results of any:
For purposes of the definition of CSDB, PSTATE.{N,Z,C,V} is not considered a data value. This definition permits:
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "DBG": return { "tooltip": "DBG executes as a NOP. Arm deprecates any use of the DBG instruction.", "html": "Debug Change PE State to EL1 allows the debugger to move the PE into EL1 from EL0 or to a specific mode at the current Exception level.
When the PE executes
When the PE executes
For more information on the operation of the DCPS<n> instructions, see
Debug Change PE State to EL2 allows the debugger to move the PE into EL2 from a lower Exception level.
When the PE executes
For more information on the operation of the DCPS<n> instructions, see
Debug Change PE State to EL3 allows the debugger to move the PE into EL3 from a lower Exception level or to a specific mode at the current Exception level.
When the PE executes
For more information on the operation of the DCPS<n> instructions, see
Data Memory Barrier is a memory barrier that ensures the ordering of observations of memory accesses, see
Data Synchronization Barrier is a memory barrier that ensures the completion of memory accesses, see
An AArch32 DSB instruction does not require the completion of any AArch64 TLB maintenance instructions, regardless of the nXS qualifier, appearing in program order before the AArch32 DSB.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "EOR": case "EORS": return { "tooltip": "Bitwise Exclusive-OR (immediate) performs a bitwise exclusive-OR of a register value and an immediate value, and writes the result to the destination register.", "html": "Bitwise Exclusive-OR (immediate) performs a bitwise exclusive-OR of a register value and an immediate value, and writes the result to the destination register.
If the destination register is not the PC, the EORS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Bitwise Exclusive-OR (register) performs a bitwise exclusive-OR of a register value and an optionally-shifted register value, and writes the result to the destination register.
If the destination register is not the PC, the EORS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Bitwise Exclusive-OR (register-shifted register) performs a bitwise exclusive-OR of a register value and a register-shifted register value. It writes the result to the destination register, and can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "ERET": return { "tooltip": "Exception Return.", "html": "Exception Return.
The PE branches to the address held in the register holding the preferred return address, and restores
The register holding the preferred return address is:
The PE checks SPSR_<current_mode> for an illegal return event. See
Exception Return is
Error Synchronization Barrier is an error synchronization event that might also update DISR and VDISR. This instruction can be used at all Exception levels and in Debug state.
In Debug state, this instruction behaves as if SError interrupts are masked at all Exception levels. See Error Synchronization Barrier in the ARM(R) Reliability, Availability, and Serviceability (RAS) Specification, Armv8, for Armv8-A architecture profile.
If the RAS Extension is not implemented, this instruction executes as a
FLDMDBX is the Decrement Before variant of this instruction, and FLDMIAX is the Increment After variant. FLDM*X loads multiple SIMD&FP registers from consecutive locations in the Advanced SIMD and floating-point register file using an address from a general-purpose register.
Arm deprecates use of FLDMDBX and FLDMIAX, except for disassembly purposes, and reassembly of disassembled code.
Depending on settings in the
FSTMX stores multiple SIMD&FP registers from the Advanced SIMD and floating-point register file to consecutive locations in using an address from a general-purpose register.
Arm deprecates use of FSTMDBX and FSTMIAX, except for disassembly purposes, and reassembly of disassembled code.
Depending on settings in the
Halting breakpoint causes a software breakpoint to occur.
Halting breakpoint is always unconditional, even inside an IT block.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "HVC": return { "tooltip": "Hypervisor Call causes a Hypervisor Call exception. For more information, see Hypervisor Call (HVC) exception. Software executing at EL1 can use this instruction to call the hypervisor to request a service.", "html": "Hypervisor Call causes a Hypervisor Call exception. For more information, see
The
The
On executing an
Instruction Synchronization Barrier flushes the pipeline in the PE and is a context synchronization event. For more information, see
If-Then makes up to four following instructions (the IT block) conditional. The conditions for the instructions in the IT block are the same as, or the inverse of, the condition the
The
16-bit instructions in the IT block, other than
The architecture permits exception return to an instruction in the IT block only if the restoration of the
Many uses of the IT instruction are deprecated for performance reasons, and an implementation might include ITD controls that can disable those uses of IT, making them
Load-Acquire Word loads a word from memory and writes it to a register. The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Load-Acquire Byte loads a byte from memory, zero-extends it to form a 32-bit word and writes it to a register. The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Load-Acquire Exclusive Word loads a word from memory, writes it to a register and:
The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Load-Acquire Exclusive Byte loads a byte from memory, zero-extends it to form a 32-bit word, writes it to a register and:
The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Load-Acquire Exclusive Doubleword loads a doubleword from memory, writes it to two registers and:
The instruction also acts as a barrier instruction with the ordering requirements described in
For more information about support for shared memory see
Load-Acquire Exclusive Halfword loads a halfword from memory, zero-extends it to form a 32-bit word, writes it to a register and:
The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Load-Acquire Halfword loads a halfword from memory, zero-extends it to form a 32-bit word and writes it to a register. The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Load data to System register (immediate) calculates an address from a base register value and an immediate offset, loads a word from memory, and writes it to the
In an implementation that includes EL2, the permitted
For simplicity, the
Load data to System register (literal) calculates an address from the PC value and an immediate offset, loads a word from memory, and writes it to the
In an implementation that includes EL2, the permitted
For simplicity, the
Load Multiple (Increment After, Full Descending) loads multiple registers from consecutive memory locations using an address from a base register. The consecutive memory locations start at this address, and the address just above the highest of those locations can optionally be written back to the base register.
The lowest-numbered register is loaded from the lowest memory address, through to the highest-numbered register from the highest memory address. See also
Armv8.2 permits the deprecation of some Load Multiple ordering behaviors in AArch32 state, for more information see
Load Multiple (exception return) loads multiple registers from consecutive memory locations using an address from a base register. The
The registers loaded include the PC. The word loaded for the PC is treated as an address and a branch occurs to that address.
The PE checks the encoding that is copied to the
Load Multiple (exception return) is:
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "LDM": return { "tooltip": "In an EL1 mode other than System mode, Load Multiple (User registers) loads multiple User mode registers from consecutive memory locations using an address from a base register. The registers loaded cannot include the PC. The PE reads the base register value normally, using the current mode to determine the correct Banked version of the register. This instruction cannot writeback to the base register.", "html": "In an EL1 mode other than System mode, Load Multiple (User registers) loads multiple User mode registers from consecutive memory locations using an address from a base register. The registers loaded cannot include the PC. The PE reads the base register value normally, using the current mode to determine the correct Banked version of the register. This instruction cannot writeback to the base register.
Load Multiple (User registers) is
Armv8.2 permits the deprecation of some Load Multiple ordering behaviors in AArch32 state, for more information see
Load Multiple Decrement After (Full Ascending) loads multiple registers from consecutive memory locations using an address from a base register. The consecutive memory locations end at this address, and the address just below the lowest of those locations can optionally be written back to the base register.
The lowest-numbered register is loaded from the lowest memory address, through to the highest-numbered register from the highest memory address. See also
Armv8.2 permits the deprecation of some Load Multiple ordering behaviors in AArch32 state, for more information see
Load Multiple Decrement Before (Empty Ascending) loads multiple registers from consecutive memory locations using an address from a base register. The consecutive memory locations end just below this address, and the address of the lowest of those locations can optionally be written back to the base register.
The lowest-numbered register is loaded from the lowest memory address, through to the highest-numbered register from the highest memory address. See also
Armv8.2 permits the deprecation of some Load Multiple ordering behaviors in AArch32 state, for more information see
Load Multiple Increment Before (Empty Descending) loads multiple registers from consecutive memory locations using an address from a base register. The consecutive memory locations start just above this address, and the address of the last of those locations can optionally be written back to the base register.
The lowest-numbered register is loaded from the lowest memory address, through to the highest-numbered register from the highest memory address. See also
Armv8.2 permits the deprecation of some Load Multiple ordering behaviors in AArch32 state, for more information see
Load Register (immediate) calculates an address from a base register value and an immediate offset, loads a word from memory, and writes it to a register. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Load Register (literal) calculates an address from the PC value and an immediate offset, loads a word from memory, and writes it to a register. For information about memory accesses see
Load Register (register) calculates an address from a base register value and an offset register value, loads a word from memory, and writes it to a register. The offset register value can optionally be shifted. For information about memory accesses, see
The T32 form of
Load Register Byte (immediate) calculates an address from a base register value and an immediate offset, loads a byte from memory, zero-extends it to form a 32-bit word, and writes it to a register. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Load Register Byte (literal) calculates an address from the PC value and an immediate offset, loads a byte from memory, zero-extends it to form a 32-bit word, and writes it to a register. For information about memory accesses see
Load Register Byte (register) calculates an address from a base register value and an offset register value, loads a byte from memory, zero-extends it to form a 32-bit word, and writes it to a register. The offset register value can optionally be shifted. For information about memory accesses see
Load Register Byte Unprivileged loads a byte from memory, zero-extends it to form a 32-bit word, and writes it to a register. For information about memory accesses see
The memory access is restricted as if the PE were running in User mode. This makes no difference if the PE is actually running in User mode.
The T32 instruction uses an offset addressing mode, that calculates the address used for the memory access from a base register value and an immediate offset, and leaves the base register unchanged.
The A32 instruction uses a post-indexed addressing mode, that uses a base register value as the address for the memory access, and calculates a new address from a base register value and an offset and writes it back to the base register. The offset can be an immediate value or an optionally-shifted register value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "LDRD": return { "tooltip": "Load Register Dual (immediate) calculates an address from a base register value and an immediate offset, loads two words from memory, and writes them to two registers. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see Memory accesses.", "html": "Load Register Dual (immediate) calculates an address from a base register value and an immediate offset, loads two words from memory, and writes them to two registers. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Load Register Dual (literal) calculates an address from the PC value and an immediate offset, loads two words from memory, and writes them to two registers. For information about memory accesses see
Load Register Dual (register) calculates an address from a base register value and a register offset, loads two words from memory, and writes them to two registers. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Load Register Exclusive calculates an address from a base register value and an immediate offset, loads a word from memory, writes it to a register and:
For more information about support for shared memory see
Load Register Exclusive Byte derives an address from a base register value, loads a byte from memory, zero-extends it to form a 32-bit word, writes it to a register and:
For more information about support for shared memory see
Load Register Exclusive Doubleword derives an address from a base register value, loads a 64-bit doubleword from memory, writes it to two registers and:
For more information about support for shared memory see
Load Register Exclusive Halfword derives an address from a base register value, loads a halfword from memory, zero-extends it to form a 32-bit word, writes it to a register and:
For more information about support for shared memory see
Load Register Halfword (immediate) calculates an address from a base register value and an immediate offset, loads a halfword from memory, zero-extends it to form a 32-bit word, and writes it to a register. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Load Register Halfword (literal) calculates an address from the PC value and an immediate offset, loads a halfword from memory, zero-extends it to form a 32-bit word, and writes it to a register. For information about memory accesses see
Load Register Halfword (register) calculates an address from a base register value and an offset register value, loads a halfword from memory, zero-extends it to form a 32-bit word, and writes it to a register. The offset register value can be shifted left by 0, 1, 2, or 3 bits. For information about memory accesses see
Load Register Halfword Unprivileged loads a halfword from memory, zero-extends it to form a 32-bit word, and writes it to a register. For information about memory accesses see
The memory access is restricted as if the PE were running in User mode. This makes no difference if the PE is actually running in User mode.
The T32 instruction uses an offset addressing mode, that calculates the address used for the memory access from a base register value and an immediate offset, and leaves the base register unchanged.
The A32 instruction uses a post-indexed addressing mode, that uses a base register value as the address for the memory access, and calculates a new address from a base register value and an offset and writes it back to the base register. The offset can be an immediate value or a register value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "LDRSB": return { "tooltip": "Load Register Signed Byte (immediate) calculates an address from a base register value and an immediate offset, loads a byte from memory, sign-extends it to form a 32-bit word, and writes it to a register. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see Memory accesses.", "html": "Load Register Signed Byte (immediate) calculates an address from a base register value and an immediate offset, loads a byte from memory, sign-extends it to form a 32-bit word, and writes it to a register. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Load Register Signed Byte (literal) calculates an address from the PC value and an immediate offset, loads a byte from memory, sign-extends it to form a 32-bit word, and writes it to a register. For information about memory accesses see
Load Register Signed Byte (register) calculates an address from a base register value and an offset register value, loads a byte from memory, sign-extends it to form a 32-bit word, and writes it to a register. The offset register value can be shifted left by 0, 1, 2, or 3 bits. For information about memory accesses see
Load Register Signed Byte Unprivileged loads a byte from memory, sign-extends it to form a 32-bit word, and writes it to a register. For information about memory accesses see
The memory access is restricted as if the PE were running in User mode. This makes no difference if the PE is actually running in User mode.
The T32 instruction uses an offset addressing mode, that calculates the address used for the memory access from a base register value and an immediate offset, and leaves the base register unchanged.
The A32 instruction uses a post-indexed addressing mode, that uses a base register value as the address for the memory access, and calculates a new address from a base register value and an offset and writes it back to the base register. The offset can be an immediate value or a register value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "LDRSH": return { "tooltip": "Load Register Signed Halfword (immediate) calculates an address from a base register value and an immediate offset, loads a halfword from memory, sign-extends it to form a 32-bit word, and writes it to a register. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see Memory accesses.", "html": "Load Register Signed Halfword (immediate) calculates an address from a base register value and an immediate offset, loads a halfword from memory, sign-extends it to form a 32-bit word, and writes it to a register. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Load Register Signed Halfword (literal) calculates an address from the PC value and an immediate offset, loads a halfword from memory, sign-extends it to form a 32-bit word, and writes it to a register. For information about memory accesses see
Load Register Signed Halfword (register) calculates an address from a base register value and an offset register value, loads a halfword from memory, sign-extends it to form a 32-bit word, and writes it to a register. The offset register value can be shifted left by 0, 1, 2, or 3 bits. For information about memory accesses see
Load Register Signed Halfword Unprivileged loads a halfword from memory, sign-extends it to form a 32-bit word, and writes it to a register. For information about memory accesses see
The memory access is restricted as if the PE were running in User mode. This makes no difference if the PE is actually running in User mode.
The T32 instruction uses an offset addressing mode, that calculates the address used for the memory access from a base register value and an immediate offset, and leaves the base register unchanged.
The A32 instruction uses a post-indexed addressing mode, that uses a base register value as the address for the memory access, and calculates a new address from a base register value and an offset and writes it back to the base register. The offset can be an immediate value or a register value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "LDRT": return { "tooltip": "Load Register Unprivileged loads a word from memory, and writes it to a register. For information about memory accesses see Memory accesses.", "html": "Load Register Unprivileged loads a word from memory, and writes it to a register. For information about memory accesses see
The memory access is restricted as if the PE were running in User mode. This makes no difference if the PE is actually running in User mode.
The T32 instruction uses an offset addressing mode, that calculates the address used for the memory access from a base register value and an immediate offset, and leaves the base register unchanged.
The A32 instruction uses a post-indexed addressing mode, that uses a base register value as the address for the memory access, and calculates a new address from a base register value and an offset and writes it back to the base register. The offset can be an immediate value or an optionally-shifted register value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "LSL": return { "tooltip": "Logical Shift Left (immediate) shifts a register value left by an immediate number of bits, shifting in zeros, and writes the result to the destination register.", "html": "Logical Shift Left (immediate) shifts a register value left by an immediate number of bits, shifting in zeros, and writes the result to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "LSLS": return { "tooltip": "Logical Shift Left, setting flags (immediate) shifts a register value left by an immediate number of bits, shifting in zeros, and writes the result to the destination register.", "html": "Logical Shift Left, setting flags (immediate) shifts a register value left by an immediate number of bits, shifting in zeros, and writes the result to the destination register.
If the destination register is not the PC, this instruction updates the condition flags based on the result.
The field descriptions for
Logical Shift Right (immediate) shifts a register value right by an immediate number of bits, shifting in zeros, and writes the result to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "LSRS": return { "tooltip": "Logical Shift Right, setting flags (immediate) shifts a register value right by an immediate number of bits, shifting in zeros, and writes the result to the destination register.", "html": "Logical Shift Right, setting flags (immediate) shifts a register value right by an immediate number of bits, shifting in zeros, and writes the result to the destination register.
If the destination register is not the PC, this instruction updates the condition flags based on the result.
The field descriptions for
Move to System register from general-purpose register or execute a System instruction. This instruction copies the value of a general-purpose register to a System register, or executes a System instruction.
The System register and System instruction descriptions identify valid encodings for this instruction. Other encodings are
In an implementation that includes EL2,
Because of the range of possible traps to Hyp mode, the
Move to System register from two general-purpose registers. This instruction copies the values of two general-purpose registers to a System register.
The System register descriptions identify valid encodings for this instruction. Other encodings are
In an implementation that includes EL2,
Because of the range of possible traps to Hyp mode, the
Multiply Accumulate multiplies two register values, and adds a third register value. The least significant 32 bits of the result are written to the destination register. These 32 bits do not depend on whether the source register values are considered to be signed values or unsigned values.
In an A32 instruction, the condition flags can optionally be updated based on the result. Use of this option adversely affects performance on many implementations.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "MLS": return { "tooltip": "Multiply and Subtract multiplies two register values, and subtracts the product from a third register value. The least significant 32 bits of the result are written to the destination register. These 32 bits do not depend on whether the source register values are considered to be signed values or unsigned values.", "html": "Multiply and Subtract multiplies two register values, and subtracts the product from a third register value. The least significant 32 bits of the result are written to the destination register. These 32 bits do not depend on whether the source register values are considered to be signed values or unsigned values.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "MOV": case "MOVS": return { "tooltip": "Move (immediate) writes an immediate value to the destination register.", "html": "Move (immediate) writes an immediate value to the destination register.
If the destination register is not the PC, the MOVS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Move (register) copies a value from a register to the destination register.
If the destination register is not the PC, the MOVS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Move (register-shifted register) copies a register-shifted register value to the destination register. It can optionally update the condition flags based on the value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "MOVT": return { "tooltip": "Move Top writes an immediate value to the top halfword of the destination register. It does not affect the contents of the bottom halfword.", "html": "Move Top writes an immediate value to the top halfword of the destination register. It does not affect the contents of the bottom halfword.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "MRC": return { "tooltip": "Move to general-purpose register from System register. This instruction copies the value of a System register to a general-purpose register.", "html": "Move to general-purpose register from System register. This instruction copies the value of a System register to a general-purpose register.
The System register descriptions identify valid encodings for this instruction. Other encodings are
In an implementation that includes EL2,
Because of the range of possible traps to Hyp mode, the
Move to two general-purpose registers from System register. This instruction copies the value of a System register to two general-purpose registers.
The System register descriptions identify valid encodings for this instruction. Other encodings are
In an implementation that includes EL2,
Because of the range of possible traps to Hyp mode, the
Move Special register to general-purpose register moves the value of the
Arm recommends the
An
An
Move to Register from Banked or Special register moves the value from the Banked general-purpose register or
When EL3 is using AArch64, if an MRS (Banked register) instruction that is executed in a Secure EL1 mode would access SPSR_mon, SP_mon, or LR_mon, it is trapped to EL3.
The effect of using an
Move to Banked or Special register from general-purpose register moves the value of a general-purpose register to the Banked general-purpose register or
When EL3 is using AArch64, if an MSR (Banked register) instruction that is executed in a Secure EL1 mode would access SPSR_mon, SP_mon, or LR_mon, it is trapped to EL3.
The effect of using an
Move immediate value to Special register moves selected bits of an immediate value to the corresponding bits in the
Because of the Do-Not-Modify nature of its reserved bits, the immediate form of
If an
An
An
Move general-purpose register to Special register moves selected bits of a general-purpose register to the
Because of the Do-Not-Modify nature of its reserved bits, a read-modify-write sequence is normally required when the
If an
An
An
Multiply multiplies two register values. The least significant 32 bits of the result are written to the destination register. These 32 bits do not depend on whether the source register values are considered to be signed values or unsigned values.
Optionally, it can update the condition flags based on the result. In the T32 instruction set, this option is limited to only a few forms of the instruction. Use of this option adversely affects performance on many implementations.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "MVN": case "MVNS": return { "tooltip": "Bitwise NOT (immediate) writes the bitwise inverse of an immediate value to the destination register.", "html": "Bitwise NOT (immediate) writes the bitwise inverse of an immediate value to the destination register.
If the destination register is not the PC, the MVNS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Bitwise NOT (register) writes the bitwise inverse of a register value to the destination register.
If the destination register is not the PC, the MVNS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Bitwise NOT (register-shifted register) writes the bitwise inverse of a register-shifted register value to the destination register. It can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "NOP": return { "tooltip": "No Operation does nothing. This instruction can be used for instruction alignment purposes.", "html": "No Operation does nothing. This instruction can be used for instruction alignment purposes.
The timing effects of including a
Bitwise OR NOT (immediate) performs a bitwise (inclusive) OR of a register value and the complement of an immediate value, and writes the result to the destination register. It can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "ORN": case "ORNS": return { "tooltip": "Bitwise OR NOT (register) performs a bitwise (inclusive) OR of a register value and the complement of an optionally-shifted register value, and writes the result to the destination register. It can optionally update the condition flags based on the result.", "html": "Bitwise OR NOT (register) performs a bitwise (inclusive) OR of a register value and the complement of an optionally-shifted register value, and writes the result to the destination register. It can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "ORR": case "ORRS": return { "tooltip": "Bitwise OR (immediate) performs a bitwise (inclusive) OR of a register value and an immediate value, and writes the result to the destination register.", "html": "Bitwise OR (immediate) performs a bitwise (inclusive) OR of a register value and an immediate value, and writes the result to the destination register.
If the destination register is not the PC, the ORRS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Bitwise OR (register) performs a bitwise (inclusive) OR of a register value and an optionally-shifted register value, and writes the result to the destination register.
If the destination register is not the PC, the ORRS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Bitwise OR (register-shifted register) performs a bitwise (inclusive) OR of a register value and a register-shifted register value, and writes the result to the destination register. It can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "PKHBT": case "PKHTB": return { "tooltip": "Pack Halfword combines one halfword of its first operand with the other halfword of its shifted second operand.", "html": "Pack Halfword combines one halfword of its first operand with the other halfword of its shifted second operand.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "PLD": case "PLDW": return { "tooltip": "Preload Data (immediate) signals the memory system that data memory accesses from a specified address are likely in the near future. The memory system can respond by taking actions that are expected to speed up the memory accesses when they do occur, such as preloading the cache line containing the specified address into the data cache.", "html": "Preload Data (immediate) signals the memory system that data memory accesses from a specified address are likely in the near future. The memory system can respond by taking actions that are expected to speed up the memory accesses when they do occur, such as preloading the cache line containing the specified address into the data cache.
The
The effect of a
Preload Data (literal) signals the memory system that data memory accesses from a specified address are likely in the near future. The memory system can respond by taking actions that are expected to speed up the memory accesses when they do occur, such as preloading the cache line containing the specified address into the data cache.
The effect of a
Preload Data (register) signals the memory system that data memory accesses from a specified address are likely in the near future. The memory system can respond by taking actions that are expected to speed up the memory accesses when they do occur, such as preloading the cache line containing the specified address into the data cache.
The
The effect of a
Preload Instruction signals the memory system that instruction memory accesses from a specified address are likely in the near future. The memory system can respond by taking actions that are expected to speed up the memory accesses when they do occur, such as pre-loading the cache line containing the specified address into the instruction cache.
The effect of a
Preload Instruction signals the memory system that instruction memory accesses from a specified address are likely in the near future. The memory system can respond by taking actions that are expected to speed up the memory accesses when they do occur, such as pre-loading the cache line containing the specified address into the instruction cache.
The effect of a
Pop Multiple Registers from Stack loads multiple general-purpose registers from the stack, loading from consecutive memory locations starting at the address in SP, and updates SP to point just above the loaded data.
The lowest-numbered register is loaded from the lowest memory address, through to the highest-numbered register from the highest memory address. See also
The registers loaded can include the PC, causing a branch to a loaded address. This is an interworking branch, see
Physical Speculative Store Bypass Barrier is a memory barrier that prevents speculative loads from bypassing earlier stores to the same physical address under certain conditions. For more information and details of the semantics, see
Push Multiple Registers to Stack stores multiple general-purpose registers to the stack, storing to consecutive memory locations ending just below the address in SP, and updates SP to point to the start of the stored data.
The lowest-numbered register is stored to the lowest memory address, through to the highest-numbered register to the highest memory address. See also
Saturating Add adds two register values, saturates the result to the 32-bit signed integer range -231 to (231 - 1), and writes the result to the destination register. If saturation occurs, it sets
Saturating Add 16 performs two 16-bit integer additions, saturates the results to the 16-bit signed integer range -215 <= x <= 215 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "QADD8": return { "tooltip": "Saturating Add 8 performs four 8-bit integer additions, saturates the results to the 8-bit signed integer range -27 <= x <= 27 - 1, and writes the results to the destination register.", "html": "Saturating Add 8 performs four 8-bit integer additions, saturates the results to the 8-bit signed integer range -27 <= x <= 27 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "QASX": return { "tooltip": "Saturating Add and Subtract with Exchange exchanges the two halfwords of the second operand, performs one 16-bit integer addition and one 16-bit subtraction, saturates the results to the 16-bit signed integer range -215 <= x <= 215 - 1, and writes the results to the destination register.", "html": "Saturating Add and Subtract with Exchange exchanges the two halfwords of the second operand, performs one 16-bit integer addition and one 16-bit subtraction, saturates the results to the 16-bit signed integer range -215 <= x <= 215 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "QDADD": return { "tooltip": "Saturating Double and Add adds a doubled register value to another register value, and writes the result to the destination register. Both the doubling and the addition have their results saturated to the 32-bit signed integer range -231 <= x <= 231 - 1. If saturation occurs in either operation, it sets PSTATE.Q to 1.", "html": "Saturating Double and Add adds a doubled register value to another register value, and writes the result to the destination register. Both the doubling and the addition have their results saturated to the 32-bit signed integer range -231 <= x <= 231 - 1. If saturation occurs in either operation, it sets
Saturating Double and Subtract subtracts a doubled register value from another register value, and writes the result to the destination register. Both the doubling and the subtraction have their results saturated to the 32-bit signed integer range -231 <= x <= 231 - 1. If saturation occurs in either operation, it sets
Saturating Subtract and Add with Exchange exchanges the two halfwords of the second operand, performs one 16-bit integer subtraction and one 16-bit addition, saturates the results to the 16-bit signed integer range -215 <= x <= 215 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "QSUB": return { "tooltip": "Saturating Subtract subtracts one register value from another register value, saturates the result to the 32-bit signed integer range -231 <= x <= 231 - 1, and writes the result to the destination register. If saturation occurs, it sets PSTATE.Q to 1.", "html": "Saturating Subtract subtracts one register value from another register value, saturates the result to the 32-bit signed integer range -231 <= x <= 231 - 1, and writes the result to the destination register. If saturation occurs, it sets
Saturating Subtract 16 performs two 16-bit integer subtractions, saturates the results to the 16-bit signed integer range -215 <= x <= 215 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "QSUB8": return { "tooltip": "Saturating Subtract 8 performs four 8-bit integer subtractions, saturates the results to the 8-bit signed integer range -27 <= x <= 27 - 1, and writes the results to the destination register.", "html": "Saturating Subtract 8 performs four 8-bit integer subtractions, saturates the results to the 8-bit signed integer range -27 <= x <= 27 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "RBIT": return { "tooltip": "Reverse Bits reverses the bit order in a 32-bit register.", "html": "Reverse Bits reverses the bit order in a 32-bit register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "REV": return { "tooltip": "Byte-Reverse Word reverses the byte order in a 32-bit register.", "html": "Byte-Reverse Word reverses the byte order in a 32-bit register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "REV16": return { "tooltip": "Byte-Reverse Packed Halfword reverses the byte order in each16-bit halfword of a 32-bit register.", "html": "Byte-Reverse Packed Halfword reverses the byte order in each16-bit halfword of a 32-bit register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "REVSH": return { "tooltip": "Byte-Reverse Signed Halfword reverses the byte order in the lower 16-bit halfword of a 32-bit register, and sign-extends the result to 32 bits.", "html": "Byte-Reverse Signed Halfword reverses the byte order in the lower 16-bit halfword of a 32-bit register, and sign-extends the result to 32 bits.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "RFE": case "RFEDA": case "RFEDB": case "RFEIA": case "RFEIB": return { "tooltip": "Return From Exception loads two consecutive memory locations using an address in a base register", "html": "Return From Exception loads two consecutive memory locations using an address in a base register:
An address adjusted by the size of the data loaded can optionally be written back to the base register.
The PE checks the value of the word loaded from the higher address for an illegal return event. See
Rotate Right (immediate) provides the value of the contents of a register rotated by a constant value. The bits that are rotated off the right end are inserted into the vacated bit positions on the left.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "RORS": return { "tooltip": "Rotate Right, setting flags (immediate) provides the value of the contents of a register rotated by a constant value. The bits that are rotated off the right end are inserted into the vacated bit positions on the left.", "html": "Rotate Right, setting flags (immediate) provides the value of the contents of a register rotated by a constant value. The bits that are rotated off the right end are inserted into the vacated bit positions on the left.
If the destination register is not the PC, this instruction updates the condition flags based on the result.
The field descriptions for
Rotate Right with Extend provides the value of the contents of a register shifted right by one place, with the Carry flag shifted into bit[31].
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "RRXS": return { "tooltip": "Rotate Right with Extend, setting flags provides the value of the contents of a register shifted right by one place, with the Carry flag shifted into bit[31].", "html": "Rotate Right with Extend, setting flags provides the value of the contents of a register shifted right by one place, with the Carry flag shifted into bit[31].
If the destination register is not the PC, this instruction updates the condition flags based on the result, and bit[0] is shifted into the Carry flag.
The field descriptions for
Reverse Subtract (immediate) subtracts a register value from an immediate value, and writes the result to the destination register.
If the destination register is not the PC, the RSBS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Reverse Subtract (register) subtracts a register value from an optionally-shifted register value, and writes the result to the destination register.
If the destination register is not the PC, the RSBS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Reverse Subtract (register-shifted register) subtracts a register value from a register-shifted register value, and writes the result to the destination register. It can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "RSC": case "RSCS": return { "tooltip": "Reverse Subtract with Carry (immediate) subtracts a register value and the value of NOT (Carry flag) from an immediate value, and writes the result to the destination register.", "html": "Reverse Subtract with Carry (immediate) subtracts a register value and the value of NOT (Carry flag) from an immediate value, and writes the result to the destination register.
If the destination register is not the PC, the RSCS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Reverse Subtract with Carry (register) subtracts a register value and the value of NOT (Carry flag) from an optionally-shifted register value, and writes the result to the destination register.
If the destination register is not the PC, the RSCS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Reverse Subtract (register-shifted register) subtracts a register value and the value of NOT (Carry flag) from a register-shifted register value, and writes the result to the destination register. It can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SADD16": return { "tooltip": "Signed Add 16 performs two 16-bit signed integer additions, and writes the results to the destination register. It sets PSTATE.GE according to the results of the additions.", "html": "Signed Add 16 performs two 16-bit signed integer additions, and writes the results to the destination register. It sets
Signed Add 8 performs four 8-bit signed integer additions, and writes the results to the destination register. It sets
Signed Add and Subtract with Exchange exchanges the two halfwords of the second operand, performs one 16-bit integer addition and one 16-bit subtraction, and writes the results to the destination register. It sets
Speculation Barrier is a barrier that controls speculation.
The semantics of the Speculation Barrier are that the execution, until the barrier completes, of any instruction that appears later in the program order than the barrier:
In particular, any instruction that appears later in the program order than the barrier cannot cause a speculative allocation into any caching structure where the allocation of that entry could be indicative of any data value present in memory or in the registers.
The SB instruction:
When the prediction of the instruction stream is not informed by data taken from the register outputs of the speculative execution of instructions appearing in program order after an uncompleted SB instruction, the SB instruction has no effect on the use of prediction resources to predict the instruction stream that is being fetched.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SBC": case "SBCS": return { "tooltip": "Subtract with Carry (immediate) subtracts an immediate value and the value of NOT (Carry flag) from a register value, and writes the result to the destination register.", "html": "Subtract with Carry (immediate) subtracts an immediate value and the value of NOT (Carry flag) from a register value, and writes the result to the destination register.
If the destination register is not the PC, the SBCS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Subtract with Carry (register) subtracts an optionally-shifted register value and the value of NOT (Carry flag) from a register value, and writes the result to the destination register.
If the destination register is not the PC, the SBCS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Subtract with Carry (register-shifted register) subtracts a register-shifted register value and the value of NOT (Carry flag) from a register value, and writes the result to the destination register. It can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SBFX": return { "tooltip": "Signed Bit Field Extract extracts any number of adjacent bits at any position from a register, sign-extends them to 32 bits, and writes the result to the destination register.", "html": "Signed Bit Field Extract extracts any number of adjacent bits at any position from a register, sign-extends them to 32 bits, and writes the result to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SDIV": return { "tooltip": "Signed Divide divides a 32-bit signed integer register value by a 32-bit signed integer register value, and writes the result to the destination register. The condition flags are not affected.", "html": "Signed Divide divides a 32-bit signed integer register value by a 32-bit signed integer register value, and writes the result to the destination register. The condition flags are not affected.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SEL": return { "tooltip": "Select Bytes selects each byte of its result from either its first operand or its second operand, according to the values of the PSTATE.GE flags.", "html": "Select Bytes selects each byte of its result from either its first operand or its second operand, according to the values of the
Set Endianness writes a new value to
Set Privileged Access Never writes a new value to
This instruction is available only in privileged mode and it is a NOP when executed in User mode.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SEV": return { "tooltip": "Send Event is a hint instruction. It causes an event to be signaled to all PEs in the multiprocessor system. For more information, see Wait For Event and Send Event.", "html": "Send Event is a hint instruction. It causes an event to be signaled to all PEs in the multiprocessor system. For more information, see
Send Event Local is a hint instruction that causes an event to be signaled locally without requiring the event to be signaled to other PEs in the multiprocessor system. It can prime a wait-loop which starts with a
SHA1 hash update (choose).
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHA1H": return { "tooltip": "SHA1 fixed rotate.", "html": "SHA1 fixed rotate.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHA1M": return { "tooltip": "SHA1 hash update (majority).", "html": "SHA1 hash update (majority).
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHA1P": return { "tooltip": "SHA1 hash update (parity).", "html": "SHA1 hash update (parity).
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHA1SU0": return { "tooltip": "SHA1 schedule update 0.", "html": "SHA1 schedule update 0.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHA1SU1": return { "tooltip": "SHA1 schedule update 1.", "html": "SHA1 schedule update 1.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHA256H": return { "tooltip": "SHA256 hash update part 1.", "html": "SHA256 hash update part 1.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHA256H2": return { "tooltip": "SHA256 hash update part 2.", "html": "SHA256 hash update part 2.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHA256SU0": return { "tooltip": "SHA256 schedule update 0.", "html": "SHA256 schedule update 0.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHA256SU1": return { "tooltip": "SHA256 schedule update 1.", "html": "SHA256 schedule update 1.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHADD16": return { "tooltip": "Signed Halving Add 16 performs two signed 16-bit integer additions, halves the results, and writes the results to the destination register.", "html": "Signed Halving Add 16 performs two signed 16-bit integer additions, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHADD8": return { "tooltip": "Signed Halving Add 8 performs four signed 8-bit integer additions, halves the results, and writes the results to the destination register.", "html": "Signed Halving Add 8 performs four signed 8-bit integer additions, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHASX": return { "tooltip": "Signed Halving Add and Subtract with Exchange exchanges the two halfwords of the second operand, performs one signed 16-bit integer addition and one signed 16-bit subtraction, halves the results, and writes the results to the destination register.", "html": "Signed Halving Add and Subtract with Exchange exchanges the two halfwords of the second operand, performs one signed 16-bit integer addition and one signed 16-bit subtraction, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHSAX": return { "tooltip": "Signed Halving Subtract and Add with Exchange exchanges the two halfwords of the second operand, performs one signed 16-bit integer subtraction and one signed 16-bit addition, halves the results, and writes the results to the destination register.", "html": "Signed Halving Subtract and Add with Exchange exchanges the two halfwords of the second operand, performs one signed 16-bit integer subtraction and one signed 16-bit addition, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHSUB16": return { "tooltip": "Signed Halving Subtract 16 performs two signed 16-bit integer subtractions, halves the results, and writes the results to the destination register.", "html": "Signed Halving Subtract 16 performs two signed 16-bit integer subtractions, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SHSUB8": return { "tooltip": "Signed Halving Subtract 8 performs four signed 8-bit integer subtractions, halves the results, and writes the results to the destination register.", "html": "Signed Halving Subtract 8 performs four signed 8-bit integer subtractions, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SMC": return { "tooltip": "Secure Monitor Call causes a Secure Monitor Call exception. For more information see Secure Monitor Call (SMC) exception.", "html": "Secure Monitor Call causes a Secure Monitor Call exception. For more information see
If the values of
If the value of
If the value of
Signed Multiply Accumulate (halfwords) performs a signed multiply accumulate operation. The multiply acts on two signed 16-bit quantities, taken from either the bottom or the top half of their respective source registers. The other halves of these source registers are ignored. The 32-bit product is added to a 32-bit accumulate value and the result is written to the destination register.
If overflow occurs during the addition of the accumulate value, the instruction sets
Signed Multiply Accumulate Dual performs two signed 16 x 16-bit multiplications. It adds the products to a 32-bit accumulate operand.
Optionally, the instruction can exchange the halfwords of the second operand before performing the arithmetic. This produces top x bottom and bottom x top multiplication.
This instruction sets
Signed Multiply Accumulate Long multiplies two signed 32-bit values to produce a 64-bit value, and accumulates this with a 64-bit value.
In A32 instructions, the condition flags can optionally be updated based on the result. Use of this option adversely affects performance on many implementations.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SMLALBB": case "SMLALBT": case "SMLALTB": case "SMLALTT": return { "tooltip": "Signed Multiply Accumulate Long (halfwords) multiplies two signed 16-bit values to produce a 32-bit value, and accumulates this with a 64-bit value. The multiply acts on two signed 16-bit quantities, taken from either the bottom or the top half of their respective source registers. The other halves of these source registers are ignored. The 32-bit product is sign-extended and accumulated with a 64-bit accumulate value.", "html": "Signed Multiply Accumulate Long (halfwords) multiplies two signed 16-bit values to produce a 32-bit value, and accumulates this with a 64-bit value. The multiply acts on two signed 16-bit quantities, taken from either the bottom or the top half of their respective source registers. The other halves of these source registers are ignored. The 32-bit product is sign-extended and accumulated with a 64-bit accumulate value.
Overflow is possible during this instruction, but only as a result of the 64-bit addition. This overflow is not detected if it occurs. Instead, the result wraps around modulo 264.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SMLALD": case "SMLALDX": return { "tooltip": "Signed Multiply Accumulate Long Dual performs two signed 16 x 16-bit multiplications. It adds the products to a 64-bit accumulate operand.", "html": "Signed Multiply Accumulate Long Dual performs two signed 16 x 16-bit multiplications. It adds the products to a 64-bit accumulate operand.
Optionally, the instruction can exchange the halfwords of the second operand before performing the arithmetic. This produces top x bottom and bottom x top multiplication.
Overflow is possible during this instruction, but only as a result of the 64-bit addition. This overflow is not detected if it occurs. Instead, the result wraps around modulo 264.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SMLAWB": case "SMLAWT": return { "tooltip": "Signed Multiply Accumulate (word by halfword) performs a signed multiply accumulate operation. The multiply acts on a signed 32-bit quantity and a signed 16-bit quantity. The signed 16-bit quantity is taken from either the bottom or the top half of its source register. The other half of the second source register is ignored. The top 32 bits of the 48-bit product are added to a 32-bit accumulate value and the result is written to the destination register. The bottom 16 bits of the 48-bit product are ignored.", "html": "Signed Multiply Accumulate (word by halfword) performs a signed multiply accumulate operation. The multiply acts on a signed 32-bit quantity and a signed 16-bit quantity. The signed 16-bit quantity is taken from either the bottom or the top half of its source register. The other half of the second source register is ignored. The top 32 bits of the 48-bit product are added to a 32-bit accumulate value and the result is written to the destination register. The bottom 16 bits of the 48-bit product are ignored.
If overflow occurs during the addition of the accumulate value, the instruction sets
Signed Multiply Subtract Dual performs two signed 16 x 16-bit multiplications. It adds the difference of the products to a 32-bit accumulate operand.
Optionally, the instruction can exchange the halfwords of the second operand before performing the arithmetic. This produces top x bottom and bottom x top multiplication.
This instruction sets
Signed Multiply Subtract Long Dual performs two signed 16 x 16-bit multiplications. It adds the difference of the products to a 64-bit accumulate operand.
Optionally, the instruction can exchange the halfwords of the second operand before performing the arithmetic. This produces top x bottom and bottom x top multiplication.
Overflow is possible during this instruction, but only as a result of the 64-bit addition. This overflow is not detected if it occurs. Instead, the result wraps around modulo 264.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SMMLA": case "SMMLAR": return { "tooltip": "Signed Most Significant Word Multiply Accumulate multiplies two signed 32-bit values, extracts the most significant 32 bits of the result, and adds an accumulate value.", "html": "Signed Most Significant Word Multiply Accumulate multiplies two signed 32-bit values, extracts the most significant 32 bits of the result, and adds an accumulate value.
Optionally, the instruction can specify that the result is rounded instead of being truncated. In this case, the constant
Signed Most Significant Word Multiply Subtract multiplies two signed 32-bit values, subtracts the result from a 32-bit accumulate value that is shifted left by 32 bits, and extracts the most significant 32 bits of the result of that subtraction.
Optionally, the instruction can specify that the result of the instruction is rounded instead of being truncated. In this case, the constant
Signed Most Significant Word Multiply multiplies two signed 32-bit values, extracts the most significant 32 bits of the result, and writes those bits to the destination register.
Optionally, the instruction can specify that the result is rounded instead of being truncated. In this case, the constant
Signed Dual Multiply Add performs two signed 16 x 16-bit multiplications. It adds the products together, and writes the result to the destination register.
Optionally, the instruction can exchange the halfwords of the second operand before performing the arithmetic. This produces top x bottom and bottom x top multiplication.
This instruction sets
Signed Multiply (halfwords) multiplies two signed 16-bit quantities, taken from either the bottom or the top half of their respective source registers. The other halves of these source registers are ignored. The 32-bit product is written to the destination register. No overflow is possible during this instruction.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SMULL": case "SMULLS": return { "tooltip": "Signed Multiply Long multiplies two 32-bit signed values to produce a 64-bit result.", "html": "Signed Multiply Long multiplies two 32-bit signed values to produce a 64-bit result.
In A32 instructions, the condition flags can optionally be updated based on the result. Use of this option adversely affects performance on many implementations.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SMULWB": case "SMULWT": return { "tooltip": "Signed Multiply (word by halfword) multiplies a signed 32-bit quantity and a signed 16-bit quantity. The signed 16-bit quantity is taken from either the bottom or the top half of its source register. The other half of the second source register is ignored. The top 32 bits of the 48-bit product are written to the destination register. The bottom 16 bits of the 48-bit product are ignored. No overflow is possible during this instruction.", "html": "Signed Multiply (word by halfword) multiplies a signed 32-bit quantity and a signed 16-bit quantity. The signed 16-bit quantity is taken from either the bottom or the top half of its source register. The other half of the second source register is ignored. The top 32 bits of the 48-bit product are written to the destination register. The bottom 16 bits of the 48-bit product are ignored. No overflow is possible during this instruction.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SMUSD": case "SMUSDX": return { "tooltip": "Signed Multiply Subtract Dual performs two signed 16 x 16-bit multiplications. It subtracts one of the products from the other, and writes the result to the destination register.", "html": "Signed Multiply Subtract Dual performs two signed 16 x 16-bit multiplications. It subtracts one of the products from the other, and writes the result to the destination register.
Optionally, the instruction can exchange the halfwords of the second operand before performing the arithmetic. This produces top x bottom and bottom x top multiplication.
Overflow cannot occur.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SRS": case "SRSDA": case "SRSDB": case "SRSIA": case "SRSIB": return { "tooltip": "Store Return State stores the LR_Store Return State stores the LR_<current_mode> and
If EL3 is using AArch64 and an
Signed Saturate saturates an optionally-shifted signed value to a selectable signed range.
This instruction sets
Signed Saturate 16 saturates two signed 16-bit values to a selected signed range.
This instruction sets
Signed Subtract and Add with Exchange exchanges the two halfwords of the second operand, performs one 16-bit integer subtraction and one 16-bit addition, and writes the results to the destination register. It sets
Speculative Store Bypass Barrier is a memory barrier that prevents speculative loads from bypassing earlier stores to the same virtual address under certain conditions. For more information and details of the semantics, see
Signed Subtract 16 performs two 16-bit signed integer subtractions, and writes the results to the destination register. It sets
Signed Subtract 8 performs four 8-bit signed integer subtractions, and writes the results to the destination register. It sets
Store data to System register calculates an address from a base register value and an immediate offset, and stores a word from the
In an implementation that includes EL2, the permitted
For simplicity, the
Store-Release Word stores a word from a register to memory. The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Store-Release Byte stores a byte from a register to memory. The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Store-Release Exclusive Word stores a word from a register to memory if the executing PE has exclusive access to the memory at that address, and returns a status value of 0 if the store was successful, or of 1 if no store was performed.
The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Store-Release Exclusive Byte stores a byte from a register to memory if the executing PE has exclusive access to the memory at that address, and returns a status value of 0 if the store was successful, or of 1 if no store was performed.
The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Store-Release Exclusive Doubleword stores a doubleword from two registers to memory if the executing PE has exclusive access to the memory at that address, and returns a status value of 0 if the store was successful, or of 1 if no store was performed.
The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Store-Release Exclusive Halfword stores a halfword from a register to memory if the executing PE has exclusive access to the memory at that address, and returns a status value of 0 if the store was successful, or of 1 if no store was performed.
The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Store-Release Halfword stores a halfword from a register to memory. The instruction also has memory ordering semantics as described in
For more information about support for shared memory see
Store Multiple (Increment After, Empty Ascending) stores multiple registers to consecutive memory locations using an address from a base register. The consecutive memory locations start at this address, and the address just above the last of those locations can optionally be written back to the base register.
The lowest-numbered register is loaded from the lowest memory address, through to the highest-numbered register from the highest memory address. See also
Armv8.2 permits the deprecation of some Store Multiple ordering behaviors in AArch32 state, for more information see
In an EL1 mode other than System mode, Store Multiple (User registers) stores multiple User mode registers to consecutive memory locations using an address from a base register. The PE reads the base register value normally, using the current mode to determine the correct Banked version of the register. This instruction cannot writeback to the base register.
Store Multiple (User registers) is
Armv8.2 permits the deprecation of some Store Multiple ordering behaviors in AArch32 state, for more information see
Store Multiple Decrement After (Empty Descending) stores multiple registers to consecutive memory locations using an address from a base register. The consecutive memory locations end at this address, and the address just below the lowest of those locations can optionally be written back to the base register.
The lowest-numbered register is loaded from the lowest memory address, through to the highest-numbered register from the highest memory address. See also
Armv8.2 permits the deprecation of some Store Multiple ordering behaviors in AArch32 state, for more information see
Store Multiple Decrement Before (Full Descending) stores multiple registers to consecutive memory locations using an address from a base register. The consecutive memory locations end just below this address, and the address of the first of those locations can optionally be written back to the base register.
The lowest-numbered register is loaded from the lowest memory address, through to the highest-numbered register from the highest memory address. See also
Armv8.2 permits the deprecation of some Store Multiple ordering behaviors in AArch32 state, for more information see
Store Multiple Increment Before (Full Ascending) stores multiple registers to consecutive memory locations using an address from a base register. The consecutive memory locations start just above this address, and the address of the last of those locations can optionally be written back to the base register.
The lowest-numbered register is loaded from the lowest memory address, through to the highest-numbered register from the highest memory address. See also
Armv8.2 permits the deprecation of some Store Multiple ordering behaviors in AArch32 state, for more information see
Store Register (immediate) calculates an address from a base register value and an immediate offset, and stores a word from a register to memory. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Store Register (register) calculates an address from a base register value and an offset register value, stores a word from a register to memory. The offset register value can optionally be shifted. For information about memory accesses see
Store Register Byte (immediate) calculates an address from a base register value and an immediate offset, and stores a byte from a register to memory. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Store Register Byte (register) calculates an address from a base register value and an offset register value, and stores a byte from a register to memory. The offset register value can optionally be shifted. For information about memory accesses see
Store Register Byte Unprivileged stores a byte from a register to memory. For information about memory accesses see
The memory access is restricted as if the PE were running in User mode. This makes no difference if the PE is actually running in User mode.
The T32 instruction uses an offset addressing mode, that calculates the address used for the memory access from a base register value and an immediate offset, and leaves the base register unchanged.
The A32 instruction uses a post-indexed addressing mode, that uses a base register value as the address for the memory access, and calculates a new address from a base register value and an offset and writes it back to the base register. The offset can be an immediate value or an optionally-shifted register value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "STRD": return { "tooltip": "Store Register Dual (immediate) calculates an address from a base register value and an immediate offset, and stores two words from two registers to memory. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see Memory accesses.", "html": "Store Register Dual (immediate) calculates an address from a base register value and an immediate offset, and stores two words from two registers to memory. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Store Register Dual (register) calculates an address from a base register value and a register offset, and stores two words from two registers to memory. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Store Register Exclusive calculates an address from a base register value and an immediate offset, stores a word from a register to the calculated address if the PE has exclusive access to the memory at that address, and returns a status value of 0 if the store was successful, or of 1 if no store was performed.
For more information about support for shared memory see
Store Register Exclusive Byte derives an address from a base register value, stores a byte from a register to the derived address if the executing PE has exclusive access to the memory at that address, and returns a status value of 0 if the store was successful, or of 1 if no store was performed.
For more information about support for shared memory see
Store Register Exclusive Doubleword derives an address from a base register value, stores a 64-bit doubleword from two registers to the derived address if the executing PE has exclusive access to the memory at that address, and returns a status value of 0 if the store was successful, or of 1 if no store was performed.
For more information about support for shared memory see
Store Register Exclusive Halfword derives an address from a base register value, stores a halfword from a register to the derived address if the executing PE has exclusive access to the memory at that address, and returns a status value of 0 if the store was successful, or of 1 if no store was performed.
For more information about support for shared memory see
Store Register Halfword (immediate) calculates an address from a base register value and an immediate offset, and stores a halfword from a register to memory. It can use offset, post-indexed, or pre-indexed addressing. For information about memory accesses see
Store Register Halfword (register) calculates an address from a base register value and an offset register value, and stores a halfword from a register to memory. The offset register value can be shifted left by 0, 1, 2, or 3 bits. For information about memory accesses see
Store Register Halfword Unprivileged stores a halfword from a register to memory. For information about memory accesses see
The memory access is restricted as if the PE were running in User mode. This makes no difference if the PE is actually running in User mode.
The T32 instruction uses an offset addressing mode, that calculates the address used for the memory access from a base register value and an immediate offset, and leaves the base register unchanged.
The A32 instruction uses a post-indexed addressing mode, that uses a base register value as the address for the memory access, and calculates a new address from a base register value and an offset and writes it back to the base register. The offset can be an immediate value or a register value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "STRT": return { "tooltip": "Store Register Unprivileged stores a word from a register to memory. For information about memory accesses see Memory accesses.", "html": "Store Register Unprivileged stores a word from a register to memory. For information about memory accesses see
The memory access is restricted as if the PE were running in User mode. This makes no difference if the PE is actually running in User mode.
The T32 instruction uses an offset addressing mode, that calculates the address used for the memory access from a base register value and an immediate offset, and leaves the base register unchanged.
The A32 instruction uses a post-indexed addressing mode, that uses a base register value as the address for the memory access, and calculates a new address from a base register value and an offset and writes it back to the base register. The offset can be an immediate value or an optionally-shifted register value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SUB": case "SUBS": return { "tooltip": "Subtract (immediate) subtracts an immediate value from a register value, and writes the result to the destination register.", "html": "Subtract (immediate) subtracts an immediate value from a register value, and writes the result to the destination register.
If the destination register is not the PC, the SUBS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Subtract (register) subtracts an optionally-shifted register value from a register value, and writes the result to the destination register.
If the destination register is not the PC, the SUBS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Subtract (register-shifted register) subtracts a register-shifted register value from a register value, and writes the result to the destination register. It can optionally update the condition flags based on the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SUB": case "SUBS": return { "tooltip": "Subtract from SP (immediate) subtracts an immediate value from the SP value, and writes the result to the destination register.", "html": "Subtract from SP (immediate) subtracts an immediate value from the SP value, and writes the result to the destination register.
If the destination register is not the PC, the SUBS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Subtract from SP (register) subtracts an optionally-shifted register value from the SP value, and writes the result to the destination register.
If the destination register is not the PC, the SUBS variant of the instruction updates the condition flags based on the result.
The field descriptions for
Supervisor Call causes a Supervisor Call exception. For more information, see
Software can use this instruction as a call to an operating system to provide a service.
In the following cases, the Supervisor Call exception generated by the
In these cases, the
Signed Extend and Add Byte extracts an 8-bit value from a register, sign-extends it to 32 bits, adds the result to the value in another register, and writes the final result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SXTAB16": return { "tooltip": "Signed Extend and Add Byte 16 extracts two 8-bit values from a register, sign-extends them to 16 bits each, adds the results to two 16-bit values from another register, and writes the final results to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit values.", "html": "Signed Extend and Add Byte 16 extracts two 8-bit values from a register, sign-extends them to 16 bits each, adds the results to two 16-bit values from another register, and writes the final results to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit values.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SXTAH": return { "tooltip": "Signed Extend and Add Halfword extracts a 16-bit value from a register, sign-extends it to 32 bits, adds the result to a value from another register, and writes the final result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 16-bit value.", "html": "Signed Extend and Add Halfword extracts a 16-bit value from a register, sign-extends it to 32 bits, adds the result to a value from another register, and writes the final result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 16-bit value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SXTB": return { "tooltip": "Signed Extend Byte extracts an 8-bit value from a register, sign-extends it to 32 bits, and writes the result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit value.", "html": "Signed Extend Byte extracts an 8-bit value from a register, sign-extends it to 32 bits, and writes the result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SXTB16": return { "tooltip": "Signed Extend Byte 16 extracts two 8-bit values from a register, sign-extends them to 16 bits each, and writes the results to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit values.", "html": "Signed Extend Byte 16 extracts two 8-bit values from a register, sign-extends them to 16 bits each, and writes the results to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit values.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "SXTH": return { "tooltip": "Signed Extend Halfword extracts a 16-bit value from a register, sign-extends it to 32 bits, and writes the result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 16-bit value.", "html": "Signed Extend Halfword extracts a 16-bit value from a register, sign-extends it to 32 bits, and writes the result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 16-bit value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "TBB": case "TBH": return { "tooltip": "Table Branch Byte or Halfword causes a PC-relative forward branch using a table of single byte or halfword offsets. A base register provides a pointer to the table, and a second register supplies an index into the table. The branch length is twice the value returned from the table.", "html": "Table Branch Byte or Halfword causes a PC-relative forward branch using a table of single byte or halfword offsets. A base register provides a pointer to the table, and a second register supplies an index into the table. The branch length is twice the value returned from the table.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "TEQ": return { "tooltip": "Test Equivalence (immediate) performs a bitwise exclusive OR operation on a register value and an immediate value. It updates the condition flags based on the result, and discards the result.", "html": "Test Equivalence (immediate) performs a bitwise exclusive OR operation on a register value and an immediate value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "TEQ": return { "tooltip": "Test Equivalence (register) performs a bitwise exclusive-OR operation on a register value and an optionally-shifted register value. It updates the condition flags based on the result, and discards the result.", "html": "Test Equivalence (register) performs a bitwise exclusive-OR operation on a register value and an optionally-shifted register value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "TEQ": return { "tooltip": "Test Equivalence (register-shifted register) performs a bitwise exclusive-OR operation on a register value and a register-shifted register value. It updates the condition flags based on the result, and discards the result.", "html": "Test Equivalence (register-shifted register) performs a bitwise exclusive-OR operation on a register value and a register-shifted register value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "TSBCSYNC": return { "tooltip": "Trace Synchronization Barrier. This instruction is a barrier that synchronizes the trace operations of instructions, see Trace Synchronization Buffer (TSB CSYNC).", "html": "Trace Synchronization Barrier. This instruction is a barrier that synchronizes the trace operations of instructions, see
If
Test (immediate) performs a bitwise AND operation on a register value and an immediate value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "TST": return { "tooltip": "Test (register) performs a bitwise AND operation on a register value and an optionally-shifted register value. It updates the condition flags based on the result, and discards the result.", "html": "Test (register) performs a bitwise AND operation on a register value and an optionally-shifted register value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "TST": return { "tooltip": "Test (register-shifted register) performs a bitwise AND operation on a register value and a register-shifted register value. It updates the condition flags based on the result, and discards the result.", "html": "Test (register-shifted register) performs a bitwise AND operation on a register value and a register-shifted register value. It updates the condition flags based on the result, and discards the result.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UADD16": return { "tooltip": "Unsigned Add 16 performs two 16-bit unsigned integer additions, and writes the results to the destination register. It sets PSTATE.GE according to the results of the additions.", "html": "Unsigned Add 16 performs two 16-bit unsigned integer additions, and writes the results to the destination register. It sets
Unsigned Add 8 performs four unsigned 8-bit integer additions, and writes the results to the destination register. It sets
Unsigned Add and Subtract with Exchange exchanges the two halfwords of the second operand, performs one unsigned 16-bit integer addition and one unsigned 16-bit subtraction, and writes the results to the destination register. It sets
Unsigned Bit Field Extract extracts any number of adjacent bits at any position from a register, zero-extends them to 32 bits, and writes the result to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UDF": return { "tooltip": "Permanently Undefined generates an Undefined Instruction exception.", "html": "Permanently Undefined generates an Undefined Instruction exception.
The encodings for
Unsigned Divide divides a 32-bit unsigned integer register value by a 32-bit unsigned integer register value, and writes the result to the destination register. The condition flags are not affected.
See
Unsigned Halving Add 16 performs two unsigned 16-bit integer additions, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UHADD8": return { "tooltip": "Unsigned Halving Add 8 performs four unsigned 8-bit integer additions, halves the results, and writes the results to the destination register.", "html": "Unsigned Halving Add 8 performs four unsigned 8-bit integer additions, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UHASX": return { "tooltip": "Unsigned Halving Add and Subtract with Exchange exchanges the two halfwords of the second operand, performs one unsigned 16-bit integer addition and one unsigned 16-bit subtraction, halves the results, and writes the results to the destination register.", "html": "Unsigned Halving Add and Subtract with Exchange exchanges the two halfwords of the second operand, performs one unsigned 16-bit integer addition and one unsigned 16-bit subtraction, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UHSAX": return { "tooltip": "Unsigned Halving Subtract and Add with Exchange exchanges the two halfwords of the second operand, performs one unsigned 16-bit integer subtraction and one unsigned 16-bit addition, halves the results, and writes the results to the destination register.", "html": "Unsigned Halving Subtract and Add with Exchange exchanges the two halfwords of the second operand, performs one unsigned 16-bit integer subtraction and one unsigned 16-bit addition, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UHSUB16": return { "tooltip": "Unsigned Halving Subtract 16 performs two unsigned 16-bit integer subtractions, halves the results, and writes the results to the destination register.", "html": "Unsigned Halving Subtract 16 performs two unsigned 16-bit integer subtractions, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UHSUB8": return { "tooltip": "Unsigned Halving Subtract 8 performs four unsigned 8-bit integer subtractions, halves the results, and writes the results to the destination register.", "html": "Unsigned Halving Subtract 8 performs four unsigned 8-bit integer subtractions, halves the results, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UMAAL": return { "tooltip": "Unsigned Multiply Accumulate Accumulate Long multiplies two unsigned 32-bit values to produce a 64-bit value, adds two unsigned 32-bit values, and writes the 64-bit result to two registers.", "html": "Unsigned Multiply Accumulate Accumulate Long multiplies two unsigned 32-bit values to produce a 64-bit value, adds two unsigned 32-bit values, and writes the 64-bit result to two registers.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UMLAL": case "UMLALS": return { "tooltip": "Unsigned Multiply Accumulate Long multiplies two unsigned 32-bit values to produce a 64-bit value, and accumulates this with a 64-bit value.", "html": "Unsigned Multiply Accumulate Long multiplies two unsigned 32-bit values to produce a 64-bit value, and accumulates this with a 64-bit value.
In A32 instructions, the condition flags can optionally be updated based on the result. Use of this option adversely affects performance on many implementations.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UMULL": case "UMULLS": return { "tooltip": "Unsigned Multiply Long multiplies two 32-bit unsigned values to produce a 64-bit result.", "html": "Unsigned Multiply Long multiplies two 32-bit unsigned values to produce a 64-bit result.
In A32 instructions, the condition flags can optionally be updated based on the result. Use of this option adversely affects performance on many implementations.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UQADD16": return { "tooltip": "Unsigned Saturating Add 16 performs two unsigned 16-bit integer additions, saturates the results to the 16-bit unsigned integer range 0 <= x <= 216 - 1, and writes the results to the destination register.", "html": "Unsigned Saturating Add 16 performs two unsigned 16-bit integer additions, saturates the results to the 16-bit unsigned integer range 0 <= x <= 216 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UQADD8": return { "tooltip": "Unsigned Saturating Add 8 performs four unsigned 8-bit integer additions, saturates the results to the 8-bit unsigned integer range 0 <= x <= 28 - 1, and writes the results to the destination register.", "html": "Unsigned Saturating Add 8 performs four unsigned 8-bit integer additions, saturates the results to the 8-bit unsigned integer range 0 <= x <= 28 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UQASX": return { "tooltip": "Unsigned Saturating Add and Subtract with Exchange exchanges the two halfwords of the second operand, performs one unsigned 16-bit integer addition and one unsigned 16-bit subtraction, saturates the results to the 16-bit unsigned integer range 0 <= x <= 216 - 1, and writes the results to the destination register.", "html": "Unsigned Saturating Add and Subtract with Exchange exchanges the two halfwords of the second operand, performs one unsigned 16-bit integer addition and one unsigned 16-bit subtraction, saturates the results to the 16-bit unsigned integer range 0 <= x <= 216 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UQSAX": return { "tooltip": "Unsigned Saturating Subtract and Add with Exchange exchanges the two halfwords of the second operand, performs one unsigned 16-bit integer subtraction and one unsigned 16-bit addition, saturates the results to the 16-bit unsigned integer range 0 <= x <= 216 - 1, and writes the results to the destination register.", "html": "Unsigned Saturating Subtract and Add with Exchange exchanges the two halfwords of the second operand, performs one unsigned 16-bit integer subtraction and one unsigned 16-bit addition, saturates the results to the 16-bit unsigned integer range 0 <= x <= 216 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UQSUB16": return { "tooltip": "Unsigned Saturating Subtract 16 performs two unsigned 16-bit integer subtractions, saturates the results to the 16-bit unsigned integer range 0 <= x <= 216 - 1, and writes the results to the destination register.", "html": "Unsigned Saturating Subtract 16 performs two unsigned 16-bit integer subtractions, saturates the results to the 16-bit unsigned integer range 0 <= x <= 216 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UQSUB8": return { "tooltip": "Unsigned Saturating Subtract 8 performs four unsigned 8-bit integer subtractions, saturates the results to the 8-bit unsigned integer range 0 <= x <= 28 - 1, and writes the results to the destination register.", "html": "Unsigned Saturating Subtract 8 performs four unsigned 8-bit integer subtractions, saturates the results to the 8-bit unsigned integer range 0 <= x <= 28 - 1, and writes the results to the destination register.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "USAD8": return { "tooltip": "Unsigned Sum of Absolute Differences performs four unsigned 8-bit subtractions, and adds the absolute values of the differences together.", "html": "Unsigned Sum of Absolute Differences performs four unsigned 8-bit subtractions, and adds the absolute values of the differences together.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "USADA8": return { "tooltip": "Unsigned Sum of Absolute Differences and Accumulate performs four unsigned 8-bit subtractions, and adds the absolute values of the differences to a 32-bit accumulate operand.", "html": "Unsigned Sum of Absolute Differences and Accumulate performs four unsigned 8-bit subtractions, and adds the absolute values of the differences to a 32-bit accumulate operand.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "USAT": return { "tooltip": "Unsigned Saturate saturates an optionally-shifted signed value to a selected unsigned range.", "html": "Unsigned Saturate saturates an optionally-shifted signed value to a selected unsigned range.
This instruction sets
Unsigned Saturate 16 saturates two signed 16-bit values to a selected unsigned range.
This instruction sets
Unsigned Subtract and Add with Exchange exchanges the two halfwords of the second operand, performs one unsigned 16-bit integer subtraction and one unsigned 16-bit addition, and writes the results to the destination register. It sets
Unsigned Subtract 16 performs two 16-bit unsigned integer subtractions, and writes the results to the destination register. It sets
Unsigned Subtract 8 performs four 8-bit unsigned integer subtractions, and writes the results to the destination register. It sets
Unsigned Extend and Add Byte extracts an 8-bit value from a register, zero-extends it to 32 bits, adds the result to the value in another register, and writes the final result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UXTAB16": return { "tooltip": "Unsigned Extend and Add Byte 16 extracts two 8-bit values from a register, zero-extends them to 16 bits each, adds the results to two 16-bit values from another register, and writes the final results to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit values.", "html": "Unsigned Extend and Add Byte 16 extracts two 8-bit values from a register, zero-extends them to 16 bits each, adds the results to two 16-bit values from another register, and writes the final results to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit values.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UXTAH": return { "tooltip": "Unsigned Extend and Add Halfword extracts a 16-bit value from a register, zero-extends it to 32 bits, adds the result to a value from another register, and writes the final result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 16-bit value.", "html": "Unsigned Extend and Add Halfword extracts a 16-bit value from a register, zero-extends it to 32 bits, adds the result to a value from another register, and writes the final result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 16-bit value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UXTB": return { "tooltip": "Unsigned Extend Byte extracts an 8-bit value from a register, zero-extends it to 32 bits, and writes the result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit value.", "html": "Unsigned Extend Byte extracts an 8-bit value from a register, zero-extends it to 32 bits, and writes the result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UXTB16": return { "tooltip": "Unsigned Extend Byte 16 extracts two 8-bit values from a register, zero-extends them to 16 bits each, and writes the results to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit values.", "html": "Unsigned Extend Byte 16 extracts two 8-bit values from a register, zero-extends them to 16 bits each, and writes the results to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 8-bit values.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "UXTH": return { "tooltip": "Unsigned Extend Halfword extracts a 16-bit value from a register, zero-extends it to 32 bits, and writes the result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 16-bit value.", "html": "Unsigned Extend Halfword extracts a 16-bit value from a register, zero-extends it to 32 bits, and writes the result to the destination register. The instruction can specify a rotation by 0, 8, 16, or 24 bits before extracting the 16-bit value.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VABA": return { "tooltip": "Vector Absolute Difference and Accumulate subtracts the elements of one vector from the corresponding elements of another vector, and accumulates the absolute values of the results into the elements of the destination vector.", "html": "Vector Absolute Difference and Accumulate subtracts the elements of one vector from the corresponding elements of another vector, and accumulates the absolute values of the results into the elements of the destination vector.
Operand and result elements are all integers of the same length.
Depending on settings in the
Vector Absolute Difference and Accumulate Long subtracts the elements of one vector from the corresponding elements of another vector, and accumulates the absolute values of the results into the elements of the destination vector.
Operand elements are all integers of the same length, and the result elements are double the length of the operands.
Depending on settings in the
Vector Absolute Difference (floating-point) subtracts the elements of one vector from the corresponding elements of another vector, and places the absolute values of the results in the elements of the destination vector.
Operand and result elements are floating-point numbers of the same size.
Depending on settings in the
Vector Absolute Difference (integer) subtracts the elements of one vector from the corresponding elements of another vector, and places the absolute values of the results in the elements of the destination vector.
Operand and result elements are all integers of the same length.
Depending on settings in the
Vector Absolute Difference Long (integer) subtracts the elements of one vector from the corresponding elements of another vector, and places the absolute values of the results in the elements of the destination vector.
Operand elements are all integers of the same length, and the result elements are double the length of the operands.
Depending on settings in the
Vector Absolute takes the absolute value of each element in a vector, and places the results in a second vector. The floating-point version only clears the sign bit.
Depending on settings in the
Vector Absolute Compare Greater Than or Equal takes the absolute value of each element in a vector, and compares it with the absolute value of the corresponding element of a second vector. If the first is greater than or equal to the second, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
The operands and result can be quadword or doubleword vectors. They must all be the same size.
The operand vector elements are floating-point numbers. The result vector elements are the same size as the operand vector elements.
Depending on settings in the
Vector Absolute Compare Greater Than takes the absolute value of each element in a vector, and compares it with the absolute value of the corresponding element of a second vector. If the first is greater than the second, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
The operands and result can be quadword or doubleword vectors. They must all be the same size.
The operand vector elements are floating-point numbers. The result vector elements are the same size as the operand vector elements.
Depending on settings in the
Vector Absolute Compare Less Than or Equal takes the absolute value of each element in a vector, and compares it with the absolute value of the corresponding element of a second vector. If the first is less than or equal to the second, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VACLT": return { "tooltip": "Vector Absolute Compare Less Than takes the absolute value of each element in a vector, and compares it with the absolute value of the corresponding element of a second vector. If the first is less than the second, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.", "html": "Vector Absolute Compare Less Than takes the absolute value of each element in a vector, and compares it with the absolute value of the corresponding element of a second vector. If the first is less than the second, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VADD": return { "tooltip": "Vector Add (floating-point) adds corresponding elements in two vectors, and places the results in the destination vector.", "html": "Vector Add (floating-point) adds corresponding elements in two vectors, and places the results in the destination vector.
Depending on settings in the
Vector Add (integer) adds corresponding elements in two vectors, and places the results in the destination vector.
Depending on settings in the
Vector Add and Narrow, returning High Half adds corresponding elements in two quadword vectors, and places the most significant half of each result in a doubleword vector. The results are truncated. For rounded results, see
The operand elements can be 16-bit, 32-bit, or 64-bit integers. There is no distinction between signed and unsigned integers.
Depending on settings in the
Vector Add Long adds corresponding elements in two doubleword vectors, and places the results in a quadword vector. Before adding, it sign-extends or zero-extends the elements of both operands.
Depending on settings in the
Vector Add Wide adds corresponding elements in one quadword and one doubleword vector, and places the results in a quadword vector. Before adding, it sign-extends or zero-extends the elements of the doubleword operand.
Depending on settings in the
Vector Bitwise AND (register) performs a bitwise AND operation between two registers, and places the result in the destination register.
Depending on settings in the
Vector Bitwise Bit Clear (immediate) performs a bitwise AND between a register value and the complement of an immediate value, and returns the result into the destination vector.
Depending on settings in the
Vector Bitwise Bit Clear (register) performs a bitwise AND between a register value and the complement of a register value, and places the result in the destination register.
Depending on settings in the
Vector Bitwise Insert if False inserts each bit from the first source register into the destination register if the corresponding bit of the second source register is 0, otherwise leaves the bit in the destination register unchanged.
Depending on settings in the
Vector Bitwise Insert if True inserts each bit from the first source register into the destination register if the corresponding bit of the second source register is 1, otherwise leaves the bit in the destination register unchanged.
Depending on settings in the
Vector Bitwise Select sets each bit in the destination to the corresponding bit from the first source operand when the original destination bit was 1, otherwise from the second source operand.
Depending on settings in the
Vector Complex Add.
This instruction operates on complex numbers that are represented in SIMD&FP registers as pairs of elements, with the more significant element holding the imaginary part of the number and the less significant element holding the real part of the number. Each element holds a floating-point value. It performs the following computation on the corresponding complex number element pairs from the two source registers:
Depending on settings in the
Vector Compare Equal to Zero takes each element in a vector, and compares it with zero. If it is equal to zero, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
The operand vector elements are the same type, and are integers or floating-point numbers. The result vector elements are fields the same size as the operand vector elements.
Depending on settings in the
Vector Compare Equal takes each element in a vector, and compares it with the corresponding element of a second vector. If they are equal, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
The operand vector elements are the same type, and are integers or floating-point numbers. The result vector elements are fields the same size as the operand vector elements.
Depending on settings in the
Vector Compare Greater Than or Equal to Zero takes each element in a vector, and compares it with zero. If it is greater than or equal to zero, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
The operand vector elements are the same type, and are signed integers or floating-point numbers. The result vector elements are fields the same size as the operand vector elements.
Depending on settings in the
Vector Compare Greater Than or Equal takes each element in a vector, and compares it with the corresponding element of a second vector. If the first is greater than or equal to the second, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
The operand vector elements are the same type, and are signed integers, unsigned integers, or floating-point numbers. The result vector elements are fields the same size as the operand vector elements.
Depending on settings in the
Vector Compare Greater Than Zero takes each element in a vector, and compares it with zero. If it is greater than zero, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
The operand vector elements are the same type, and are signed integers or floating-point numbers. The result vector elements are fields the same size as the operand vector elements.
Depending on settings in the
Vector Compare Greater Than takes each element in a vector, and compares it with the corresponding element of a second vector. If the first is greater than the second, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
The operand vector elements are the same type, and are signed integers, unsigned integers, or floating-point numbers. The result vector elements are fields the same size as the operand vector elements.
Depending on settings in the
Vector Compare Less Than or Equal to Zero takes each element in a vector, and compares it with zero. If it is less than or equal to zero, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
The operand vector elements are the same type, and are signed integers or floating-point numbers. The result vector elements are fields the same size as the operand vector elements.
Depending on settings in the
Vector Compare Less Than or Equal takes each element in a vector, and compares it with the corresponding element of a second vector. If the first is less than or equal to the second, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VCLS": return { "tooltip": "Vector Count Leading Sign Bits counts the number of consecutive bits following the topmost bit, that are the same as the topmost bit, in each element in a vector, and places the results in a second vector. The count does not include the topmost bit itself.", "html": "Vector Count Leading Sign Bits counts the number of consecutive bits following the topmost bit, that are the same as the topmost bit, in each element in a vector, and places the results in a second vector. The count does not include the topmost bit itself.
The operand vector elements can be any one of 8-bit, 16-bit, or 32-bit signed integers.
The result vector elements are the same data type as the operand vector elements.
Depending on settings in the
Vector Compare Less Than Zero takes each element in a vector, and compares it with zero. If it is less than zero, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
The operand vector elements are the same type, and are signed integers or floating-point numbers. The result vector elements are fields the same size as the operand vector elements.
Depending on settings in the
Vector Compare Less Than takes each element in a vector, and compares it with the corresponding element of a second vector. If the first is less than the second, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VCLZ": return { "tooltip": "Vector Count Leading Zeros counts the number of consecutive zeros, starting from the most significant bit, in each element in a vector, and places the results in a second vector.", "html": "Vector Count Leading Zeros counts the number of consecutive zeros, starting from the most significant bit, in each element in a vector, and places the results in a second vector.
The operand vector elements can be any one of 8-bit, 16-bit, or 32-bit integers. There is no distinction between signed and unsigned integers.
The result vector elements are the same data type as the operand vector elements.
Depending on settings in the
Vector Complex Multiply Accumulate.
This instruction operates on complex numbers that are represented in SIMD&FP registers as pairs of elements, with the more significant element holding the imaginary part of the number and the less significant element holding the real part of the number. Each element holds a floating-point value. It performs the following computation on the corresponding complex number element pairs from the two source registers and the destination register:
The multiplication and addition operations are performed as a fused multiply-add, without any intermediate rounding.
Depending on settings in the
Vector Complex Multiply Accumulate (by element).
This instruction operates on complex numbers that are represented in SIMD&FP registers as pairs of elements, with the more significant element holding the imaginary part of the number and the less significant element holding the real part of the number. Each element holds a floating-point value. It performs the following computation on complex numbers from the first source register and the destination register with the specified complex number from the second source register:
The multiplication and addition operations are performed as a fused multiply-add, without any intermediate rounding.
Depending on settings in the
Vector Compare compares two floating-point registers, or one floating-point register and zero. It writes the result to the
This instruction raises an Invalid Operation floating-point exception if either or both of the operands is a signaling NaN.
Depending on settings in the
Vector Compare, raising Invalid Operation on NaN compares two floating-point registers, or one floating-point register and zero. It writes the result to the
This instruction raises an Invalid Operation floating-point exception if either or both of the operands is any type of NaN.
Depending on settings in the
Vector Count Set Bits counts the number of bits that are one in each element in a vector, and places the results in a second vector.
The operand vector elements must be 8-bit fields.
The result vector elements are 8-bit integers.
Depending on settings in the
Vector Convert from single-precision to BFloat16 converts each 32-bit element in a vector from single-precision floating-point to BFloat16 format, and writes the result into a second vector. The result vector elements are half the width of the source vector elements.
Unlike the BFloat16 multiplication instructions, this instruction uses the Round to Nearest rounding mode, and can generate a floating-point exception that causes cumulative exception bits in the
Convert between double-precision and single-precision does one of the following:
Depending on settings in the
Vector Convert between half-precision and single-precision converts each element in a vector from single-precision to half-precision floating-point, or from half-precision to single-precision, and places the results in a second vector.
Depending on settings in the
Vector Convert between floating-point and integer converts each element in a vector from floating-point to integer, or from integer to floating-point, and places the results in a second vector.
The vector elements are the same type, and are floating-point numbers or integers. Signed and unsigned integers are distinct.
The floating-point to integer operation uses the Round towards Zero rounding mode. The integer to floating-point operation uses the Round to Nearest rounding mode.
Depending on settings in the
Convert floating-point to integer with Round towards Zero converts a value in a register from floating-point to a 32-bit integer, using the Round towards Zero rounding mode, and places the result in a second register.
Depending on settings in the
Convert integer to floating-point converts a 32-bit integer to floating-point using the rounding mode specified by the
Depending on settings in the
Vector Convert between floating-point and fixed-point converts each element in a vector from floating-point to fixed-point, or from fixed-point to floating-point, and places the results in a second vector.
The vector elements are the same type, and are floating-point numbers or integers. Signed and unsigned integers are distinct.
The floating-point to fixed-point operation uses the Round towards Zero rounding mode. The fixed-point to floating-point operation uses the Round to Nearest rounding mode.
Depending on settings in the
Convert between floating-point and fixed-point converts a value in a register from floating-point to fixed-point, or from fixed-point to floating-point. Software can specify the fixed-point value as either signed or unsigned.
The fixed-point value can be 16-bit or 32-bit. Conversions from fixed-point values take their operand from the low-order bits of the source register and ignore any remaining bits. Signed conversions to fixed-point values sign-extend the result value to the destination register width. Unsigned conversions to fixed-point values zero-extend the result value to the destination register width.
The floating-point to fixed-point operation uses the Round towards Zero rounding mode. The fixed-point to floating-point operation uses the Round to Nearest rounding mode.
Depending on settings in the
Vector Convert floating-point to integer with Round to Nearest with Ties to Away converts each element in a vector from floating-point to integer using the Round to Nearest with Ties to Away rounding mode, and places the results in a second vector.
The operand vector elements are floating-point numbers.
The result vector elements are integers, and the same size as the operand vector elements. Signed and unsigned integers are distinct.
Depending on settings in the
Convert floating-point to integer with Round to Nearest with Ties to Away converts a value in a register from floating-point to a 32-bit integer using the Round to Nearest with Ties to Away rounding mode, and places the result in a second register.
Depending on settings in the
Convert to or from a half-precision value in the bottom half of a single-precision register does one of the following:
Depending on settings in the
Converts the single-precision value in a single-precision register to BFloat16 format and writes the result into the bottom half of a single precision register, preserving the top 16 bits of the destination register.
Unlike the BFloat16 multiplication instructions, this instruction honors all the control bits in the
Vector Convert floating-point to integer with Round towards -Infinity converts each element in a vector from floating-point to integer using the Round towards -Infinity rounding mode, and places the results in a second vector.
The operand vector elements are floating-point numbers.
The result vector elements are integers, and the same size as the operand vector elements. Signed and unsigned integers are distinct.
Depending on settings in the
Convert floating-point to integer with Round towards -Infinity converts a value in a register from floating-point to a 32-bit integer using the Round towards -Infinity rounding mode, and places the result in a second register.
Depending on settings in the
Vector Convert floating-point to integer with Round to Nearest converts each element in a vector from floating-point to integer using the Round to Nearest rounding mode, and places the results in a second vector.
The operand vector elements are floating-point numbers.
The result vector elements are integers, and the same size as the operand vector elements. Signed and unsigned integers are distinct.
Depending on settings in the
Convert floating-point to integer with Round to Nearest converts a value in a register from floating-point to a 32-bit integer using the Round to Nearest rounding mode, and places the result in a second register.
Depending on settings in the
Vector Convert floating-point to integer with Round towards +Infinity converts each element in a vector from floating-point to integer using the Round towards +Infinity rounding mode, and places the results in a second vector.
The operand vector elements are floating-point numbers.
The result vector elements are integers, and the same size as the operand vector elements. Signed and unsigned integers are distinct.
Depending on settings in the
Convert floating-point to integer with Round towards +Infinity converts a value in a register from floating-point to a 32-bit integer using the Round towards +Infinity rounding mode, and places the result in a second register.
Depending on settings in the
Convert floating-point to integer converts a value in a register from floating-point to a 32-bit integer, using the rounding mode specified by the
Depending on settings in the
Convert to or from a half-precision value in the top half of a single-precision register does one of the following:
Depending on settings in the
Converts the single-precision value in a single-precision register to BFloat16 format and writes the result in the top half of a single-precision register, preserving the bottom 16 bits of the register.
Unlike the BFloat16 multiplication instructions, this instruction honors all the control bits in the
Divide divides one floating-point value by another floating-point value and writes the result to a third floating-point register.
Depending on settings in the
BFloat16 floating-point (BF16) dot product (vector). This instruction delimits the source vectors into pairs of 16-bit BF16 elements. Within each pair, the elements in the first source vector are multiplied by the corresponding elements in the second source vector. The resulting single-precision products are then summed and added destructively to the single-precision element in the destination vector which aligns with the pair of BF16 values in the first source vector. The instruction does not update the
BFloat16 floating-point indexed dot product (vector, by element). This instruction delimits the source vectors into pairs of 16-bit BF16 elements. Each pair of elements in the first source vector is multiplied by the indexed pair of elements in the second source vector. The resulting single-precision products are then summed and added destructively to the single-precision element in the destination vector which aligns with the pair of BFloat16 values in the first source vector. The instruction does not update the
Duplicate general-purpose register to vector duplicates an element from a general-purpose register into every element of the destination vector.
The destination vector elements can be 8-bit, 16-bit, or 32-bit fields. The source element is the least significant 8, 16, or 32 bits of the general-purpose register. There is no distinction between data types.
Depending on settings in the
Duplicate vector element to vector duplicates a single element of a vector into every element of the destination vector.
The scalar, and the destination vector elements, can be any one of 8-bit, 16-bit, or 32-bit fields. There is no distinction between data types.
For more information about scalars see
Depending on settings in the
Vector Bitwise Exclusive-OR performs a bitwise exclusive-OR operation between two registers, and places the result in the destination register. The operand and result registers can be quadword or doubleword. They must all be the same size.
Depending on settings in the
Vector Extract extracts elements from the bottom end of the second operand vector and the top end of the first, concatenates them and places the result in the destination vector.
The elements of the vectors are treated as being 8-bit fields. There is no distinction between data types.
Depending on settings in the
Vector Fused Multiply Accumulate multiplies corresponding elements of two vectors, and accumulates the results into the elements of the destination vector. The instruction does not round the result of the multiply before the accumulation.
Depending on settings in the
The Bfloat16 floating-point widening multiply-add long instruction widens the even-numbered (bottom) or odd-numbered (top) 16-bit elements in the first and second source vectors from Bfloat16 to single-precision format. The instruction then multiplies and adds these values to the overlapping single-precision elements of the destination vector.
Unlike other BFloat16 multiplication instructions, this performs a fused multiply-add, without intermediate rounding that uses the Round to Nearest rounding mode and can generate a floating-point exception that causes cumulative exception bits in the
The BFloat16 floating-point widening multiply-add long instruction widens the even-numbered (bottom) or odd-numbered (top) 16-bit elements in the first source vector, and an indexed element in the second source vector from Bfloat16 to single-precision format. The instruction then multiplies and adds these values to the overlapping single-precision elements of the destination vector.
Unlike other BFloat16 multiplication instructions, this performs a fused multiply-add, without intermediate rounding that uses the Round to Nearest rounding mode and can generate a floating-point exception that causes cumulative exception bits in the
Vector Floating-point Multiply-Add Long to accumulator (vector). This instruction multiplies corresponding values in the vectors in the two source SIMD&FP registers, and accumulates the product to the corresponding vector element of the destination SIMD&FP register. The instruction does not round the result of the multiply before the accumulation.
Depending on settings in the
In Armv8.2 and Armv8.3, this is an
Vector Floating-point Multiply-Add Long to accumulator (by scalar). This instruction multiplies the vector elements in the first source SIMD&FP register by the specified value in the second source SIMD&FP register, and accumulates the product to the corresponding vector element of the destination SIMD&FP register. The instruction does not round the result of the multiply before the accumulation.
Depending on settings in the
In Armv8.2 and Armv8.3, this is an
Vector Fused Multiply Subtract negates the elements of one vector and multiplies them with the corresponding elements of another vector, adds the products to the corresponding elements of the destination vector, and places the results in the destination vector. The instruction does not round the result of the multiply before the addition.
Depending on settings in the
Vector Floating-point Multiply-Subtract Long from accumulator (vector). This instruction negates the values in the vector of one SIMD&FP register, multiplies these with the corresponding values in another vector, and accumulates the product to the corresponding vector element of the destination SIMD&FP register. The instruction does not round the result of the multiply before the accumulation.
Depending on settings in the
In Armv8.2 and Armv8.3, this is an
Vector Floating-point Multiply-Subtract Long from accumulator (by scalar). This instruction multiplies the negated vector elements in the first source SIMD&FP register by the specified value in the second source SIMD&FP register, and accumulates the product to the corresponding vector element of the destination SIMD&FP register. The instruction does not round the result of the multiply before the accumulation.
Depending on settings in the
In Armv8.2 and Armv8.3, this is an
Vector Fused Negate Multiply Accumulate negates one floating-point register value and multiplies it by another floating-point register value, adds the negation of the floating-point value in the destination register to the product, and writes the result back to the destination register. The instruction does not round the result of the multiply before the addition.
Depending on settings in the
Vector Fused Negate Multiply Subtract multiplies together two floating-point register values, adds the negation of the floating-point value in the destination register to the product, and writes the result back to the destination register. The instruction does not round the result of the multiply before the addition.
Depending on settings in the
Vector Halving Add adds corresponding elements in two vectors of integers, shifts each result right one bit, and places the final results in the destination vector. The results of the halving operations are truncated. For rounded results, see
The operand and result elements are all the same type, and can be any one of:
Depending on settings in the
Vector Halving Subtract subtracts the elements of the second operand from the corresponding elements of the first operand, shifts each result right one bit, and places the final results in the destination vector. The results of the halving operations are truncated. There is no rounding version.
The operand and result elements are all the same type, and can be any one of:
Depending on settings in the
Vector move Insertion. This instruction copies the lower 16 bits of the 32-bit source SIMD&FP register into the upper 16 bits of the 32-bit destination SIMD&FP register, while preserving the values in the remaining bits.
Depending on settings in the
Javascript Convert to signed fixed-point, rounding toward Zero. This instruction converts the double-precision floating-point value in the SIMD&FP source register to a 32-bit signed integer using the Round towards Zero rounding mode, and writes the result to the SIMD&FP destination register. If the result is too large to be accommodated as a signed 32-bit integer, then the result is the integer modulo 232, as held in a 32-bit signed integer.
This instruction can generate a floating-point exception. Depending on the settings in
Depending on settings in the
Load single 1-element structure to one lane of one register loads one element from memory into one element of a register. Elements of the register that are not loaded are unchanged. For details of the addressing mode, see
Depending on settings in the
Load single 1-element structure and replicate to all lanes of one register loads one element from memory into every element of one or two vectors. For details of the addressing mode, see
Depending on settings in the
Load multiple single 1-element structures to one, two, three, or four registers loads elements from memory into one, two, three, or four registers, without de-interleaving. Every element of each register is loaded. For details of the addressing mode, see
Depending on settings in the
Load single 2-element structure to one lane of two registers loads one 2-element structure from memory into corresponding elements of two registers. Elements of the registers that are not loaded are unchanged. For details of the addressing mode, see
Depending on settings in the
Load single 2-element structure and replicate to all lanes of two registers loads one 2-element structure from memory into all lanes of two registers. For details of the addressing mode, see
Depending on settings in the
Load multiple 2-element structures to two or four registers loads multiple 2-element structures from memory into two or four registers, with de-interleaving. For more information, see
Depending on settings in the
Load single 3-element structure to one lane of three registers loads one 3-element structure from memory into corresponding elements of three registers. Elements of the registers that are not loaded are unchanged. For details of the addressing mode, see
Depending on settings in the
Load single 3-element structure and replicate to all lanes of three registers loads one 3-element structure from memory into all lanes of three registers. For details of the addressing mode, see
Depending on settings in the
Load multiple 3-element structures to three registers loads multiple 3-element structures from memory into three registers, with de-interleaving. For more information, see
Depending on settings in the
Load single 4-element structure to one lane of four registers loads one 4-element structure from memory into corresponding elements of four registers. Elements of the registers that are not loaded are unchanged. For details of the addressing mode, see
Depending on settings in the
Load single 4-element structure and replicate to all lanes of four registers loads one 4-element structure from memory into all lanes of four registers. For details of the addressing mode, see
Depending on settings in the
Load multiple 4-element structures to four registers loads multiple 4-element structures from memory into four registers, with de-interleaving. For more information, see
Depending on settings in the
Load Multiple SIMD&FP registers loads multiple registers from consecutive locations in the Advanced SIMD and floating-point register file using an address from a general-purpose register.
Depending on settings in the
Load SIMD&FP register (immediate) loads a single register from the Advanced SIMD and floating-point register file, using an address from a general-purpose register, with an optional offset.
Depending on settings in the
Load SIMD&FP register (literal) loads a single register from the Advanced SIMD and floating-point register file, using an address from the PC value and an immediate offset.
Depending on settings in the
Vector Maximum compares corresponding elements in two vectors, and copies the larger of each pair into the corresponding element in the destination vector.
The operand vector elements are floating-point numbers.
Depending on settings in the
Vector Maximum compares corresponding elements in two vectors, and copies the larger of each pair into the corresponding element in the destination vector.
The operand vector elements can be any one of:
The result vector elements are the same size as the operand vector elements.
Depending on settings in the
This instruction determines the floating-point maximum number.
It handles NaNs in consistence with the IEEE754-2008 specification. It returns the numerical operand when one operand is numerical and the other is a quiet NaN, but otherwise the result is identical to floating-point
This instruction is not conditional.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VMIN": return { "tooltip": "Vector Minimum compares corresponding elements in two vectors, and copies the smaller of each pair into the corresponding element in the destination vector.", "html": "Vector Minimum compares corresponding elements in two vectors, and copies the smaller of each pair into the corresponding element in the destination vector.
The operand vector elements are floating-point numbers.
Depending on settings in the
Vector Minimum compares corresponding elements in two vectors, and copies the smaller of each pair into the corresponding element in the destination vector.
The operand vector elements can be any one of:
The result vector elements are the same size as the operand vector elements.
Depending on settings in the
This instruction determines the floating point minimum number.
It handles NaNs in consistence with the IEEE754-2008 specification. It returns the numerical operand when one operand is numerical and the other is a quiet NaN, but otherwise the result is identical to floating-point
This instruction is not conditional.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VMLA": return { "tooltip": "Vector Multiply Accumulate multiplies corresponding elements in two vectors, and accumulates the results into the elements of the destination vector.", "html": "Vector Multiply Accumulate multiplies corresponding elements in two vectors, and accumulates the results into the elements of the destination vector.
Depending on settings in the
Vector Multiply Accumulate multiplies corresponding elements in two vectors, and adds the products to the corresponding elements of the destination vector.
Depending on settings in the
Vector Multiply Accumulate multiplies elements of a vector by a scalar, and adds the products to corresponding elements of the destination vector.
For more information about scalars see
Depending on settings in the
Vector Multiply Accumulate Long multiplies corresponding elements in two vectors, and add the products to the corresponding element of the destination vector. The destination vector element is twice as long as the elements that are multiplied.
Depending on settings in the
Vector Multiply Accumulate Long multiplies elements of a vector by a scalar, and adds the products to corresponding elements of the destination vector. The destination vector elements are twice as long as the elements that are multiplied.
For more information about scalars see
Depending on settings in the
Vector Multiply Subtract multiplies corresponding elements in two vectors, subtracts the products from corresponding elements of the destination vector, and places the results in the destination vector.
Arm recommends that software does not use the
Depending on settings in the
Vector Multiply Subtract multiplies corresponding elements in two vectors, and subtracts the products from the corresponding elements of the destination vector.
Depending on settings in the
Vector Multiply Subtract multiplies elements of a vector by a scalar, and either subtracts the products from corresponding elements of the destination vector.
For more information about scalars see
Depending on settings in the
Vector Multiply Subtract Long multiplies corresponding elements in two vectors, and subtract the products from the corresponding elements of the destination vector. The destination vector element is twice as long as the elements that are multiplied.
Depending on settings in the
Vector Multiply Subtract Long multiplies elements of a vector by a scalar, and subtracts the products from corresponding elements of the destination vector. The destination vector elements are twice as long as the elements that are multiplied.
For more information about scalars see
Depending on settings in the
BFloat16 floating-point matrix multiply-accumulate. This instruction multiplies the 2x4 matrix of BF16 values in the first 128-bit source vector by the 4x2 BF16 matrix in the second 128-bit source vector. The resulting 2x2 single-precision matrix product is then added destructively to the 2x2 single-precision matrix in the 128-bit destination vector. This is equivalent to performing a 4-way dot product per destination element. The instruction does not update the
Arm expects that the VMMLA instruction will deliver a peak BF16 multiply throughput that is at least as high as can be achieved using two VDOT instructions, with a goal that it should have significantly higher throughput.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VMOV": return { "tooltip": "Copy two general-purpose registers to or from a SIMD&FP register copies two words from two general-purpose registers into a doubleword register in the Advanced SIMD and floating-point register file, or from a doubleword register in the Advanced SIMD and floating-point register file to two general-purpose registers.", "html": "Copy two general-purpose registers to or from a SIMD&FP register copies two words from two general-purpose registers into a doubleword register in the Advanced SIMD and floating-point register file, or from a doubleword register in the Advanced SIMD and floating-point register file to two general-purpose registers.
Depending on settings in the
Copy 16 bits of a general-purpose register to or from a 32-bit SIMD&FP register. This instruction transfers the value held in the bottom 16 bits of a 32-bit SIMD&FP register to the bottom 16 bits of a general-purpose register, or the value held in the bottom 16 bits of a general-purpose register to the bottom 16 bits of a 32-bit SIMD&FP register.
Depending on settings in the
Copy immediate value to a SIMD&FP register places an immediate constant into every element of the destination register.
Depending on settings in the
Copy between FP registers copies the contents of one FP register to another.
Depending on settings in the
Copy a general-purpose register to a vector element copies a byte, halfword, or word from a general-purpose register into an Advanced SIMD scalar.
On a Floating-point-only system, this instruction transfers one word to the upper or lower half of a double-precision floating-point register from a general-purpose register. This is an identical operation to the Advanced SIMD single word transfer.
For more information about scalars see
Depending on settings in the
Copy a general-purpose register to or from a 32-bit SIMD&FP register. This instruction transfers the value held in a 32-bit SIMD&FP register to a general-purpose register, or the value held in a general-purpose register to a 32-bit SIMD&FP register.
Depending on settings in the
Copy a vector element to a general-purpose register with sign or zero extension copies a byte, halfword, or word from an Advanced SIMD scalar to a general-purpose register. Bytes and halfwords can be either zero-extended or sign-extended.
On a Floating-point-only system, this instruction transfers one word from the upper or lower half of a double-precision floating-point register to a general-purpose register. This is an identical operation to the Advanced SIMD single word transfer.
For more information about scalars see
Depending on settings in the
Copy two general-purpose registers to a pair of 32-bit SIMD&FP registers transfers the contents of two consecutively numbered single-precision Floating-point registers to two general-purpose registers, or the contents of two general-purpose registers to a pair of single-precision Floating-point registers. The general-purpose registers do not have to be contiguous.
Depending on settings in the
Vector Move Long takes each element in a doubleword vector, sign or zero-extends them to twice their original length, and places the results in a quadword vector.
Depending on settings in the
Vector Move and Narrow copies the least significant half of each element of a quadword vector into the corresponding elements of a doubleword vector.
The operand vector elements can be any one of 16-bit, 32-bit, or 64-bit integers. There is no distinction between signed and unsigned integers.
Depending on settings in the
Vector Move extraction. This instruction copies the upper 16 bits of the 32-bit source SIMD&FP register into the lower 16 bits of the 32-bit destination SIMD&FP register, while clearing the remaining bits to zero.
Depending on settings in the
Move SIMD&FP Special register to general-purpose register moves the value of an Advanced SIMD and floating-point System register to a general-purpose register. When the specified System register is the
Depending on settings in the
When these settings permit the execution of Advanced SIMD and floating-point instructions, if the specified floating-point System register is not the
In an implementation that includes EL2, when
For simplicity, the
Move general-purpose register to SIMD&FP Special register moves the value of a general-purpose register to a floating-point System register.
Depending on settings in the
When these settings permit the execution of Advanced SIMD and floating-point instructions:
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VMUL": return { "tooltip": "Vector Multiply multiplies corresponding elements in two vectors, and places the results in the destination vector.", "html": "Vector Multiply multiplies corresponding elements in two vectors, and places the results in the destination vector.
Depending on settings in the
Vector Multiply multiplies corresponding elements in two vectors.
For information about multiplying polynomials, see
Depending on settings in the
Vector Multiply multiplies each element in a vector by a scalar, and places the results in a second vector.
For more information about scalars see
Depending on settings in the
Vector Multiply Long multiplies corresponding elements in two vectors. The destination vector elements are twice as long as the elements that are multiplied.
For information about multiplying polynomials see
Depending on settings in the
Vector Multiply Long multiplies each element in a vector by a scalar, and places the results in a second vector. The destination vector elements are twice as long as the elements that are multiplied.
For more information about scalars see
Depending on settings in the
Vector Bitwise NOT (immediate) places the bitwise inverse of an immediate integer constant into every element of the destination register.
Depending on settings in the
Vector Bitwise NOT (register) takes a value from a register, inverts the value of each bit, and places the result in the destination register. The registers can be either doubleword or quadword.
Depending on settings in the
Vector Negate negates each element in a vector, and places the results in a second vector. The floating-point version only inverts the sign bit.
Depending on settings in the
Vector Negate Multiply Accumulate multiplies together two floating-point register values, adds the negation of the floating-point value in the destination register to the negation of the product, and writes the result back to the destination register.
Arm recommends that software does not use the
Depending on settings in the
Vector Negate Multiply Subtract multiplies together two floating-point register values, adds the negation of the floating-point value in the destination register to the product, and writes the result back to the destination register.
Depending on settings in the
Vector Negate Multiply multiplies together two floating-point register values, and writes the negation of the result to the destination register.
Depending on settings in the
Vector bitwise OR NOT (register) performs a bitwise OR NOT operation between two registers, and places the result in the destination register. The operand and result registers can be quadword or doubleword. They must all be the same size.
Depending on settings in the
Vector Bitwise OR (immediate) performs a bitwise OR between a register value and an immediate value, and returns the result into the destination vector.
Depending on settings in the
Vector bitwise OR (register) performs a bitwise OR operation between two registers, and places the result in the destination register. The operand and result registers can be quadword or doubleword. They must all be the same size.
Depending on settings in the
Vector Pairwise Add and Accumulate Long adds adjacent pairs of elements of a vector, and accumulates the results into the elements of the destination vector.
The vectors can be doubleword or quadword. The operand elements can be 8-bit, 16-bit, or 32-bit integers. The result elements are twice the length of the operand elements.
Depending on settings in the
Vector Pairwise Add (floating-point) adds adjacent pairs of elements of two vectors, and places the results in the destination vector.
The operands and result are doubleword vectors.
The operand and result elements are floating-point numbers.
Depending on settings in the
Vector Pairwise Add (integer) adds adjacent pairs of elements of two vectors, and places the results in the destination vector.
The operands and result are doubleword vectors.
The operand and result elements must all be the same type, and can be 8-bit, 16-bit, or 32-bit integers. There is no distinction between signed and unsigned integers.
Depending on settings in the
Vector Pairwise Add Long adds adjacent pairs of elements of two vectors, and places the results in the destination vector.
The vectors can be doubleword or quadword. The operand elements can be 8-bit, 16-bit, or 32-bit integers. The result elements are twice the length of the operand elements.
Depending on settings in the
Vector Pairwise Maximum compares adjacent pairs of elements in two doubleword vectors, and copies the larger of each pair into the corresponding element in the destination doubleword vector.
Depending on settings in the
Vector Pairwise Maximum compares adjacent pairs of elements in two doubleword vectors, and copies the larger of each pair into the corresponding element in the destination doubleword vector.
Depending on settings in the
Vector Pairwise Minimum compares adjacent pairs of elements in two doubleword vectors, and copies the smaller of each pair into the corresponding element in the destination doubleword vector.
Depending on settings in the
Vector Pairwise Minimum compares adjacent pairs of elements in two doubleword vectors, and copies the smaller of each pair into the corresponding element in the destination doubleword vector.
Depending on settings in the
Pop SIMD&FP registers from stack loads multiple consecutive Advanced SIMD and floating-point register file registers from the stack.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VPUSH": return { "tooltip": "Push SIMD&FP registers to stack stores multiple consecutive registers from the Advanced SIMD and floating-point register file to the stack.", "html": "Push SIMD&FP registers to stack stores multiple consecutive registers from the Advanced SIMD and floating-point register file to the stack.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VQABS": return { "tooltip": "Vector Saturating Absolute takes the absolute value of each element in a vector, and places the results in the destination vector.", "html": "Vector Saturating Absolute takes the absolute value of each element in a vector, and places the results in the destination vector.
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Add adds the values of corresponding elements of two vectors, and places the results in the destination vector.
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Doubling Multiply Accumulate Long multiplies corresponding elements in two doubleword vectors, doubles the products, and accumulates the results into the elements of a quadword vector.
The second operand can be a scalar instead of a vector. For more information about scalars see
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Doubling Multiply Subtract Long multiplies corresponding elements in two doubleword vectors, subtracts double the products from corresponding elements of a quadword vector, and places the results in the same quadword vector.
The second operand can be a scalar instead of a vector. For more information about scalars see
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Doubling Multiply Returning High Half multiplies corresponding elements in two vectors, doubles the results, and places the most significant half of the final results in the destination vector. The results are truncated, for rounded results see
The second operand can be a scalar instead of a vector. For more information about scalars see
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Doubling Multiply Long multiplies corresponding elements in two doubleword vectors, doubles the products, and places the results in a quadword vector.
The second operand can be a scalar instead of a vector. For more information about scalars see
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Move and Narrow copies each element of the operand vector to the corresponding element of the destination vector.
The operand is a quadword vector. The elements can be any one of:
The result is a doubleword vector. The elements are half the length of the operand vector elements. If the operand is unsigned, the results are unsigned. If the operand is signed, the results can be signed or unsigned.
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Negate negates each element in a vector, and places the results in the destination vector.
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Rounding Doubling Multiply Accumulate Returning High Half. This instruction multiplies the vector elements of the first source SIMD&FP register with either the corresponding vector elements of the second source SIMD&FP register or the value of a vector element of the second source SIMD&FP register, without saturating the multiply results, doubles the results, and accumulates the most significant half of the final results with the vector elements of the destination SIMD&FP register. The results are rounded.
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Rounding Doubling Multiply Subtract Returning High Half. This instruction multiplies the vector elements of the first source SIMD&FP register with either the corresponding vector elements of the second source SIMD&FP register or the value of a vector element of the second source SIMD&FP register, without saturating the multiply results, doubles the results, and subtracts the most significant half of the final results from the vector elements of the destination SIMD&FP register. The results are rounded.
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Rounding Doubling Multiply Returning High Half multiplies corresponding elements in two vectors, doubles the results, and places the most significant half of the final results in the destination vector. The results are rounded. For truncated results see
The second operand can be a scalar instead of a vector. For more information about scalars see
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Rounding Shift Left takes each element in a vector, shifts them by a value from the least significant byte of the corresponding element of a second vector, and places the results in the destination vector. If the shift value is positive, the operation is a left shift. Otherwise, it is a right shift.
For truncated results see
The first operand and result elements are the same data type, and can be any one of:
The second operand is a signed integer of the same size.
If any of the results overflow, they are saturated. The cumulative saturation bit,
Vector Saturating Rounding Shift Right, Narrow takes each element in a quadword vector of integers, right shifts them by an immediate value, and places the rounded results in a doubleword vector.
For truncated results, see
The operand elements must all be the same size, and can be any one of:
The result elements are half the width of the operand elements. If the operand elements are signed, the results can be either signed or unsigned. If the operand elements are unsigned, the result elements must also be unsigned.
If any of the results overflow, they are saturated. The cumulative saturation bit,
Vector Saturating Shift Left (immediate) takes each element in a vector of integers, left shifts them by an immediate value, and places the results in a second vector.
The operand elements must all be the same size, and can be any one of:
The result elements are the same size as the operand elements. If the operand elements are signed, the results can be either signed or unsigned. If the operand elements are unsigned, the result elements must also be unsigned.
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Saturating Shift Left (register) takes each element in a vector, shifts them by a value from the least significant byte of the corresponding element of a second vector, and places the results in the destination vector. If the shift value is positive, the operation is a left shift. Otherwise, it is a right shift.
The results are truncated. For rounded results, see
The first operand and result elements are the same data type, and can be any one of:
The second operand is a signed integer of the same size.
If any of the results overflow, they are saturated. The cumulative saturation bit,
Vector Saturating Shift Right, Narrow takes each element in a quadword vector of integers, right shifts them by an immediate value, and places the truncated results in a doubleword vector.
For rounded results, see
The operand elements must all be the same size, and can be any one of:
The result elements are half the width of the operand elements. If the operand elements are signed, the results can be either signed or unsigned. If the operand elements are unsigned, the result elements must also be unsigned.
If any of the results overflow, they are saturated. The cumulative saturation bit,
Vector Saturating Subtract subtracts the elements of the second operand vector from the corresponding elements of the first operand vector, and places the results in the destination vector. Signed and unsigned operations are distinct.
The operand and result elements must all be the same type, and can be any one of:
If any of the results overflow, they are saturated. The cumulative saturation bit,
Depending on settings in the
Vector Rounding Add and Narrow, returning High Half adds corresponding elements in two quadword vectors, and places the most significant half of each result in a doubleword vector. The results are rounded. For truncated results, see
The operand elements can be 16-bit, 32-bit, or 64-bit integers. There is no distinction between signed and unsigned integers.
Depending on settings in the
Vector Reciprocal Estimate finds an approximate reciprocal of each element in the operand vector, and places the results in the destination vector.
The operand and result elements are the same type, and can be floating-point numbers or unsigned integers.
For details of the operation performed by this instruction see
Depending on settings in the
Vector Reciprocal Step multiplies the elements of one vector by the corresponding elements of another vector, subtracts each of the products from 2.0, and places the results into the elements of the destination vector.
The operand and result elements are floating-point numbers.
For details of the operation performed by this instruction see
Depending on settings in the
Vector Reverse in halfwords reverses the order of 8-bit elements in each halfword of the vector, and places the result in the corresponding destination vector.
There is no distinction between data types, other than size.
Depending on settings in the
Vector Reverse in words reverses the order of 8-bit or 16-bit elements in each word of the vector, and places the result in the corresponding destination vector.
There is no distinction between data types, other than size.
Depending on settings in the
Vector Reverse in doublewords reverses the order of 8-bit, 16-bit, or 32-bit elements in each doubleword of the vector, and places the result in the corresponding destination vector.
There is no distinction between data types, other than size.
Depending on settings in the
Vector Rounding Halving Add adds corresponding elements in two vectors of integers, shifts each result right one bit, and places the final results in the destination vector.
The operand and result elements are all the same type, and can be any one of:
The results of the halving operations are rounded. For truncated results, see
Depending on settings in the
Vector Round floating-point to integer towards Nearest with Ties to Away rounds a vector of floating-point values to integral floating-point values of the same size using the Round to Nearest with Ties to Away rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTA": return { "tooltip": "Round floating-point to integer to Nearest with Ties to Away rounds a floating-point value to an integral floating-point value of the same size using the Round to Nearest with Ties to Away rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Round floating-point to integer to Nearest with Ties to Away rounds a floating-point value to an integral floating-point value of the same size using the Round to Nearest with Ties to Away rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTM": return { "tooltip": "Vector Round floating-point to integer towards -Infinity rounds a vector of floating-point values to integral floating-point values of the same size, using the Round towards -Infinity rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Vector Round floating-point to integer towards -Infinity rounds a vector of floating-point values to integral floating-point values of the same size, using the Round towards -Infinity rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTM": return { "tooltip": "Round floating-point to integer towards -Infinity rounds a floating-point value to an integral floating-point value of the same size using the Round towards -Infinity rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Round floating-point to integer towards -Infinity rounds a floating-point value to an integral floating-point value of the same size using the Round towards -Infinity rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTN": return { "tooltip": "Vector Round floating-point to integer to Nearest rounds a vector of floating-point values to integral floating-point values of the same size using the Round to Nearest rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Vector Round floating-point to integer to Nearest rounds a vector of floating-point values to integral floating-point values of the same size using the Round to Nearest rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTN": return { "tooltip": "Round floating-point to integer to Nearest rounds a floating-point value to an integral floating-point value of the same size using the Round to Nearest rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Round floating-point to integer to Nearest rounds a floating-point value to an integral floating-point value of the same size using the Round to Nearest rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTP": return { "tooltip": "Vector Round floating-point to integer towards +Infinity rounds a vector of floating-point values to integral floating-point values of the same size using the Round towards +Infinity rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Vector Round floating-point to integer towards +Infinity rounds a vector of floating-point values to integral floating-point values of the same size using the Round towards +Infinity rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTP": return { "tooltip": "Round floating-point to integer towards +Infinity rounds a floating-point value to an integral floating-point value of the same size using the Round towards +Infinity rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Round floating-point to integer towards +Infinity rounds a floating-point value to an integral floating-point value of the same size using the Round towards +Infinity rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTR": return { "tooltip": "Round floating-point to integer rounds a floating-point value to an integral floating-point value of the same size using the rounding mode specified in the FPSCR. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Round floating-point to integer rounds a floating-point value to an integral floating-point value of the same size using the rounding mode specified in the FPSCR. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTX": return { "tooltip": "Vector round floating-point to integer inexact rounds a vector of floating-point values to integral floating-point values of the same size, using the Round to Nearest rounding mode, and raises the Inexact exception when the result value is not numerically equal to the input value. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Vector round floating-point to integer inexact rounds a vector of floating-point values to integral floating-point values of the same size, using the Round to Nearest rounding mode, and raises the Inexact exception when the result value is not numerically equal to the input value. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTX": return { "tooltip": "Round floating-point to integer inexact rounds a floating-point value to an integral floating-point value of the same size, using the rounding mode specified in the FPSCR, and raises an Inexact exception when the result value is not numerically equal to the input value. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Round floating-point to integer inexact rounds a floating-point value to an integral floating-point value of the same size, using the rounding mode specified in the FPSCR, and raises an Inexact exception when the result value is not numerically equal to the input value. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTZ": return { "tooltip": "Vector round floating-point to integer towards Zero rounds a vector of floating-point values to integral floating-point values of the same size, using the Round towards Zero rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Vector round floating-point to integer towards Zero rounds a vector of floating-point values to integral floating-point values of the same size, using the Round towards Zero rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRINTZ": return { "tooltip": "Round floating-point to integer towards Zero rounds a floating-point value to an integral floating-point value of the same size, using the Round towards Zero rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.", "html": "Round floating-point to integer towards Zero rounds a floating-point value to an integral floating-point value of the same size, using the Round towards Zero rounding mode. A zero input gives a zero result with the same sign, an infinite input gives an infinite result with the same sign, and a NaN is propagated as for normal arithmetic.
", "url": "https://developer.arm.com/documentation/ddi0597/latest/Base-Instructions/" }; case "VRSHL": return { "tooltip": "Vector Rounding Shift Left takes each element in a vector, shifts them by a value from the least significant byte of the corresponding element of a second vector, and places the results in the destination vector. If the shift value is positive, the operation is a left shift. If the shift value is negative, it is a rounding right shift. For a truncating shift, see VSHL.", "html": "Vector Rounding Shift Left takes each element in a vector, shifts them by a value from the least significant byte of the corresponding element of a second vector, and places the results in the destination vector. If the shift value is positive, the operation is a left shift. If the shift value is negative, it is a rounding right shift. For a truncating shift, see
The first operand and result elements are the same data type, and can be any one of:
The second operand is always a signed integer of the same size.
Depending on settings in the
Vector Rounding Shift Right takes each element in a vector, right shifts them by an immediate value, and places the rounded results in the destination vector. For truncated results, see
The operand and result elements must be the same size, and can be any one of:
Depending on settings in the
Vector Rounding Shift Right and Narrow takes each element in a vector, right shifts them by an immediate value, and places the rounded results in the destination vector. For truncated results, see
The operand elements can be 16-bit, 32-bit, or 64-bit integers. There is no distinction between signed and unsigned integers. The destination elements are half the size of the source elements.
Depending on settings in the
Vector Reciprocal Square Root Estimate finds an approximate reciprocal square root of each element in a vector, and places the results in a second vector.
The operand and result elements are the same type, and can be floating-point numbers or unsigned integers.
For details of the operation performed by this instruction see
Depending on settings in the
Vector Reciprocal Square Root Step multiplies the elements of one vector by the corresponding elements of another vector, subtracts each of the products from 3.0, divides these results by 2.0, and places the results into the elements of the destination vector.
The operand and result elements are floating-point numbers.
For details of the operation performed by this instruction see
Depending on settings in the
Vector Rounding Shift Right and Accumulate takes each element in a vector, right shifts them by an immediate value, and accumulates the rounded results into the destination vector. For truncated results, see
The operand and result elements must all be the same type, and can be any one of:
Depending on settings in the
Vector Rounding Subtract and Narrow, returning High Half subtracts the elements of one quadword vector from the corresponding elements of another quadword vector, takes the most significant half of each result, and places the final results in a doubleword vector. The results are rounded. For truncated results, see
The operand elements can be 16-bit, 32-bit, or 64-bit integers. There is no distinction between signed and unsigned integers.
Depending on settings in the
Dot Product vector form with signed integers. This instruction performs the dot product of the four 8-bit elements in each 32-bit element of the first source register with the four 8-bit elements of the corresponding 32-bit element in the second source register, accumulating the result into the corresponding 32-bit element of the destination register.
In Armv8.2 and Armv8.3, this is an
Dot Product index form with signed integers. This instruction performs the dot product of the four 8-bit elements in each 32-bit element of the first source register with the four 8-bit elements of an indexed 32-bit element in the second source register, accumulating the result into the corresponding 32-bit element of the destination register.
In Armv8.2 and Armv8.3, this is an
Floating-point conditional select allows the destination register to take the value in either one or the other source register according to the condition codes in the
Vector Shift Left (immediate) takes each element in a vector of integers, left shifts them by an immediate value, and places the results in the destination vector.
Bits shifted out of the left of each element are lost.
The elements must all be the same size, and can be 8-bit, 16-bit, 32-bit, or 64-bit integers. There is no distinction between signed and unsigned integers.
Depending on settings in the
Vector Shift Left (register) takes each element in a vector, shifts them by a value from the least significant byte of the corresponding element of a second vector, and places the results in the destination vector. If the shift value is positive, the operation is a left shift. If the shift value is negative, it is a truncating right shift.
For a rounding shift, see
The first operand and result elements are the same data type, and can be any one of:
The second operand is always a signed integer of the same size.
Depending on settings in the
Vector Shift Left Long takes each element in a doubleword vector, left shifts them by an immediate value, and places the results in a quadword vector.
The operand elements can be:
The result elements are twice the length of the operand elements.
Depending on settings in the
Vector Shift Right takes each element in a vector, right shifts them by an immediate value, and places the truncated results in the destination vector. For rounded results, see
The operand and result elements must be the same size, and can be any one of:
Depending on settings in the
Vector Shift Right Narrow takes each element in a vector, right shifts them by an immediate value, and places the truncated results in the destination vector. For rounded results, see
The operand elements can be 16-bit, 32-bit, or 64-bit integers. There is no distinction between signed and unsigned integers. The destination elements are half the size of the source elements.
Depending on settings in the
Vector Shift Left and Insert takes each element in the operand vector, left shifts them by an immediate value, and inserts the results in the destination vector. Bits shifted out of the left of each element are lost.
The elements must all be the same size, and can be 8-bit, 16-bit, 32-bit, or 64-bit. There is no distinction between data types.
Depending on settings in the
The widening integer matrix multiply-accumulate instruction multiplies the 2x8 matrix of signed 8-bit integer values held in the first source vector by the 8x2 matrix of signed 8-bit integer values in the second source vector. The resulting 2x2 32-bit integer matrix product is destructively added to the 32-bit integer matrix accumulator held in the destination vector. This is equivalent to performing an 8-way dot product per destination element.
From Armv8.2, this is an
Square Root calculates the square root of the value in a floating-point register and writes the result to another floating-point register.
Depending on settings in the
Vector Shift Right and Accumulate takes each element in a vector, right shifts them by an immediate value, and accumulates the truncated results into the destination vector. For rounded results, see
The operand and result elements must all be the same type, and can be any one of:
Depending on settings in the
Vector Shift Right and Insert takes each element in the operand vector, right shifts them by an immediate value, and inserts the results in the destination vector. Bits shifted out of the right of each element are lost.
The elements must all be the same size, and can be 8-bit, 16-bit, 32-bit, or 64-bit. There is no distinction between data types.
Depending on settings in the
Store single element from one lane of one register stores one element to memory from one element of a register. For details of the addressing mode, see
Depending on settings in the
Store multiple single elements from one, two, three, or four registers stores elements to memory from one, two, three, or four registers, without interleaving. Every element of each register is stored. For details of the addressing mode, see
Depending on settings in the
Store single 2-element structure from one lane of two registers stores one 2-element structure to memory from corresponding elements of two registers. For details of the addressing mode, see
Depending on settings in the
Store multiple 2-element structures from two or four registers stores multiple 2-element structures from two or four registers to memory, with interleaving. For more information, see
Depending on settings in the
Store single 3-element structure from one lane of three registers stores one 3-element structure to memory from corresponding elements of three registers. For details of the addressing mode, see
Depending on settings in the
Store multiple 3-element structures from three registers stores multiple 3-element structures to memory from three registers, with interleaving. For more information, see
Depending on settings in the
Store single 4-element structure from one lane of four registers stores one 4-element structure to memory from corresponding elements of four registers. For details of the addressing mode, see
Depending on settings in the
Store multiple 4-element structures from four registers stores multiple 4-element structures to memory from four registers, with interleaving. For more information, see
Depending on settings in the
Store multiple SIMD&FP registers stores multiple registers from the Advanced SIMD and floating-point register file to consecutive memory locations using an address from a general-purpose register.
Depending on settings in the
Store SIMD&FP register stores a single register from the Advanced SIMD and floating-point register file to memory, using an address from a general-purpose register, with an optional offset.
Depending on settings in the
Vector Subtract (floating-point) subtracts the elements of one vector from the corresponding elements of another vector, and places the results in the destination vector.
Depending on settings in the
Vector Subtract (integer) subtracts the elements of one vector from the corresponding elements of another vector, and places the results in the destination vector.
Depending on settings in the
Vector Subtract and Narrow, returning High Half subtracts the elements of one quadword vector from the corresponding elements of another quadword vector, takes the most significant half of each result, and places the final results in a doubleword vector. The results are truncated. For rounded results, see
There is no distinction between signed and unsigned integers.
Depending on settings in the
Vector Subtract Long subtracts the elements of one doubleword vector from the corresponding elements of another doubleword vector, and places the results in a quadword vector. Before subtracting, it sign-extends or zero-extends the elements of both operands.
Depending on settings in the
Vector Subtract Wide subtracts the elements of a doubleword vector from the corresponding elements of a quadword vector, and places the results in another quadword vector. Before subtracting, it sign-extends or zero-extends the elements of the doubleword operand.
Depending on settings in the
Dot Product index form with signed and unsigned integers. This instruction performs the dot product of the four signed 8-bit integer values in each 32-bit element of the first source register with the four unsigned 8-bit integer values in an indexed 32-bit element of the second source register, accumulating the result into the corresponding 32-bit element of the destination register.
From Armv8.2, this is an
Vector Swap exchanges the contents of two vectors. The vectors can be either doubleword or quadword. There is no distinction between data types.
Depending on settings in the
Vector Table Lookup uses byte indexes in a control vector to look up byte values in a table and generate a new vector. Indexes out of range return 0.
Vector Table Extension works in the same way, except that indexes out of range leave the destination element unchanged.
Depending on settings in the
Vector Transpose treats the elements of its operand vectors as elements of 2 x 2 matrices, and transposes the matrices.
The elements of the vectors can be 8-bit, 16-bit, or 32-bit. There is no distinction between data types.
Depending on settings in the
Vector Test Bits takes each element in a vector, and bitwise ANDs it with the corresponding element of a second vector. If the result is not zero, the corresponding element in the destination vector is set to all ones. Otherwise, it is set to all zeros.
The operand vector elements can be any one of:
The result vector elements are fields the same size as the operand vector elements.
Depending on settings in the
Dot Product vector form with unsigned integers. This instruction performs the dot product of the four 8-bit elements in each 32-bit element of the first source register with the four 8-bit elements of the corresponding 32-bit element in the second source register, accumulating the result into the corresponding 32-bit element of the destination register.
In Armv8.2 and Armv8.3, this is an
Dot Product index form with unsigned integers. This instruction performs the dot product of the four 8-bit elements in each 32-bit element of the first source register with the four 8-bit elements of an indexed 32-bit element in the second source register, accumulating the result into the corresponding 32-bit element of the destination register.
In Armv8.2 and Armv8.3, this is an
The widening integer matrix multiply-accumulate instruction multiplies the 2x8 matrix of unsigned 8-bit integer values held in the first source vector by the 8x2 matrix of unsigned 8-bit integer values in the second source vector. The resulting 2x2 32-bit integer matrix product is destructively added to the 32-bit integer matrix accumulator held in the destination vector. This is equivalent to performing an 8-way dot product per destination element.
From Armv8.2, this is an
Dot Product vector form with mixed-sign integers. This instruction performs the dot product of the four unsigned 8-bit integer values in each 32-bit element of the first source register with the four signed 8-bit integer values in the corresponding 32-bit element of the second source register, accumulating the result into the corresponding 32-bit element of the destination register.
From Armv8.2, this is an
Dot Product index form with unsigned and signed integers. This instruction performs the dot product of the four unsigned 8-bit integer values in each 32-bit element of the first source register with the four signed 8-bit integer values in an indexed 32-bit element of the second source register, accumulating the result into the corresponding 32-bit element of the destination register.
From Armv8.2, this is an
The widening integer matrix multiply-accumulate instruction multiplies the 2x8 matrix of unsigned 8-bit integer values held in the first source vector by the 8x2 matrix of signed 8-bit integer values in the second source vector. The resulting 2x2 32-bit integer matrix product is destructively added to the 32-bit integer matrix accumulator held in the destination vector. This is equivalent to performing an 8-way dot product per destination element.
From Armv8.2, this is an
Vector Unzip de-interleaves the elements of two vectors.
The elements of the vectors can be 8-bit, 16-bit, or 32-bit. There is no distinction between data types.
Depending on settings in the
Vector Zip interleaves the elements of two vectors.
The elements of the vectors can be 8-bit, 16-bit, or 32-bit. There is no distinction between data types.
Depending on settings in the
Wait For Event is a hint instruction that indicates that the PE can enter a low-power state and remain there until a wakeup event occurs. Wakeup events include the event signaled as a result of executing the
As described in
Wait For Interrupt is a hint instruction that indicates that the PE can enter a low-power state and remain there until a wakeup event occurs. For more information, see
As described in
For more information about the recommended use of this instruction see