How To Inspect A Specific Bit In A Register Arm Assembly

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

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 – movement with go along, which inserts the first operand (a xvi-bit immediate value) into an 10 or W register without changing the $.25 exterior information technology,
MOVN – move with NOT, which performs a 1'south complement (bitwise Not) on the first operand (a xvi-bit immediate value) as information technology's moved,
MOVZ – move with zero, which inserts the commencement operand (a 16-fleck 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 grade the nearly pregnant bytes in the register W0.

Because of the limitation on size of immediate values, you can load a 64-flake immediate using a sequence of i MOV followed by iii MOVKs:
MOV X0, #0xDEF0 // this is assembled equally MOVZ to nix the other $.25 in the register
MOVK X0, #0x9ABC, LSL #xvi MOVK X0, #0x5678, LSL #32 MOVK X0, #0x1234, LSL #48
which sets X0 to 0x123456789ABCDEF0.

Shifting bits

There are 4 means in which the bits in a annals tin 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 past moving in zero bits at the correct:
LSL W0, W1, #i
shifts the contents of W1 i place to the left and puts the result in W0. The shift can be in a register, and for West registers can be 0-31, for X registers 0-63 in places.

For instance, if W1 contained 0x0000 00F0 = 1111 0000, then shifting it left past one place converts information technology to 1 1110 0000 = 0x0000 01E0. Logical shift right moves the $.25 in the other direction.

If the integer being shifted is signed and negative, then LSR unfortunately changes its sign. To suit 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 flake 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 past ROR, and its relative RORV.

Bitwise operations

The most mutual 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 tin 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 sectional 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 articulate, 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 crook sheet summary of the main operations using these registers:

armgpinstructions1

and a tear-out PDF is here: armgpinstructions1

The next commodity 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 manufactures in this series:

ane: Building an app to develop assembly routines, including an caption of calling assembly language from Swift, with a complete Xcode project
two: Registers explained
3: Working with pointers
4: Controlling period
5: Provisional loops
6: Period, pipelines and operation
7: Moving data around
8: Integer arithmetic

Downloads:

ARM annals 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

Process Call Standard for the Arm 64-flake Architecture (ARM) from Github
Writing ARM64 Lawmaking for Apple tree Platforms (Apple tree)
Stephen Smith (2020) Programming with 64-Bit ARM Assembly Language, Apress, ISBN 978 1 4842 5880 4.
Daniel Kusswurm (2020) Modern Arm Associates Linguistic communication Programming, Apress, ISBN 978 one 4842 6266 5.
ARM64 Instruction Set Reference (ARM).