一、简介
CPU 中央处理器，内部主要包括寄存器、运算器、控制器。
- 寄存器：存储数据
- 运算器：处理数据
- 控制器：控制硬件
IO口的高低电平
常用寄存器
pc：程序计数器，确定指令位置sp：在任意时刻都会保存栈顶的地址，调用函数就会开辟栈空间（通过操作sp寄存器来开辟栈空间）fp：也称为x29寄存器属于通用寄存器，在某些时刻利用它来保存栈底的地址x0、x1：存放参数的寄存器w0、w1：是寄存器x0、x1的低32位，使用中w0=x0、w1=x1
x30寄存器
x30寄存器存放当前调用函数的返回地址- 当
ret指令执行时，会找到x30寄存器保存的地址值，继续向下执行
常用指令
str：读取寄存器值，存入内存中ldr：读内存中的值，存入到寄存器stp：入栈指令stp x0, x1, [sp]存入两个值ldp：出栈指令ldp x0, x1, [sp]取出两个值bl：将下一条指令的地址放入lr(x30)寄存器，跳转到标号处执行指令ret：默认使用lr(x30)寄存器的值，通过底层指令提示CPU此处作为下条指令的地址orr：orr{条件}{S} 目的寄存器，操作数1，操作数2，把结果放置到目的寄存器
函数参数和返回值
ARM64下，函数存放在x0~x7（w0~w7）这8个寄存器中，超过8个参数，就会入栈。函数返回值是放在x0寄存器中的。通用寄存器32个。
二、汇编函数嵌套
1、demo1-汇编函数嵌套
.text
.global _A, B
_A:
mov x0, #0xaaaa
bl _B
mov x0,#0xaaaa
ret
_B:
mov x0, #0xbbbb
ret
执行顺序：
demo`A:
0x102c0a0c4 <+0>: mov x0, #0xaaaa
0x102c0a0c8 <+4>: bl 0x102c0a0d4 ; B ①
0x102c0a0cc <+8>: mov x0, #0xaaaa ②
-> 0x102c0a0d0 <+12>: ret
继续执行，①和②会来回执行，①->②->①->…。
原因：在A函数中调用了B函数，这里x30的值将被置为B函数的结束地址，继续执行到ret，ret会读取了x30的地址（B函数的结束地址）①处，继续往下执行到②，因此就①->②->①->…。
下面看系统是如何处理嵌套函数的调用的：
2、demo2-c函数嵌套
int A(void);
void b() {
return;
}
void c() {
b();
}
int main(int argc, char * argv[]) {
c();
// A();
}
断点单步执行打印如下：
demo`c:
0x102f9a318 <+0>: stp x29, x30, [sp, #-0x10]!
0x102f9a31c <+4>: mov x29, sp
0x102f9a320 <+8>: bl 0x102f9a314 ; b at main.m:14:5
0x102f9a324 <+12>: ldp x29, x30, [sp], #0x10
-> 0x102f9a328 <+16>: ret
stp：写入，将x29、x30写入到栈空间stp x29, x30, [sp, #-0x10]!：等价于sp = sp-0x10（16字节）并赋值所在地址，拉伸栈空间，拉伸栈空间的大小为16字节的倍数- 执行
c函数 ldp x29, x30, [sp], #0x10：将用sp所在地址值给x29、x30赋值，sp+0x10释放空间，保持栈平衡
在每一步打印x30的值：
从上面的运行结果可以看出，x30寄存器在调起内嵌函数前，存储x30寄存器的值到 [sp, #-0x10]的地址中，内嵌函数调用完成后，重新设置当前x30 = sp（sp存储了当前函数的地址），执行到ret，ret读取到的地址即当前函数的结束地址，继续执行则跳出该函数。
3、demo3-完善demo1
在函数内调用函数，保存当前函数A结束地址x30到sp-0x10（16个字节）位置，函数B结束后重新设置x30的值为sp（函数A的结束地址），这样就完成嵌套函数调用。
.text
.global _A, B
_A:
mov x0, #0xaaaa
str x30,[sp, #-0x10]!
bl _B
mov x0,#0xaaaa
ldr x30, [sp], #0x10
ret
_B:
mov x0, #0xbbbb
ret
如下：
三、函数
上面了解了汇编函数嵌套的处理方法，下面看一下在汇编层对参数是怎么处理的。
int sum(int a, int b) {
return a+b;
}
int main(int argc, char * argv[]) {
Int res = sum(5,7);
}
断点查看主函数汇编代码：

sub sp, sp, #0x30：sp-0x30申请48个字节的栈空间（sp指向可用栈空间的栈顶），sub减指令x29、x30保存栈底栈顶，做为嵌套函数的中间变量- 上面可以看到变量值
#0x5、#0x7，存入到w0、w1寄存器中
进入sum函数内查看，汇编指令：

- 在
sum函数内拉伸栈空间 str指令将w0、w1寄存器中的值入栈，再取出计算，为什么不直接计算呢？这是编译规则（编译->汇编），防止存在内嵌函数，在内嵌函数内使用了w0、w1寄存器（参数），会影响外层函数的参数值，因此为了方便编译器操作设定了这样一条逻辑：所有参数要入栈。当然编译器也可以优化，优化后的指令就直接走add sp, sp, #0x10了sp, sp, #0x10：数据处理完成回收栈空间ret：有参数函数返回值是x0寄存器的值不是x30寄存器的值，w0是x0寄存器的低32位，因此x0=w0，ret=w0=0x12=12
编译器优化：

优化后的汇编指令：

- 优化掉了参数的存储，取值，直接将寄存器值相加
- 没有拉伸栈空间
掉了两根头发！！！
多参数demo
int sum(int a,int b,int c,int d,int e,int f,int g,int h,int i,int j,int k,int l) {
return a+b+b+c+d+e+f+g+h+i+j+k+l;
}
int main(int argc, char * argv[]) {
int res = sum(5,7);
}
main函数汇编指令如下：
初始化寄存器的值，这里使用w0~w8、x9，这里w0=x0，w9=x9，不用纠结为什么没有都使用w或x，w是x的低32位，同属于一个寄存器，在系统级别怎么用都行。过！
进入函数内部：

拉伸栈空间，存寄存器值，取值，相加，指令太多，每一条指令耗时1/主频，复合指令耗时2/主频，这么多指令，太烧了。
局部变量
demo1-函数多参数
int funcC() {
int a = 1;
int b = 2;
int c = 3;
return a+b+c;
}
int main(int argc, char * argv[]) {
int res = funcC();
}
函数汇编指令如下：
- 开辟栈空间
0x10 - 将值存入到
w8寄存器中（任意w） - 将寄存器值入栈，出栈，计算
再看一段代码：
int funcC() {
return 1+2+3;
}
int main(int argc, char * argv[]) {
int res = funcC();
}
汇编指令：

这里就执行了一条指令，其实内部有做add相关指令，这里做了优化，但相比上面声明的局部变量，这里没有开辟栈空间，省去了很多指令，每一条指令耗时1/主频，复合指令耗时2/主频，每条指令都要放电一次，耗电，局部变量悠着点用，当然真正开发中编译器是会优化掉这些多余代码。
…… ……
