一、汇编基础

作者: Mjs | 来源:发表于2021-03-22 14:31 被阅读0次

寄存器

内部部件之间由总线连接

15193669666308.jpg

CPU除了有控制器、运算器还有寄存器。其中寄存器的作用就是进行数据的临时存储。

CPU的运算速度是非常快的，为了性能CPU在内部开辟一小块临时存储区域，并在进行运算时先将数据从内存复制到这一小块临时存储区域中，运算时就在这一小快临时存储区域内进行。我们称这一小块临时存储区域为寄存器。

对于arm64系的CPU来说，如果寄存器以x开头则表明的是一个64位的寄存器，如果以w开头则表明是一个32位的寄存器，在系统中没有提供16位和8位的寄存器供访问和使用。其中32位的寄存器是64位寄存器的低32位部分并不是独立存在的。

对程序员来说，CPU中最主要部件是寄存器，可以通过改变寄存器的内容来实现对CPU的控制
不同的CPU，寄存器的个数、结构是不相同的

浮点和向量寄存器

因为浮点数的存储以及其运算的特殊性,CPU中专门提供浮点数寄存器来处理浮点数

浮点寄存器 64位: D0 - D31 32位: S0 - S31

现在的CPU支持向量运算.(向量运算在图形处理相关的领域用得非常的多)为了支持向量计算系统了也提供了众多的向量寄存器.

向量寄存器 128位:V0-V31

通用寄存器

通用寄存器也称数据地址寄存器通常用来做数据计算的临时存储、做累加、计数、地址保存等功能。定义这些寄存器的作用主要是用于在CPU指令中保存操作数，在CPU中当做一些常规变量来使用。
ARM64拥有有32个64位的通用寄存器 x0 到 x30，以及XZR(零寄存器),这些通用寄存器有时也有特定用途。
- 那么w0 到 w28 这些是32位的. 因为64位CPU可以兼容32位.所以可以只使用64位寄存器的低32位.
- 比如 w0 就是 x0的低32位!

注意:
有一种特殊的寄存器段寄存器:CS,DS,SS,ES四个寄存器来保存这些段的基地址,这个属于Intel架构CPU中.在ARM中并没有

15193699098685.jpg

通常，CPU会先将内存中的数据存储到通用寄存器中，然后再对通用寄存器中的数据进行运算
假设内存中有块红色内存空间的值是3，现在想把它的值加1，并将结果存储到蓝色内存空间

15193703231861.jpg
- CPU首先会将红色内存空间的值放到X0寄存器中：mov X0,红色内存空间
- 然后让X0寄存器与1相加：add X0,1
- 最后将值赋值给内存空间：mov 蓝色内存空间,X0

pc寄存器(program counter)

为指令指针寄存器，它指示了CPU当前要读取指令的地址
在内存或者磁盘上，指令和数据没有任何区别，都是二进制信息
CPU在工作的时候把有的信息看做指令，有的信息看做数据，为同样的信息赋予了不同的意义
- 比如 1110 0000 0000 0011 0000 1000 1010 1010
- 可以当做数据 0xE003008AA
- 也可以当做指令 mov x0, x8
CPU根据什么将内存中的信息看做指令？
- CPU将pc指向的内存单元的内容看做指令
- 如果内存中的某段内容曾被CPU执行过，那么它所在的内存单元必然被pc指向过

高速缓存

iPhoneX上搭载的ARM处理器A11它的1级缓存的容量是64KB，2级缓存的容量8M.

CPU每执行一条指令前都需要从内存中将指令读取到CPU内并执行。而寄存器的运行速度相比内存读写要快很多,为了性能,CPU还集成了一个高速缓存存储区域.当程序在运行时，先将要执行的指令代码以及数据复制到高速缓存中去(由操作系统完成).CPU直接从高速缓存依次读取指令来执行.

bl指令

CPU从何处执行指令是由pc中的内容决定的，我们可以通过改变pc的内容来控制CPU执行目标指令
ARM64提供了一个mov指令（传送指令），可以用来修改大部分寄存器的值，比如
- mov x0,#10、mov x1,#20
但是，mov指令不能用于设置pc的值，ARM64没有提供这样的功能
ARM64提供了另外的指令来修改PC的值，这些指令统称为转移指令，最简单的是bl指令

bl指令 -- 练习

在xcode中声明.s文件

.text
.global _A,_B

_A:
    mov x0,#0xa0
    mov x1,#0x00
    add x1, x0, #0x14
    mov x0,x1
    bl _B
    mov x0,#0x0
    ret

_B:
    add x0, x0, #0x10
    ret

将代码写入
就可以项目中直接运行代码


int A();

int main(int argc, char * argv[]) {
    A();
    return 0;
}

注:这些x0代码和寄存器需要在真机上编译和查看
返回时会发生死循环

SP和FP寄存器

sp寄存器在任意时刻会保存我们栈顶的地址.
fp寄存器也称为x29寄存器属于通用寄存器,但是在某些时刻我们利用它保存栈底的地址!

注意:ARM64开始,取消32位的 LDM,STM,PUSH,POP指令! 取而代之的是ldr\ldp str\stp
ARM64里面对栈的操作是16字节对齐的!!

函数调用栈

常见的函数调用开辟和恢复的栈空间

sub    sp, sp, #0x40             ; 拉伸0x40（64字节）空间
stp    x29, x30, [sp, #0x30]     ;x29\x30 寄存器入栈保护
add    x29, sp, #0x30            ; x29指向栈帧的底部
... 
ldp    x29, x30, [sp, #0x30]     ;恢复x29/x30 寄存器的值
add    sp, sp, #0x40             ; 栈平衡
ret

bl和ret指令

bl标号

将下一条指令的地址放入lr(x30)寄存器
转到标号处执行指令
B代表着跳转
L代表lr（x30）寄存器

b指令可以直接跳转

ret

默认使用lr(x30)寄存器的值,通过底层指令提示CPU此处作为下条指令地址!

ARM64平台的特色指令,它面向硬件做了优化处理的

x30寄存器

x30寄存器存放的是函数的返回地址.当ret指令执行时刻,会寻找x30寄存器保存的地址值!

关于内存读写指令

注意:读/写数据是都是往高地址读/写

str(store register)指令

将数据从寄存器中读出来,存到内存中.

ldr(load register)指令

将数据从内存中读出来,存到寄存器中

此ldr 和 str 的变种ldp 和 stp 还可以操作2个寄存器.

.text
.global _A,_B

_A:

    //sub sp,sp,#0x10
    //str x30,[sp]
    str x30,[sp,#-0x10]! ;合并上面两句
    mov x0,#0xaaaa
    bl _B
    mov x0,#0xaaaa
    //ldr x30,[sp]
    //add sp,sp,#0x10
    ldr x30,[sp],#0x10
    ret

_B:
    mov x0,#0xbbbb
    ret

注意对栈操作是16字节对齐的

堆栈操作练习

使用32个字节空间作为这段程序的栈空间,然后利用栈将x0和x1的值进行交换.

sub    sp, sp, #0x20    ;拉伸栈空间32个字节
stp    x0, x1, [sp, #0x10] ;sp往上加16个字节,存放x0 和 x1
ldp    x1, x0, [sp, #0x10] ;将sp偏移16个字节的值取出来,放入x1 和 x0

函数的参数和返回值

ARM64下,函数的参数是存放在X0到X7(W0到W7)这8个寄存器里面的.如果超过8个参数,就会入栈.
函数的返回值是放在X0 寄存器里面的.

.text
.global _suma
_suma:
    add x0,x0,x1
    ret

参数

代码

int test(int a,int b,int c,int d,int e,int f,int g,int h,int i){
    return a + b + c + d + e + f + g + h + i;
}

int main(int argc, char * argv[]) {
    test(1, 2, 3, 4, 5, 6, 7, 8, 9);
}

汇编

main:
    0x1025827b4 <+0>:  sub    sp, sp, #0x30             ; =0x30 
    0x1025827b8 <+4>:  stp    x29, x30, [sp, #0x20]
    0x1025827bc <+8>:  add    x29, sp, #0x20            ; =0x20 
    0x1025827c0 <+12>: stur   w0, [x29, #-0x4]
    0x1025827c4 <+16>: str    x1, [sp, #0x10]
    0x1025827c8 <+20>: mov    w0, #0x1
    0x1025827cc <+24>: mov    w1, #0x2
    0x1025827d0 <+28>: mov    w2, #0x3
    0x1025827d4 <+32>: mov    w3, #0x4
    0x1025827d8 <+36>: mov    w4, #0x5
    0x1025827dc <+40>: mov    w5, #0x6
    0x1025827e0 <+44>: mov    w6, #0x7
    0x1025827e4 <+48>: mov    w7, #0x8
    0x1025827e8 <+52>: mov    w8, #0x9
    0x1025827ec <+56>: str    w8, [sp]
    0x1025827f0 <+60>: bl     0x102582740               ; test at main.m:33
    0x1025827f4 <+64>: mov    w8, #0x0
    0x1025827f8 <+68>: str    w0, [sp, #0xc]
    0x1025827fc <+72>: mov    x0, x8
    0x102582800 <+76>: ldp    x29, x30, [sp, #0x20]
    0x102582804 <+80>: add    sp, sp, #0x30             ; =0x30 
    0x102582808 <+84>: ret

test:
    0x102582740 <+0>:   sub    sp, sp, #0x20             ; =0x20 
    0x102582744 <+4>:   ldr    w8, [sp, #0x20]
    0x102582748 <+8>:   str    w0, [sp, #0x1c]
    0x10258274c <+12>:  str    w1, [sp, #0x18]
    0x102582750 <+16>:  str    w2, [sp, #0x14]
    0x102582754 <+20>:  str    w3, [sp, #0x10]
    0x102582758 <+24>:  str    w4, [sp, #0xc]
    0x10258275c <+28>:  str    w5, [sp, #0x8]
    0x102582760 <+32>:  str    w6, [sp, #0x4]
    0x102582764 <+36>:  str    w7, [sp]
    0x102582768 <+40>:  ldr    w9, [sp, #0x1c]
    0x10258276c <+44>:  ldr    w10, [sp, #0x18]
    0x102582770 <+48>:  add    w9, w9, w10
    0x102582774 <+52>:  ldr    w10, [sp, #0x14]
    0x102582778 <+56>:  add    w9, w9, w10
    0x10258277c <+60>:  ldr    w10, [sp, #0x10]
    0x102582780 <+64>:  add    w9, w9, w10
    0x102582784 <+68>:  ldr    w10, [sp, #0xc]
    0x102582788 <+72>:  add    w9, w9, w10
    0x10258278c <+76>:  ldr    w10, [sp, #0x8]
    0x102582790 <+80>:  add    w9, w9, w10
    0x102582794 <+84>:  ldr    w10, [sp, #0x4]
    0x102582798 <+88>:  add    w9, w9, w10
    0x10258279c <+92>:  ldr    w10, [sp]
    0x1025827a0 <+96>:  add    w9, w9, w10
    0x1025827a4 <+100>: ldr    w10, [sp, #0x20]
    0x1025827a8 <+104>: add    w0, w9, w10
    0x1025827ac <+108>: add    sp, sp, #0x20             ; =0x20 
    0x1025827b0 <+112>: ret

前8个参数都是通过寄存器传递的，9放入了栈中

返回值

代码

struct str {
    int a;
    int b;
    int c;
    int d;
    int f;
    int g;
};

struct str getStr(int a,int b,int c,int d,int f,int g){
    struct str str1;
    str1.a = a;
    str1.b = b;
    str1.c = d;
    str1.d = d;
    str1.f = f;
    str1.g = g;
    return str1;
}

int main(int argc, char * argv[]) {
    struct str str2 =  getStr(1, 2, 3, 4, 5, 6);
}

汇编：

main:
    0x1021467c4 <+0>:  sub    sp, sp, #0x40             ; =0x40 
    0x1021467c8 <+4>:  stp    x29, x30, [sp, #0x30]
    0x1021467cc <+8>:  add    x29, sp, #0x30            ; =0x30 
    0x1021467d0 <+12>: stur   w0, [x29, #-0x4]
    0x1021467d4 <+16>: stur   x1, [x29, #-0x10]
    0x1021467d8 <+20>: add    x8, sp, #0x8              ; =0x8 
    0x1021467dc <+24>: mov    w0, #0x1
    0x1021467e0 <+28>: mov    w1, #0x2
    0x1021467e4 <+32>: mov    w2, #0x3
    0x1021467e8 <+36>: mov    w3, #0x4
    0x1021467ec <+40>: mov    w4, #0x5
    0x1021467f0 <+44>: mov    w5, #0x6
->  0x1021467f4 <+48>: bl     0x1021466fc               ; getStr at main.m:22
    0x1021467f8 <+52>: mov    w9, #0x0
    0x1021467fc <+56>: mov    x0, x9
    0x102146800 <+60>: ldp    x29, x30, [sp, #0x30]
    0x102146804 <+64>: add    sp, sp, #0x40             ; =0x40 
    0x102146808 <+68>: ret

x8执行栈区域

getStr:
    0x1021466fc <+0>:  sub    sp, sp, #0x20             ; =0x20 
    0x102146700 <+4>:  str    w0, [sp, #0x1c]
    0x102146704 <+8>:  str    w1, [sp, #0x18]
    0x102146708 <+12>: str    w2, [sp, #0x14]
    0x10214670c <+16>: str    w3, [sp, #0x10]
    0x102146710 <+20>: str    w4, [sp, #0xc]
    0x102146714 <+24>: str    w5, [sp, #0x8]
->  0x102146718 <+28>: ldr    w9, [sp, #0x1c]
    0x10214671c <+32>: str    w9, [x8]
    0x102146720 <+36>: ldr    w9, [sp, #0x18]
    0x102146724 <+40>: str    w9, [x8, #0x4]
    0x102146728 <+44>: ldr    w9, [sp, #0x10]
    0x10214672c <+48>: str    w9, [x8, #0x8]
    0x102146730 <+52>: ldr    w9, [sp, #0x10]
    0x102146734 <+56>: str    w9, [x8, #0xc]
    0x102146738 <+60>: ldr    w9, [sp, #0xc]
    0x10214673c <+64>: str    w9, [x8, #0x10]
    0x102146740 <+68>: ldr    w9, [sp, #0x8]
    0x102146744 <+72>: str    w9, [x8, #0x14]
    0x102146748 <+76>: add    sp, sp, #0x20             ; =0x20 
    0x10214674c <+80>: ret

在x8每偏移4个字节写入数据，当返回值大于8个字节也会用栈空间。

函数的局部变量

函数的局部变量放在栈里面!

int funcB(int a,int b){
    int c = 30;
    return a + b + c;
}

int main(int argc, char * argv[]) {
    funcB(10, 20);
}

main:
    0x100a7e7d0 <+0>:  sub    sp, sp, #0x30             ; =0x30 
    0x100a7e7d4 <+4>:  stp    x29, x30, [sp, #0x20]
    0x100a7e7d8 <+8>:  add    x29, sp, #0x20            ; =0x20 
    0x100a7e7dc <+12>: stur   w0, [x29, #-0x4]
    0x100a7e7e0 <+16>: str    x1, [sp, #0x10]
->  0x100a7e7e4 <+20>: mov    w0, #0xa
    0x100a7e7e8 <+24>: mov    w1, #0x14
    0x100a7e7ec <+28>: bl     0x100a7e7a0               ; funcB at main.m:24
    0x100a7e7f0 <+32>: mov    w8, #0x0
    0x100a7e7f4 <+36>: str    w0, [sp, #0xc]
    0x100a7e7f8 <+40>: mov    x0, x8
    0x100a7e7fc <+44>: ldp    x29, x30, [sp, #0x20]
    0x100a7e800 <+48>: add    sp, sp, #0x30             ; =0x30 
    0x100a7e804 <+52>: ret

funcB:
    0x100a7e7a0 <+0>:  sub    sp, sp, #0x10             ; =0x10 
    0x100a7e7a4 <+4>:  str    w0, [sp, #0xc]
    0x100a7e7a8 <+8>:  str    w1, [sp, #0x8]
->  0x100a7e7ac <+12>: mov    w8, #0x1e
    0x100a7e7b0 <+16>: str    w8, [sp, #0x4]
    0x100a7e7b4 <+20>: ldr    w8, [sp, #0xc]
    0x100a7e7b8 <+24>: ldr    w9, [sp, #0x8]
    0x100a7e7bc <+28>: add    w8, w8, w9
    0x100a7e7c0 <+32>: ldr    w9, [sp, #0x4]
    0x100a7e7c4 <+36>: add    w0, w8, w9
    0x100a7e7c8 <+40>: add    sp, sp, #0x10             ; =0x10 
    0x100a7e7cc <+44>: ret

很明显这个局部变量是在函数里面的，将c存入w8，写入到栈中,现将a和b相加，在取出c存入w9再相加存入w0返回

全局变量

代码：


int g = 12;

int func(int a,int b){
    printf("haha");
    int c = a + g + b;
    return c;
}

int main(int argc, char * argv[]) {
    func(1, 2);
}

func:
    0x102e02760 <+0>:  sub    sp, sp, #0x20             ; =0x20 
    0x102e02764 <+4>:  stp    x29, x30, [sp, #0x10]
    0x102e02768 <+8>:  add    x29, sp, #0x10            ; =0x10 
    0x102e0276c <+12>: stur   w0, [x29, #-0x4]
    0x102e02770 <+16>: str    w1, [sp, #0x8]  
    0x102e02774 <+20>: adrp   x0, 1
    0x102e02778 <+24>: add    x0, x0, #0xf20            ; =0xf20 
->    0x102e0277c <+28>: bl     0x102e02ac4               ; symbol stub for: printf
    0x102e02780 <+32>: adrp   x8, 2
    0x102e02784 <+36>: add    x8, x8, #0xd70            ; =0xd70 
    0x102e02788 <+40>: ldur   w9, [x29, #-0x4]
    0x102e0278c <+44>: ldr    w10, [x8]
    0x102e02790 <+48>: add    w9, w9, w10
    0x102e02794 <+52>: ldr    w10, [sp, #0x8]
    0x102e02798 <+56>: add    w9, w9, w10
    0x102e0279c <+60>: str    w9, [sp, #0x4]
    0x102e027a0 <+64>: ldr    w9, [sp, #0x4]
    0x102e027a4 <+68>: str    w0, [sp]
    0x102e027a8 <+72>: mov    x0, x9
    0x102e027ac <+76>: ldp    x29, x30, [sp, #0x10]
    0x102e027b0 <+80>: add    sp, sp, #0x20             ; =0x20 
    0x102e027b4 <+84>: ret

在调用printf函数的时候regist read x0可以得到x0 = 0x0000000102e03f20 "haha"
adrp: (address page)
0x102e02774 <+20>: adrp x0, 1代表将1左移12位(0x1000)然后加上pc寄存器的值（0x102e02774）,然后低12位清零得到0x102e03000
0x102e02778 <+24>: add x0, x0, #0xf20偏移地址。再加上0xf20得到0x102e03f20,得出来的结果就是刚刚读出来的x0值

0x1000大小为4096占4k大小也就是pagesize大小正好是一页的开始。（iphone中pagesize为16k）

    0x102e02780 <+32>: adrp   x8, 2
    0x102e02784 <+36>: add    x8, x8, #0xd70            ; =0xd70

同理通过地址偏移找到全局变量的值

栈：

是一种具有特殊的访问方式的存储空间(后进先出)
SP和FP寄存器
1. sp寄存器在任意时刻会保存我们栈顶的地址
2. fp寄存器也称为x29寄存器属于通用寄存器，但是某些时刻我们利用它保存栈底的地址
ARM64里面对栈的操作是16字节对齐的
栈的读写指令
1. 读：ldr（load register）指令 LDR，LDP（两个寄存器操作）
2. 写：str（store register）指令 STR，STP（两个寄存器操作）
汇编练习
sub sp, sp, #0x10 ;拉伸栈空间16个字节
stp x0, x1 [sp] ; 网sp所在的位置存放x0和x1
stp x0, x1, [sp, #-0x10]! ;sp往上加16个字节,存放x0 和 x1

状态寄存器

void func(){
    int a = 1;
    int b = 2;
    if (a == b) {
        printf("a == b\n");
    }else{
        printf("error\n");
    }
}

int main(int argc, char * argv[]) {
//    funcB(10, 20);
    func();
}

修改cpsr.png

(lldb) register write cpsr 0x40000000
a == b

更改了cpsr的值后运行结果就发生了改变

CPU内部的寄存器中,有一种特殊的寄存器(对于不同的处理器,个数和结构都可能不同).这种寄存器在ARM中,被称为状态寄存器就是CPSR(current program status register)寄存器
CPSR和其他寄存器不一样,其他寄存器是用来存放数据的,都是整个寄存器具有一个含义.而CPSR寄存器是按位起作用的,也就是说,它的每一位都有专门的含义,记录特定的信息.

注:CPSR寄存器是32位的

CPSR的低8位（包括I、F、T和M[4：0]）称为控制位，程序无法修改,除非CPU运行于特权模式下,程序才能修改控制位!
N、Z、C、V均为条件码标志位。它们的内容可被算术或逻辑运算的结果所改变，并且可以决定某条指令是否被执行!意义重大!

CPSR.jpg

N（Negative）标志

CPSR的第31位是 N，符号标志位。它记录相关指令执行后,其结果是否为负.如果为负 N = 1,如果是非负数 N = 0.

注意,在ARM64的指令集中,有的指令的执行时影响状态寄存器的,比如add\sub\or等,他们大都是运算指令(进行逻辑或算数运算)；

Z(Zero)标志

CPSR的第30位是Z，0标志位。它记录相关指令执行后,其结果是否为0.如果结果为0.那么Z = 1.如果结果不为0,那么Z = 0.

对于Z的值,我们可以这样来看,Z标记相关指令的计算结果是否为0,如果为0,则Z要记录下"是0"这样的肯定信息.在计算机中1表示逻辑真,表示肯定.所以当结果为0的时候Z = 1,表示"结果是0".如果结果不为0,则Z要记录下"不是0"这样的否定信息.在计算机中0表示逻辑假,表示否定,所以当结果不为0的时候Z = 0,表示"结果不为0"。

C(Carry)标志

CPSR的第29位是C，进位标志位。一般情况下,进行无符号数的运算。
加法运算：当运算结果产生了进位时（无符号数溢出），C=1，否则C=0。
减法运算（包括CMP）：当运算时产生了借位时（无符号数溢出），C=0，否则C=1。

对于位数为N的无符号数来说，其对应的二进制信息的最高位，即第N - 1位，就是它的最高有效位，而假想存在的第N位，就是相对于最高有效位的更高位。如下图所示：

15468591547671.jpg

进位

我们知道，当两个数据相加的时候，有可能产生从最高有效位想更高位的进位。比如两个32位数据：0xaaaaaaaa + 0xaaaaaaaa,将产生进位。由于这个进位值在32位中无法保存，我们就只是简单的说这个进位值丢失了。其实CPU在运算的时候，并不丢弃这个进位制，而是记录在一个特殊的寄存器的某一位上。ARM下就用C位来记录这个进位值。比如，下面的指令

mov w0,#0xaaaaaaaa；0xa 的二进制是 1010
adds w0,w0,w0； 执行后 相当于 1010 << 1 进位1（无符号溢出） 所以C标记 为 1
adds w0,w0,w0； 执行后 相当于 0101 << 1 进位0（无符号没溢出） 所以C标记 为 0
adds w0,w0,w0； 重复上面操作
adds w0,w0,w0

借位

当两个数据做减法的时候，有可能向更高位借位。再比如，两个32位数据：0x00000000 - 0x000000ff,将产生借位，借位后，相当于计算0x100000000 - 0x000000ff。得到0xffffff01 这个值。由于借了一位，所以C位用来标记借位。C = 0.比如下面指令：

mov w0,#0x0
subs w0,w0,#0xff ;
subs w0,w0,#0xff
subs w0,w0,#0xff

V(Overflow)溢出标志

CPSR的第28位是V，溢出标志位。在进行有符号数运算的时候，如果超过了机器所能标识的范围，称为溢出。

正数 + 正数为负数溢出
负数 + 负数为正数溢出
正数 + 负数不可能溢出

if 判断

代码：

void fund(int a,int b){
    if (a > b) {
        g = a;
    }else{
        g = b;
    }
}

int main(int argc, char * argv[]) {
    fund(1, 2);
}

fund:
    0x100a6676c <+0>:  sub    sp, sp, #0x10             ; =0x10 
    0x100a66770 <+4>:  str    w0, [sp, #0xc]
    0x100a66774 <+8>:  str    w1, [sp, #0x8]
->  0x100a66778 <+12>: ldr    w8, [sp, #0xc]
    0x100a6677c <+16>: ldr    w9, [sp, #0x8]
    0x100a66780 <+20>: cmp    w8, w9
    0x100a66784 <+24>: b.le   0x100a6679c               ; <+48> at main.m
    0x100a66788 <+28>: adrp   x8, 2
    0x100a6678c <+32>: add    x8, x8, #0xd70            ; =0xd70 
    0x100a66790 <+36>: ldr    w9, [sp, #0xc]
    0x100a66794 <+40>: str    w9, [x8]
    0x100a66798 <+44>: b      0x100a667ac               ; <+64> at main.m:50:1
    0x100a6679c <+48>: adrp   x8, 2
    0x100a667a0 <+52>: add    x8, x8, #0xd70            ; =0xd70 
    0x100a667a4 <+56>: ldr    w9, [sp, #0x8]
    0x100a667a8 <+60>: str    w9, [x8]
    0x100a667ac <+64>: add    sp, sp, #0x10             ; =0x10 
    0x100a667b0 <+68>: ret

cmp（Compare）比较指令

CMP 把一个寄存器的内容和另一个寄存器的内容或立即数进行比较。但不存储结果，只是正确的更改标志。
一般CMP做完判断后会进行跳转，后面通常会跟上B指令！

BL 标号：跳转到标号处执行
B.LT 标号：比较结果是小于（less than），执行标号，否则不跳转
B.LE 标号：比较结果是小于等于（less than or equal to），执行标号，否则不跳转
B.GT 标号：比较结果是大于（greater than），执行标号，否则不跳转
B.GE 标号：比较结果是大于等于（greater than or equal to），执行标号，否则不跳转
B.EQ 标号：比较结果是等于，执行标号，否则不跳转
B.HI 标号：比较结果是无符号大于，执行标号，否则不跳转
B.NE 标号：比较结果是不大于，执行标号，否则不跳转

循环

void fune(){
    int nSum = 0;
    int i = 0;
    do{
        nSum += 1;
        i++;
    }while (i < 100);
}

fune:
    0x100832784 <+0>:  sub    sp, sp, #0x10             ; =0x10 
->  0x100832788 <+4>:  str    wzr, [sp, #0xc]
    0x10083278c <+8>:  str    wzr, [sp, #0x8]
    0x100832790 <+12>: ldr    w8, [sp, #0xc]
    0x100832794 <+16>: add    w8, w8, #0x1              ; =0x1 
    0x100832798 <+20>: str    w8, [sp, #0xc]
    0x10083279c <+24>: ldr    w8, [sp, #0x8]
    0x1008327a0 <+28>: add    w8, w8, #0x1              ; =0x1 
    0x1008327a4 <+32>: str    w8, [sp, #0x8]
    0x1008327a8 <+36>: ldr    w8, [sp, #0x8]
    0x1008327ac <+40>: cmp    w8, #0x64                 ; =0x64 
    0x1008327b0 <+44>: b.lt   0x100832790               ; <+12> at main.m:56:14
    0x1008327b4 <+48>: add    sp, sp, #0x10             ; =0x10 
    0x1008327b8 <+52>: ret

在判断不满足条件后跳回循环开始的地方

switch

void funf(int a){
    switch (a) {
        case 1:
            printf("打坐");
            break;
        case 2:
            printf("加红");
            break;
        case 3:
            printf("加蓝");
            break;
        case 4:
            printf("打怪");
            break;
            
        default:
            printf("啥都不干");
            break;
    }
}

funf:
    0x1009de37c <+0>:   sub    sp, sp, #0x20             ; =0x20 
    0x1009de380 <+4>:   stp    x29, x30, [sp, #0x10]
    0x1009de384 <+8>:   add    x29, sp, #0x10            ; =0x10 
    0x1009de388 <+12>:  stur   w0, [x29, #-0x4]
->  0x1009de38c <+16>:  ldur   w8, [x29, #-0x4]
    0x1009de390 <+20>:  subs   w8, w8, #0x1              ; =0x1 
    0x1009de394 <+24>:  mov    x9, x8
    0x1009de398 <+28>:  ubfx   x9, x9, #0, #32
    0x1009de39c <+32>:  cmp    x9, #0x4                  ; =0x4 
    0x1009de3a0 <+36>:  str    x9, [sp]
    0x1009de3a4 <+40>:  b.hi   0x1009de400               ; <+132> at main.m
    0x1009de3a8 <+44>:  adrp   x8, 0
    0x1009de3ac <+48>:  add    x8, x8, #0x418            ; =0x418 
    0x1009de3b0 <+52>:  ldr    x11, [sp]
    0x1009de3b4 <+56>:  ldrsw  x10, [x8, x11, lsl #2]
    0x1009de3b8 <+60>:  add    x9, x8, x10
    0x1009de3bc <+64>:  br     x9
    0x1009de3c0 <+68>:  adrp   x0, 1
    0x1009de3c4 <+72>:  add    x0, x0, #0xed3            ; =0xed3 
    0x1009de3c8 <+76>:  bl     0x1009de924               ; symbol stub for: printf
    0x1009de3cc <+80>:  b      0x1009de40c               ; <+144> at main.m:96:1
    0x1009de3d0 <+84>:  adrp   x0, 1
    0x1009de3d4 <+88>:  add    x0, x0, #0xeda            ; =0xeda 
    0x1009de3d8 <+92>:  bl     0x1009de924               ; symbol stub for: printf
    0x1009de3dc <+96>:  b      0x1009de40c               ; <+144> at main.m:96:1
    0x1009de3e0 <+100>: adrp   x0, 1
    0x1009de3e4 <+104>: add    x0, x0, #0xee1            ; =0xee1 
    0x1009de3e8 <+108>: bl     0x1009de924               ; symbol stub for: printf
    0x1009de3ec <+112>: b      0x1009de40c               ; <+144> at main.m:96:1
    0x1009de3f0 <+116>: adrp   x0, 1
    0x1009de3f4 <+120>: add    x0, x0, #0xee8            ; =0xee8 
    0x1009de3f8 <+124>: bl     0x1009de924               ; symbol stub for: printf
    0x1009de3fc <+128>: b      0x1009de40c               ; <+144> at main.m:96:1
    0x1009de400 <+132>: adrp   x0, 1
    0x1009de404 <+136>: add    x0, x0, #0xeef            ; =0xeef 
    0x1009de408 <+140>: bl     0x1009de924               ; symbol stub for: printf
    0x1009de40c <+144>: ldp    x29, x30, [sp, #0x10]
    0x1009de410 <+148>: add    sp, sp, #0x20             ; =0x20 
    0x1009de414 <+152>: ret

当判断条件小于等于3个的时候，走的是if判断，当超过3个并且有一定规律的时候就变成了现在这个样子。
ubfx x9, x9, #0, #32: 高32位清零。
br x9跳转x9所在的地址
x8d的地址里的信息为A8 FF FF FF B8 FF FF FF C8 FF FF FF E8 FF FF FF D8 FF FF FF FF 03 01 D1 FD 7B 03
ldrsw x10, [x8, x11, lsl #2]: 这是x11为1，先计算后面x11, lsl #2 1左移两位得到4，然后x8便宜4个地址得到E8 FF FF FF，反过来读就是ffffffe8取出来存入x10.

方法一开始减去case最小值subs w8, w8, #0x1
在和最大值和最小值的差值进行比较，b.hi 0x1009de400无大于跳转，说明比最大值大就跳转，如过是负数将会以0xf开头也会跳转，所以会直接剔除区间外的
之前的add x8, x8, #0x418的地址就是0x1009de414return地址后4位，这里存在一个表，这个表里存着差值+default，如果不存在这个分支直接跳转default

注意：如果各个分支差值偏差过大就会通过cmp直接比较跳转。