寄存器
内部部件之间由总线连接
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中并没有
通常，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寄存器
- sp寄存器在任意时刻会保存我们栈顶的地址
- fp寄存器也称为x29寄存器属于通用寄存器，但是某些时刻我们利用它保存栈底的地址
- ARM64里面 对栈的操作是16字节对齐的
- 栈的读写指令
- 读：ldr（load register）指令 LDR，LDP（两个寄存器操作）
- 写：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();
}
(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位，就是相对于最高有效位的更高位。如下图所示：
进位
我们知道，当两个数据相加的时候，有可能产生从最高有效位想更高位的进位。比如两个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直接比较跳转。