In the previous article I looked at the rich families of instructions to perform arithmetic on integer values in the general-purpose registers. This article completes most of this survey of instructions by considering those which operate with bits and other representations of data.

Move as bits

In addition to the MOV instruction to move the contents of a register to another register, there are three variants which perform bit operations as part of the move:

• MOVK – move with keep, which inserts the first operand (a 16-bit immediate value) into an X or W register without changing the bits outside it,
• MOVN – move with NOT, which performs a one’s complement (bitwise NOT) on the first operand (a 16-bit immediate value) as it’s moved,
• MOVZ – move with zero, which inserts the first operand (a 16-bit immediate value) into an X or W register, zeroing the other bits.

Some examples explain these better:
MOVK W0, #0x1234, LSL #16
moves the halfword 0x1234 which has been left-shifted (see below) 16 places to form the most significant bytes in the register W0.

Because of the limitation on size of immediate values, you can load a 64-bit immediate using a sequence of one MOV followed by three MOVKs:
MOV X0, #0xDEF0 // this is assembled as MOVZ to zero the other bits in the register
MOVK X0, #0x9ABC, LSL #16
MOVK X0, #0x5678, LSL #32
MOVK X0, #0x1234, LSL #48
which sets X0 to 0x123456789ABCDEF0.

Shifting bits

There are four ways in which the bits in a register can be shifted and rotated: LSL (logical shift left), LSR (logical shift right), ASR (arithmetic shift right) and ROR (rotate right).

LSL is an alias for LSLV, which shift bits to the left by moving in zero bits at the right:
LSL W0, W1, #1
shifts the contents of W1 one place to the left and puts the result in W0. The shift can be in a register, and for W registers can be 0-31, for X registers 0-63 in places.

For example, if W1 contained 0x0000 00F0 = 1111 0000, then shifting it left by one place converts it to 1 1110 0000 = 0x0000 01E0. Logical shift right moves the bits in the other direction.

If the integer being shifted is signed and negative, then LSR unfortunately changes its sign. To accommodate that, when shifting signed values to the right, you should use ASR, which is an alias of ASRV. This shifts in copies of the sign bit of the number rather than zeros. LSL and ASR are handy quick methods of multiplying and dividing integers by powers of 2.

LSL, LSR and their relatives all move in zeros. The other option is to move in the bits that are shifted out, which is performed by ROR, and its relative RORV.

Bitwise operations

The most common operations are:

• AND performs a bitwise AND, and has a sibling ANDS which does the same and sets NZCV flags;
• BIC and BICS perform a bitwise AND with the complement of a register value, which can be shifted;
• ORR performs a bitwise (inclusive) OR of a register value; ORN performs a bitwise (inclusive) OR of a register value and the complement of a register value;
• EOR performs a bitwise exclusive OR (XOR) of a register value; EON performs a bitwise exclusive OR (XOR) of the complement of a register value;
• MVN performs a bitwise inverse of a register value.

Miscellaneous operations you should be aware of, which are detailed in the instruction set reference, include:

• BFC, BFI, BFM, BFXIL – these clear, insert and move bitfields within registers;
• REV reverses the byte order in a register, and has relatives which work within sub-units: REV16 for each halfword, and REV32 for each word.

As promised, here’s a cheat sheet summary of the main operations using these registers:

and a tear-out PDF is here: armgpinstructions1

The next article will tackle the remaining topic involving the general-purpose registers, that of conditional operations, and their use to avoid branching. After that, I’ll move on to floating point.

Previous articles in this series:

1: Building an app to develop assembly routines, including an explanation of calling assembly language from Swift, with a complete Xcode project
2: Registers explained
3: Working with pointers
4: Controlling flow
5: Conditional loops
6: Flow, pipelines and performance
7: Moving data around
8: Integer arithmetic

Downloads:

ARM register summary
ARM operand architecture
Conditions and conditional branching instructions
Control Flow
ARM instructions for GP registers
AsmAttic 2, a complete Xcode project (version 2)
AsmAttic, a complete Xcode project (version 1)

References

Procedure Call Standard for the Arm 64-bit Architecture (ARM) from Github
Writing ARM64 Code for Apple Platforms (Apple)
Stephen Smith (2020) Programming with 64-Bit ARM Assembly Language, Apress, ISBN 978 1 4842 5880 4.
Daniel Kusswurm (2020) Modern Arm Assembly Language Programming, Apress, ISBN 978 1 4842 6266 5.
ARM64 Instruction Set Reference (ARM).