The AArch64 processor (aka arm64), part 8: Bit shifting and rotation

Bit shifting and rotation instructions on AArch64 fall into two general categories: Hard-coded shift amounts and variable shifts.

The hard-coded shifts are done by repurposing the versatile bitfield manipulation instructions.

    ; logical shift left by fixed amount
    ; ubfiz Rd, Rn, #(size-shift), #shift
    lsl     Rd/zr, Rn/zr, #shift

    ; logical shift right by fixed amount
    ; ubfx  Rd, Rn, #(size-shift), #shift
    lsr     Rd/zr, Rn/zr, #shift

    ; arithmetic shift right by fixed amount
    ; sbfx  Rd, Rn, #(size-shift), #shift
    asr     Rd/zr, Rn/zr, #shift

Left shifting is done by doing a bit insertion of the surviving bits into the upper bits of the destination. It’s the special case where the number of bits is exactly equal to the register size minus the shift amount.

shift	size−shift
	⇙ ⇙ ⇙ ⇙
		zero-fill
size−shift		shift

Right shifting is the same thing, but using the unsigned bitfield extract instruction to go in the opposite direction:

size−shift		shift
	⇘ ⇘ ⇘ ⇘
zero-fill
shift	size−shift

And arithmetic right shifting uses the signed bitfield extract in order to get sign-extension behavior.

size−shift		shift
S
⇓	⇘ ⇘ ⇘ ⇘
sign-fill	S
shift	size−shift

Rotation can be synthesized from double-register extraction by using the rotation source as both of the source registers for extraction.

    ; rotate right by fixed amount
    ; extr  Rd, Rs, Rs, #shift
    ror     Rd/zr, Rs/zr, #shift

	size		shift
Rs		Rs
	⇓ ⇓ ⇓ ⇓
	Rd

Note that there is no “rotate with carry” instruction. The AArch32 rrx instruction does not exist in AArch64.¹ It would have been handy for finding the average of two unsigned integers without overflow.

The variable shifts have their own dedicated instructions.

    ; logical shift left variable
    ; Wd = Wn << (Wm & 31)
    ; Xd = Xn << (Xm & 63)
    lslv    Rd/zr, Rn/zr, Rm/zr

    ; logical shift right variable
    ; Wd = Wn >> (Wm & 31), unsigned shift
    ; Xd = Xn >> (Xm & 63), unsigned shift
    lsrv    Rd/zr, Rn/zr, Rm/zr

    ; arithmetic shift right variable
    ; Wd = Wn >> (Wm & 31), signed shift
    ; Xd = Xn >> (Xm & 63), signed shift
    asrv    Rd/zr, Rn/zr, Rm/zr

    ; rotate right variable
    ; Rd = Rn rotated right by Rm positions
    rorv    Rd/zr, Rn/zr, Rm/zr

Note that the shift amount is taken modulo the bit size of the operand. (This doesn’t really matter for RORV since rotating by the operand bit size has no effect.)

The pseudo-instructions LSL LSR, ASR, and ROR accept a register as the second input operand and convert it to the corresponding V instruction. This means that when writing assembly, you can just write LSL and let the assembler figure out which real opcode it corresponds to.

There are no S variants to the bit shifting instructions. They never update flags, unlike AArch32, which updated the carry with the last bit shifted out. If you want to know what bit got shifted out, you’ll have to calculate it yourself, say by shifting the same value again, but by one less position, and then inspecting the top/bottom bit (depending on the shift direction).

I have my guesses as to why the designers removed the flags behavior from these instructions: First, it removes a partial register update (flags), which creates a usually-unwanted dependency on the previous flags. Second, no major programming language gives you access to the bit that was shifted out, so it wasn’t used in practice anyway.

Exercise: Suppose there was no double-register extraction instruction or variable rotation instruction. Synthesize fixed and variable rotation from other instructions. (Answer below.)

Bonus chatter: In AArch32, the bottom 8 bits of the shift-count register were used. But in AArch64, only the bottom 5 (for 32-bit operands) or 6 (for 64-bit operands) bits are used.

Answer to exercise: You can synthesize a fixed rotation from a shift and a bitfield insertion.

    ; rotate r1 left by #imm, producing r0
                                        ; r1 = ABCDEFGH
    lsl     r0, r1, #imm                ; r0 = EFGH0000
    bfxil   r0, r1, #(size-imm), #imm   ; r0 = EFGHABCD

A variable rotation can be synthesized from a pair of shifts.

    ; rotate r1 left by r2, producing r0
    ; (destroys r2)
                                        ; r1 = ABCDEFGH
    lslv    r0, r1, r2                  ; r0 = EFGH0000
    mvn     r2, r2                      ; r2 = leftover bits
    lsrv    r2, r1, r2                  ; r2 = 0000ABCD
    orr     r0, r0, r2                  ; r0 = EFGHABCD

¹ Although it doesn’t explicitly have a “rotate left through carry” instruction, you can still do it in a single instruction:

    adcs    r0, r1, r1  ; r0 = r1 rotated left through carry