AArch64 Tutorial

#include <stdint.h>
int64_t foo(int32_t a, int32_t b) { return (int64_t)a * b; }

uint64_t foo2(uint32_t a, uint32_t b) { return (uint64_t)a * b; }

foo:
0	smull	x0, w0, w1
4	ret

foo2:
10	umull	x0, w0, w1
14	ret

UMULL/SMULL 使得输入不需要做 sext/zext, 对比 RISC-V:

foo2:
    slli	a0,a0,32
    slli	a1,a1,32
    srli	a1,a1,32
    srli	a0,a0,32
    mul	a0,a0,a1
    ret

int32_t foo(int32_t a, int32_t b, int32_t c) { return a + b * c; }

foo:
    madd	w0, w1, w2, w0
    ret

AND <Xd|SP>, <Xn>, #<imm>

• 汇编时需要把 imm 编码成 bitmask 的形式 (encoding-of-immediate-values-on-aarch64), 并不是所有 imm 都可以被编码

imm 需要满足如下的格式:

1. imm 是某个长度为 (2,4,8,16,32,64) 的 patten 的重复, 例如 0x0110011001100110… 是 0110 这个长度为 4 的 patten 重复

2. patten 只能包含连续的 1, 或者能由连续的 1 通过循环右移得到, 例如 0110, 1001 是合法的 patten, 但 0101 不是

   # 4位的 0b0011 循环右移一位, 重复 8 次
   and w0, w0, #0x99999999
   # 32位的 0x00000006, 不移位, 不重复
   and x0, x0, #0x6
   

AND <Xd>, <Xn>, <Xm>{, <shift> #<amount>}

or

Exclusive OR, 异或

not

TST <Xn>, #<imm> 即 ANDS XZR, <Xn>, #<imm>

int foo(int x, int y) {
    if (x & 0x3) {return x;}
    return y;
}

int bar(int x, int y) {
    if (x & 0x5) {return x;}
    return y;
}

foo:
    tst	x0, 3
    csel	w0, w1, w0, eq
    ret

bar:
    mov	w2, 5
    tst	w0, w2
    csel	w0, w1, w0, eq
    ret

BIC <Xd>, <Xn>, <Xm>{, <shift> #<amount>}

Xn 中与 Xm 掩码对应的 bit 被 clear, BIC 不支持 imm

int foo(int x, int y) { return x & ~(y << 2); }

foo:
    bic	w0, w0, w1, lsl 2
    ret

ORN <Xd>, <Xn>, <Xm>{, <shift> #<amount>}

Rd = Rn OR NOT shift(Rm, amount)

int foo(int x, int y) { return x | ~(y >> 2); }

foo:
    orn	w0, w0, w1, asr 2
    ret

算术右移

• register

  ASR <Xd>, <Xn>, <Xm>

• immediate

  ASR <Xd>, <Xn>, #<shift>

  shift 范围为 0~63

循环右移

uint64_t foo(uint64_t x) { return x >> 8 | x << 56; }

foo:
    ror	x0, x0, 8
    ret

上述优化只适用于 unsigned int, 因为 `x>>8` 必须是逻辑右移才与 ror 等价

Unsigned BitField eXtract

UBFX <Xd>, <Xn>, #<lsb>, #<width>

假设 X0 为 0b0000000 0101011 000110100001110100

为了取出 0101011 部分, 需要用 `UBFX X1, X0, #18, #7`

若使用 SBFX, 则取出部分的最高位会作为符号位做符号扩展

uint32_t foo(uint32_t x) { return (x >> 8) & 0xf; }

foo:
    ubfx	x0, x0, 8, 4
    ret

BitField Insert, leaving other bits unchanged

BFI <Xd>, <Xn>, #<lsb>, #<width>

把 Xn 插入到 Xd[lsb+width:lsb] 位置, 假设 X0 为 0x1234, X1 为 0xabcd, 则 `bfi x0, x1, #4, #16` 后 X0 为 0xabcd4

uint32_t foo(uint32_t x, uint32_t y) { return (x & ~0xf0) | ((y << 4) & 0xf0); }

foo:
    bfi	w0, w1, 4, 4
    ret

UXTB: Unsigned eXTend Byte SXTH: Signed eXTend Halfword

SXTH <Xd>, <Wn>

不存在 UXTW, 因为可以用 `MOV Wd, Wn` 代替: 操作 Wd 时 Xd 的高 32 位会清零

• REV 是 reverse byte, 例如 rev(0x1234abcd) 结果为 0xcdab3412
• REV16 是以 16 bit 一组做 reverse byte, 例如 rev16(0x1234abcd) 结果为 0x3412cdab

#include <stdint.h>
uint32_t foo(uint32_t x) {
    return ((x >> 24) & 0x000000FF) | ((x >> 8) & 0x0000FF00) |
           ((x << 8) & 0x00FF0000) | ((x << 24) & 0xFF000000);
}

foo:
    rev	w0, w0
    ret

__builtin_bswap 对应 rev, 但 __builtin__bswap32/__builtin__bswap16 并非直接对应 rev32/rev16, 因为它们只会 swap 低 32/16 位, 而不是每 32/16 位一组, 例如:

uint32_t foo(uint32_t x) {
    return __builtin_bswap16(x);
}

foo:
    rev16	w0, w0
    and	w0, w0, 65535
    ret

count leading zero bits

int foo(int a) { return __builtin_clz(a); }

foo:
    clz	w0, w0
    ret

reberse bit order

arm 没有提供 ctz (count trailing zero bits), 可以通过 RBIT 和 clz 实现

int foo(int a) { return __builtin_ctz(a); }

foo:
    rbit	w0, w0
    clz	w0, w0
    ret

B <label> BL <label>

无条件相对跳转, 类似于 RISC-V 的 jal.

B 指令不需要编码 link register, BL 会隐式的使用 LR (X30), 所以指令不需要编码返回地址寄存器, 因此 imm 的地址可以达到 26 位带符号数(而不是 jal 的 20 位)

BR <Xn> BLR <Xn>

相当于 RISC-V 的 jalr.

一个典型的需要使用 BR/BLR 的场景是 plt:

00000000000004b0 <bar@plt>:
 4b0:   b0000090        adrp    x16, 11000 <__cxa_finalize>
 4b4:   f9400611        ldr     x17, [x16, #8]
 4b8:   91002210        add     x16, x16, #0x8
 4bc:   d61f0220        br      x17

RISC-V 中针对函数调用会生成 auipc+jalr, 依赖 Relaxation 把它转换为 jal, AArch64 针对函数调用则会生成 bl (而不是 adrp+blr), 靠 linker 生成 veneer 来处理过远的函数调用

$> cat test.S
    .text
    .global main
main:
    bl foo
    ret

    .data
    .rep 1<<25
    .dword 0
    .endr
foo:
    ret

$> arm-objdum a.out
...
00000000004006d4 <main>:
  4006d4:       940159d7        bl      456e30 <___veneer>
  4006d8:       d65f03c0        ret
  4006dc:       d503201f        nop
...
0000000000456e30 <___veneer>:
  456e30:       900801f0        adrp    x16, 10492000 <__dso_handle+0xfffffc0>
  456e34:       91012210        add     x16, x16, #0x48
  456e38:       d61f0200        br      x16
        ...

Disassembly of section .data:

...
0000000010492048 <foo>:
    10492048:   d65f03c0        ret
    1049204c:   00000000        udf     #0

B.<cond> <label>

label 为 imm19, 而 RISC-V 的 blt 类指令的 label 为 imm12, 因为 B.cond 不需要在指令中编码要比较的寄存器

CBZ <Xt>, <label>

跳转到 label 如果 Xt 为/不为 0. label 为 imm19

TBZ <R><t>, #<imm>, <label>

其中 imm 表示要测试第几个 bit, 而不是一个 bitmask

• offset

  LDR <Xt>, [<Xn|SP>{, #<pimm>}]

  pimm 是 imm12

  # 相当于 RISC-V 的 `ld a0, 12(a1)`
  ldr x0, [x1, #12]
  

  它和 RISC-V 的 load 类指令相同, RISC-V 只支持这一种寻址方式

• post-index

  LDR <Xt>, [<Xn|SP>], #<simm>

  simm 是 imm9, 因为需要占用额外的比特来编码 post/pre index

  ldr x0, [x1], #12
  

  post-index 类似 i++, 使用 Xn 寻址, 然后 `Xn=Xn+simm`

• pre-index

  LDR <Xt>, [<Xn|SP>, #<simm>]!

  simm 是 imm9

  ldr x0, [x1, #12]!
  

  pre-index 类似于 ++i, 即 `Xn=Xn+simm`, 然后再用 Xn 寻址

void foo(int a) { bar(); }

foo:
    # prologue 使用 pre-index, 因为 [sp, 0] 属于上一个栈帧
    stp	x29, x30, [sp, -32]!
    mov	x29, sp
    str	w0, [sp, 28]
    bl	bar
    nop
    # epilogue 使用 post-index
    ldp	x29, x30, [sp], 32
    ret

LDR <Xt>, <label>

汇编时 label 被编码为 pc-relative literal, imm19

相当于 adr + ldr, RISC-V 不支持这种寻址, 需要先用 auipc 获得 label 的地址到寄存器,然后再用类似 LDR(immediate) 的方式

另外, 通过 LDR <Xt>, ==imm 类似于 RISC-V 的 la/li 伪指令, 但是通过 literal pool 实现

    .text
    .global main
main:
    # load main 的数据
    ldr x0, main
    # load main 的地址, 注意 `=` 是必要的
    ldr x1, =main
    ldr x2, =0x1234

Disassembly of section .text:

0000000000000000 <main>:
   0:   58000000        ldr     x0, 0 <main>
                        0: R_AARCH64_LD_PREL_LO19       main
   4:   58000061        ldr     x1, 10 <main+0x10>   ---------------+
   8:   58000082        ldr     x2, 18 <main+0x18>   ----+          |
        ...                                              |          |
                        10: R_AARCH64_ABS64     main <---+----------+
  18:   00001234        .word   0x00001234           <---+
  1c:   00000000        .word   0x00000000

LDR <Xt>, [<Xn|SP>, <R><m>{, <extend> {<amount>}}]

基址变址寻址

int foo (int64_t * x, int y) {
    return *(x + y);
}

foo:
    ldr	x0, [x0, w1, sxtw 3]
    ret

类似于 RISC-V 的 lb, lh, 但 RISC-V 会自动做 sext, aarch64 的 LDRB 会做 zext, LDRSB 做 sext.

并不存在 LDRW, 因为 `ldr Wd …` 相当于 LDRW

int *x;
int foo() { return x[0] + x[1]; }

foo:
    adrp	x0, .LANCHOR0
    ldr	x1, [x0, #:lo12:.LANCHOR0]
    ldp	w2, w0, [x1]
    add	w0, w2, w0
    ret
x:
    .zero	8

MOVZ <Xd>, #<imm>{, LSL #<shift>}

`mov X0, #0x12340000` 相当于 `movz X0, #0x1234, lsl#16`

MOVe and Keep

MOVK <Xd>, #<imm>{, LSL #<shift>}

shift 只能是 0, 16, 32, 48.

`MOVK X0, #0xab, LSL#16` 会把 X0 的 `16~31` 位设为 0xab, 且 X0 的其它部分保持不变

通过多个 MOVK 可以加载任意 64 位 imm 到寄存器, 例如

movk X0, 0xaaaa, lsl #48
movk X0, 0xbbbb, lsl #32
movk X0, 0xcccc, lsl #16
movk X0, 0xdddd

X0 最终为 0xaaaabbbbccccdddd

int64_t foo () {
    return 0xaaaabbbbccccdddd;
}

0000000000000000 <foo>:
   0:   d29bbba0        mov     x0, #0xdddd                     // #56797
   4:   f2b99980        movk    x0, #0xcccc, lsl #16
   8:   f2d77760        movk    x0, #0xbbbb, lsl #32
   c:   f2f55540        movk    x0, #0xaaaa, lsl #48
  10:   d65f03c0        ret

RISC-V 的 lui 和 movk 有一点累似

• FADD/FSUB/FMUL/FDIV
• FNEG
• FCMP
• FSQRT
• FMAX/FMIN
• FNMUL
• FMADD/FMSUB/FNMADD

与 RISC-V 的 fmv 类似, 可以用来在 GPR 和 FPR 之间复制数据

    .text
    .global main
main:
    mov x0, 1
    fmov d0, x0
    # vector 寄存器也可以用做 scalar, 而非 vector 或 float
    add d0, d0, d0
    fmov x0, d0
    ret

浮点数之间转换, 例如 `fcvt s0, d0` 类似于 RISC-V 的 fcvt.s.d, 把 float 转换为 double

FCVT{x}{S,U}

float 转换为 int, 其中 x 表示不同的 rounding mode:

• Z rounding towards zero, 即 c 语言中的取整
• M rounding towards minus infinity, 即 floor
• P rounding towards positive infinity, 即 ceil
• N rounding to nearest with ties to even
• A rounding to nearest with ties to away

RISC-V 中的 fcvt.{w,l}.{d,s} 支持把 d(double), s(float) 转换为 w(int), l(long), 但 rounding mode 需要通过 fcsr 中的 frm 来设置

int 转换为 float, 类似于 RISC-V 的 fcvt.{s,d}.{w,l}

普通的 LDR/STR 等指令也可以 load/store 浮点数, 只要指定 FPR, 例如 `ldr d0, [sp]`

RET 和 `br lr` 相同, 但会影响 branch prediction

MRS: move from system register to GPR

MSR: move from GPT to system register

PACIBSP: P ointer A uthentication C ode for I nstruction address using key B and SP register

AUTIBSP: AUT henticate and restore I nstruction address that was encoded with key B and SP register

pacibsp 会使用 lr 低位有效比特/sp/secret register `B` 生成一个 hash, 放在 lr 的冗余高位. autibsp 会使用与 pacibsp 同样的信息验证 lr 高位的 hash 是正确的并去掉 hash, 恢复原始的 lr. 若验证失败则 lr 会使 ret 时 crash

这个机制用来保证栈上被篡改的 lr 无法工作

验证成功的例子:

main:
    pacibsp
    autibsp
    ret

Breakpoint 1, main () at test.S:5
5           pacibsp
(gdb) p /x $lr
$1 = 0x400784
(gdb) ni
6           autibsp
(gdb) p /x $lr
$2 = 0x53000000400784    #  0x53000000 是 pacibsp 生成的 hash
(gdb) ni
7           ret
(gdb) p /x $lr
$3 = 0x400784            # autibsp 验证 hash 通过后去掉了高位的 hash,
                         # 恢复了原始的 lr
(gdb) c
Continuing.
[Inferior 1 (process 1) exited with code 01

验证失败的例子:

main:
    pacibsp
    add sp, sp, #16
    autibsp
    ret

Breakpoint 1, main () at test.S:5
5           pacibsp
(gdb) p /x $lr
$1 = 0x400794
(gdb) ni
6           add sp, sp, #16
(gdb) p /x $lr
$2 = 0x9000000400794
(gdb) ni
main () at test.S:7
7           autibsp
(gdb) ni
8           ret
(gdb) p /x $lr
$3 = 0x40000000400794
(gdb) c
Continuing.

Program received signal SIGSEGV, Segmentation fault.
0x0040000000400794 in ?? ()

通过 `-mbranch-protection=standard` 可以打开 PAC 功能

• DMB: Data Memory Barrier
• DSB: Data Synchronization Barrier
• ISB: Instruction Synchronization Barrier.

load/store exclusive register, 类似于 RISC-V 的 LR/SC

// aarch64-linux-gnu-gcc -O3 -mno-outline-atomics
int v = 0;

int atomic_fetch_add_RELAXED(int a) {
    return __atomic_fetch_add(&v, a, __ATOMIC_RELAXED);
}

atomic_fetch_add_RELAXED:
    adrp	x1, .LANCHOR0
    mov	w2, w0
    add	x1, x1, :lo12:.LANCHOR0
.L3:
    ldxr	w0, [x1]
    add	w3, w0, w2
    stxr	w4, w3, [x1]
    cbnz	w4, .L3
    ret
v:
    .zero	4

LDAXR 类似于 RISC-V 的 lr.aq, STLXR 类似于 RISC-V 的 sc.rl, 即包含隐式的 barrier 语义

除 LDXR/STXR, LSE 还提供了 CAS 以及和 RISC-V AMO 类似的指令