本文主要是讲解函数的参数
、返回值
、局部变量
在汇编中是如何存储,以及CPSR
标志寄存器
函数的参数和返回值
-
arm64下,函数的
参数
是存放在x0-x7(w0-w7)
这8个寄存器里面的,如果超过8个参数,就会入栈如果自定义函数时,
参数最好不要超过6个
(因为有两个隐藏参数self,_cmd
)如果函数需要多个参数,可以传入数组、结构体、指针等类型
-
函数的
返回值
放在x0寄存器
中- 如果返回值
大于8个
字节,就会利用内存传递
- 如果返回值
查看系统的参数汇编
下面通过系统中对函数的汇编来查看系统对参数、返回值是如何操作的
int sum(int a, int b){
return a + b;
}
- (void)viewDidLoad{
[super viewDidLoad];
sum(10, 20);
}
-
查看汇编,在跳转到sum函数之前,已经将参数存入了w0、w1
-
在sum函数中,读取w0、w1,放入w8、w9。然后将相加后的结果放入w0(即返回值在w0寄存器)
自己优化实现suma
运行发现,其结果与sum函数是一致的,结果都是30
<!--asm.s-->
.text
.global _suma
_suma:
add x0, x0, x1
ret
<!--调用-->
int suma;
- (void)viewDidLoad{
[super viewDidLoad];
suma(10, 20);
}
编译器优化
来看以下代码的汇编
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;
}
- (void)viewDidLoad {
[super viewDidLoad];
test(1, 2, 3, 4, 5, 6, 7, 8, 9);
}
-
在test函数断住,查看汇编
以下是viewDidLoad
栈空间的存入分析过程
下图是对汇编代码中入栈过程的一个图示
-
以下是
test
函数的汇编分析
编译器优化
-
debug模式改成release模式,此时再来查看汇编代码,发现没有test函数,被优化掉了
如果非要执行test,可以这样写
- (void)viewDidLoad {
[super viewDidLoad];
printf("%d", test(1, 2, 3, 4, 5, 6, 7, 8, 9));
}
汇编代码如下,发现优化后的test函数在汇编中,其本质是一个数
,也就是test函数的返回值
。(相当于将printf("%d", test(1, 2, 3, 4, 5, 6, 7, 8, 9));
直接优化成了printf("%d", 45);
)
通过汇编实现函数
- 定义函数声明及调用
int funcA(int a, int b);
- (void)viewDidLoad {
[super viewDidLoad];
int a = funcA(10, 20);
printf("%d", a);
}
- 汇编实现
funcA
.text
.global _funcA, _sum
_funcA:
sub sp, sp, #0x10
stp x29, x30, [sp] //保护lr
bl _sum
ldp x29, x30, [sp]
add sp, sp, #0x10
ret
_sum:
add x0, x0, x1
ret
<!--简写-->
_funcA:
stp x29, x30, [sp, #-0x10]!
bl _sum
ldp x29, x30, [sp], #0x10
ret
_sum:
add x0, x0, x1
ret
<!--巧合:还可以将bl替换成b-->
//b就是简单跳转,在逆向中用于绕过某些代码(例如安全监测)
_funcA:
b _sum
_sum:
add x0, x0, x1
ret
运行结果如下所示
说明:
- 关于b指令:只是跳转,不改变lr寄存器
- 拉伸栈空间和参数个数有没有关系?:有关系,当参数越多时,如果寄存器放不下,就需要用到内存。就会将栈空间放大,影响栈空间的不仅仅是参数个数,还有局部变量
函数的返回值
如果返回值是一个结构体类型,一个寄存器放不下,这时是什么情况?
有以下代码,运行查看其汇编
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 = c;
str1.d = d;
str1.f = f;
str1.g = g;
return str1;
}
- (void)viewDidLoad {
[super viewDidLoad];
struct Str str2 = getStr(1, 2, 3, 4, 5, 6);
}
- 断点运行,以下是
viewDidLoad
函数的汇编
-
以下是getStr函数的汇编代码
结论:如果返回值大于x0的8个字节
,也会使用栈空间
来存储
练习
1、如果函数的参数/返回是9个呢?
struct Str{
int a;
int b;
int c;
int d;
int e;
int f;
int g;
int h;
int i;
};
struct Str getStr(int a, int b, int c, int d, int e, int f, int g, int h, int i){
struct Str str1;
str1.a = a;
str1.b = b;
str1.c = c;
str1.d = d;
str1.e = e;
str1.f = f;
str1.g = g;
str1.h = h;
str1.i = i;
return str1;
}
- (void)viewDidLoad {
[super viewDidLoad];
struct Str str2 = getStr(1, 2, 3, 4, 5, 6, 7, 8, 9);
}
-
查看
viewDidLoad
函数汇编
-
查看
getStr
函数汇编
结论:发现前8
个参数是存储到寄存器
,第9
个参数是存储到栈空间
2、如果结构体参数是10个呢?
struct Str{
int a;
int b;
int c;
int d;
int e;
int f;
int g;
int h;
int i;
int j;
};
struct Str getStr(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j){
struct Str str1;
str1.a = a;
str1.b = b;
str1.c = c;
str1.d = d;
str1.e = e;
str1.f = f;
str1.g = g;
str1.h = h;
str1.i = i;
str1.j = j;
return str1;
}
- (void)viewDidLoad {
[super viewDidLoad];
struct Str str2 = getStr(1, 2, 3, 4, 5, 6, 7, 8, 9);
-
查看
viewDidLoad
函数汇编
-
查看
getStr
函数汇编
- 其中
w0-w7
都是参数 -
x8
用于返回值参照 -
w9
用作临时变量
- 其中
结论:前8个参数存储到寄存器,后两个参数存储到栈空间
函数的局部变量
- 函数的
局部变量
放在栈
里面
分析下面代码的汇编
int funcB(int a, int b){
int c = 6;
return a + b + c;
}
- (void)viewDidLoad {
[super viewDidLoad];
funcB(10, 20);
}
-
查看
viewDidLoad
的汇编
-
查看
funcB
的汇编
总结:
-
局部变量
存储在栈
空间 - 参数的传递是用的寄存器,然后将寄存器的值写入栈
如果函数有嵌套调用的情况呢?
int funcB(int a, int b){
int c = 6;
int d = funcSum(a, b, c);
return d;
}
int funcSum(int a, int b, int c){
int d = a + b + c;
printf("%d", d);
return d;
}
- (void)viewDidLoad {
[super viewDidLoad];
funcB(10, 20);
}
-
从viewDidLoad到funcB没有任何变化
-
来看funcB的汇编
- 参数入栈,其实本质也是对参数的一个保护
- 所以使用的参数是从栈中获取,而不是直接通过寄存器获取
- stur 操作4个字节时使用
标记/状态寄存器
标记/状态寄存器:主要用于控制程序的执行流程
引子
分析下面函数的汇编
void func(){
int a = 1;
int b = 2;
if (a == b){
printf("a == b");
}else{
printf("error");
}
}
- (void)viewDidLoad {
[super viewDidLoad];
func();
}
- 查看
func
的汇编
- 手动更改
cpsr
的值(从1000 -> 0100)
输入c执行,此时的输出是a == b
所以,从这里可以说明,高四位(31-28)是有特殊含义的
CPSR
CPU内部的寄存器中,有一种特殊的寄存器(对于不同的处理器,个数和数据结构都可能不同)。这种寄存器在ARM中,被称为
状态寄存器
,即CPSR(current program status register)寄存器
CPSR和其他寄存器不一样,其他寄存器是用来存放数据的,都是整个寄存器具有一个含义,而CPSR寄存器是按位起作用的,即它的
每一位都有专门的含义,用于记录特定的信息
注意:
CPSR
寄存器是32位
的CPSR的
低8位(包括I、F、T和M[4:0])
称为控制位
,程序无法修改
,除非CPU运行于特权模式下,程序才能修改控制位中间27-8是保留位,主要作用是为了升级,即更新扩展
-
N、Z、C、V
均为条件码标志位
,它们的内容可被算术或逻辑运算的结果所改变
,并且可以决定某条指令是否被执行,意义重大!
N(Negative)标志
- CPSR的
第31位是N
,符号标志位
,它记录相关指令执行后,其结果是否为负如果
为负
,则N=1
如果是
非负数
,则N=0
- 注意:在ARM64的指令集中,有的指令的执行时影响状态寄存器的。例如
adds/sub/or
等,他们大都是运算指令(用于进行逻辑/算数运算)- adds 执行add运算,且会改变标志位
案例调试
查看以下代码的汇编
void func(){
asm(
"mov w0, #0xffffffff\n"
"adds w0, w0, #0x0\n"
);
}
- (void)viewDidLoad {
[super viewDidLoad];
func();
}
-
执行
mov w0, #0xffffffff
:w0赋值-1
查看此时的cpsr,高4位是6(即0110)
-
执行
adds w0, w0, #0x0
:因为w0位负数,加上0x0后,仍为负数,所以N标志为1
从cpsr的值中可以看出,6变成了8,即0110 -> 1000
,N
位从0变成了1
,符合我们的预期
Z(zero)标志
- CPSR的第30位是Z,0标志位,它记录相关指令执行后,其结果是否为0
如果
结果为0
,则Z=1
(此时能确定前面两位为01,即N非负,为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“
案例调试
目的:验证z为1时,N必为0
void func(){
asm(
"mov w0, #0x0\n"
"adds w0, w0, #0x0\n"
);
}
-
查看此时的
CPSR
执行
mov w0, #0x0
和adds w0, w0, #0x0
,发现N和Z仍然是0和1修改:将adds中的0x0更改为0x1
void func(){
asm(
"mov w0, #0x0\n"
"adds w0, w0, #0x1\n"
);
}
查看CPSR,从图中可以看出,由于为结果为非负数
,所以N为0
,同时也不为0,则Z为0
C(Carry)标志
CPSR的第
29
位是C
,进位标志位
,一般情况下,进行无符号数的运算
-
加法
运算:当运算结果产生了进位时
(无符号溢出),则C=1
,否则C=0
- 例如 1111 1111 + 1 --> 1 0000 0000,此时的1就保存在C标志位
-
减法运算(包括CMP)
:当运算时产生了借位时
(无符号数溢出),C=0
,否则C=1
- 例如 0000 0001 - 0000 0010 --> 1111 1111,
对于位数为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
-
首先将
CPSR
变成0x00000000
,然后查看执行mov w0,#0xaaaaaaaa
后的CPSR
-
执行第一次
adds w0,w0,w0
:进位1,C为1
-
执行第二次
adds w0,w0,w0
:无进位,C由1变成0
-
执行第三次
adds w0,w0,w0
:有进位,0变成1
-
执行第四次
adds w0,w0,w0
,无进位,1变成0
借位
当两个数据做减法时,有可能向更高位借位,例如,两个32位数据0x00000000 - 0x000000ff
,将产生借位,借位后,相当于计算0x100000000 - 0x000000ff
,得到0xffffff01
这个值,由于借了一位,所以C位用来标记借位。C=0,例如下面的指令
mov w0,#0x0
subs w0,w0,#0xff
subs w0,w0,#0xff
subs w0,w0,#0xff
-
将CPSR修改为
0x00000000
,执行mov w0,#0x0
-
执行第一次
subs w0,w0,#0xff
:产生了借位,所以C=0
-
执行第二次
subs w0,w0,#0xff
:无借位,所以C=1
-
执行第三次
subs w0,w0,#0xff
:无借位,所以C=1
总结
-
函数参数
arm64中,参数是放在
x0-x7
的8个寄存器中如果是浮点数,就会用浮点数寄存器
如果
超过8个
参数就会用栈传递
-
函数返回值
一般函数的返回值使用
x0寄存器
保存如果返回值
大于了8个字节
(x0寄存器大小是8个字节),就会利用内存传递
返回值
-
函数局部变量
-
局部变量
存储在栈
空间
-
函数的嵌套调用:会将
x29、x30
寄存器入栈保护-
状态(标志)寄存器 - CPSR
arm64中
cpsr
寄存器(32位
)为状态寄存器-
最高4位(28、29、30、31)为标志位
-
N
标志(负标记位)执行结果为
负数N=1
执行结果
非负数N=0
-
Z
标志(0标记位)结果
为0则Z=1
结果
非0则Z=0
-
C
标志(无符号溢出)加法:
进位 C=1,否则C=0
减法:
借位 C=0,否则C=1
-
V
标志(有符号溢出)正数+正数=
负数,则V=1
正数+负数=
正数,则V=0
-