一说到函数，我就会自然而然的想到函数的栈幁结构，调用约定，参数传参顺序，返回值等，那么在arm中函数究竟是如何工作的呢，我们来举例探究一下。
栈帧的形成和关闭
int main(int argc, char **argv)
{
printf("Hello ARM! \r\n");
return 0;
}
.text:000004DC var_C = -0xC
.text:000004DC var_8 = -8
.text:000004DC
.text:000004DC STMFD SP!, {R11,LR}
.text:000004E0 ADD R11, SP, #4
.text:000004E4 SUB SP, SP, #8
.text:000004E8 STR R0, [R11,#var_8]
.text:000004EC STR R1, [R11,#var_C]
.text:000004F0 LDR R3, =(aHelloArm - 0x4FC)
.text:000004F4 ADD R3, PC, R3 ; "Hello ARM! \r"
.text:000004F8 MOV R0, R3 ; char *
.text:000004FC BL puts
.text:00000500 MOV R3, #0
.text:00000504 MOV R0, R3
.text:00000508 SUB SP, R11, #4
.text:0000050C LDMFD SP!, {R11,PC}<strong>
</strong>执行完指令STMFD SP!, {R11,LR}后，栈幁就开始形成了，此时栈幁（栈的生长方向向上）的结构如下：
接下来执行指令ADD R11, SP, #4，将R11作为栈幁指针来寻址访问栈中的变量，此时栈幁的结构如下：
然后执行SUB SP, SP, #8指令，在栈中开辟出var_8和var_C变量的空间，此时栈幁的结构如下：
接下来STR R0, [R11,#var_8]，STR R1, [R11,#var_C]两条指令就是把R0和R1的值赋值给var_8和var_C，也就是argc和argv的值，当然这涉及到函数传参的方式，我们后面再谈。现在只关注栈幁的形成。再接下来从地址000004F0到00000504的代码都是对函数printf的调用，我们可以将其跳过。当程序执行到SUB SP, R11, #4时，程序将变量var_8和var_C的存储空间从栈幁中移出，此时的栈幁结构如下：
随后执行指令LDMFD SP!, {R11,PC}将R11和LR分别出栈，并将LR的值赋值给PC使其程序能够返回到调用主函数中，到此时为止，整个栈幁全部关闭。
函数的调用约定
在X86体系中，函数的调用约定有三种，__cdecl、__stdcall、__fastcall，下面我们来看看它们们在AMR体系中又是怎样的，举例如下：
void __attribute__((__stdcall)) ShowStd(int nNumber)
{
printf("%d \r\n", nNumber);
}
void __attribute__((__cdecl)) ShowCde(int nNumber)
{
printf("%d \r\n", nNumber);
}
void __attribute__((__fastcall)) ShowFst(int nNumber)
{
printf("%d \r\n", nNumber);
}
int main(int argc, char **argv)
{
ShowStd(5);
ShowCde(5);
ShowFst(5);
return 0;
}
生成的反汇编代码如下图所示：
我们可以发现在ARM体系中，无论哪种调用约定，函数的栈平衡方式都一样。
函数的传参与返回值
void __attribute__((__stdcall)) ShowStd(int nOne, int nTwo, int nThree, int nFour, int nFive)
{
printf("%d %d %d %d %d\r\n", nOne, nTwo, nThree, nFour, nFive);
}
void __attribute__((__cdecl)) ShowCde(int nOne, int nTwo, int nThree, int nFour, int nFive)
{
printf("%d %d %d %d %d\r\n", nOne, nTwo, nThree, nFour, nFive);
}
void __attribute__((__fastcall)) ShowFst(int nOne, int nTwo, int nThree, int nFour, int nFive)
{
printf("%d %d %d %d %d\r\n", nOne, nTwo, nThree, nFour, nFive);
}
int main(int argc, char **argv)
{
ShowStd(1, 2, 3, 4, 5);
ShowCde(1, 2, 3, 4, 5);
ShowFst(1, 2, 3, 4, 5);
return 0;
}
.text:000005C0 ; int __cdecl main(int argc, const char **argv, const char **envp)
.text:000005C0 main ; DATA XREF: start+50 o
.text:000005C0 ; .got:off_2FB4 o
.text:000005C0
.text:000005C0 var_14 = -0x14
.text:000005C0 var_C = -0xC
.text:000005C0 var_8 = -8
.text:000005C0
.text:000005C0 STMFD SP!, {R11,LR}
.text:000005C4 ADD R11, SP, #4
.text:000005C8 SUB SP, SP, #0x10
.text:000005CC STR R0, [R11,#var_8]
.text:000005D0 STR R1, [R11,#var_C]
.text:000005D4 MOV R3, #5
.text:000005D8 STR R3, [SP,#0x14+var_14]
.text:000005DC MOV R0, #1
.text:000005E0 MOV R1, #2
.text:000005E4 MOV R2, #3
.text:000005E8 MOV R3, #4
.text:000005EC BL ShowStd
.text:000005F0 MOV R3, #5
.text:000005F4 STR R3, [SP,#0x14+var_14]
.text:000005F8 MOV R0, #1
.text:000005FC MOV R1, #2
.text:00000600 MOV R2, #3
.text:00000604 MOV R3, #4
.text:00000608 BL ShowCde
.text:0000060C MOV R3, #5
.text:00000610 STR R3, [SP,#0x14+var_14]
.text:00000614 MOV R0, #1
.text:00000618 MOV R1, #2
.text:0000061C MOV R2, #3
.text:00000620 MOV R3, #4
.text:00000624 BL ShowFst
.text:00000628 MOV R3, #0
.text:0000062C MOV R0, R3
.text:00000630 SUB SP, R11, #4
.text:00000634 LDMFD SP!, {R11,PC}
指令STMFD SP!, {R11,LR}、ADD R11, SP, #4、SUB SP, R11, #4、LDMFD SP!, {R11,PC}都是函数建栈幁和销毁栈幁的固定操作，基本上可以理解为函数定式，这里略去讲解。从指令SUB SP, SP, #0x10开始，函数才是真正进入功能实现。当指令执行到地址000005D4处时，此时的栈幁结构如图所示
随后执行指令MOV R3, #5和STR R3, [SP,#0x14+var_14]，将#5存放到var_14的地址空间，此时栈幁结构如下
.text:000004C4 ShowStd ; CODE XREF: main+2C p
.text:000004C4
.text:000004C4 var_1C = -0x1C
.text:000004C4 var_18 = -0x18
.text:000004C4 var_14 = -0x14
.text:000004C4 var_10 = -0x10
.text:000004C4 var_C = -0xC
.text:000004C4 var_8 = -8
.text:000004C4 arg_0 = 4
.text:000004C4
.text:000004C4 STMFD SP!, {R11,LR}
.text:000004C8 ADD R11, SP, #4
.text:000004CC SUB SP, SP, #0x18
.text:000004D0 <strong><span style="color:#ff0000;">STR R0, [R11,#var_8]</span></strong>
.text:000004D4 <span style="color:#ff0000;"> <strong>STR R1, [R11,#var_C]</strong></span>
.text:000004D8 <strong><span style="color:#ff0000;">STR R2, [R11,#var_10]</span></strong>
.text:000004DC <strong><span style="color:#ff0000;">STR R3, [R11,#var_14]</span></strong>
.text:000004E0 LDR R3, [R11,#var_14]
.text:000004E4 STR R3, [SP,#0x1C+var_1C]
.text:000004E8 <strong><span style="color:#ff0000;">LDR R3, [R11,#arg_0]</span></strong>
.text:000004EC STR R3, [SP,#0x1C+var_18]
.text:000004F0 LDR R3, =(aDDDDD - 0x4FC)
.text:000004F4 ADD R3, PC, R3 ; "%d %d %d %d %d\r\n"
.text:000004F8 MOV R0, R3 ; char *
.text:000004FC LDR R1, [R11,#var_8]
.text:00000500 LDR R2, [R11,#var_C]
.text:00000504 LDR R3, [R11,#var_10]
.text:00000508 BL printf
.text:0000050C SUB SP, R11, #4
.text:00000510 LDMFD SP!, {R11,PC}
我们来到函数ShowStd的代码继续分析，当程序执行到地址000004CC时此时的栈幁结构如下：
解决了函数传参的问题，接下来我们来看看函数的返回值，举例如下：我们来看用红色标注出来的代码，可以发现程序对寄存器R0-R3以及#5存放的地址空间都有直接引用，先将R0-R3的值存放到临时变量空间，然后再访问存放#5的地址空间，将#5赋值给R3。根据以上的特征代码，基本就可以确定，#1-#4是通过R0-R3寄存器传参，#5是通过栈传参。ShowCde与ShowFst产生的代码与ShowStd基本一致，这里分析略去。
int Add(int nOne, int nTwo)
{
return nOne + nTwo;
}
.text:00000494 Add ; CODE XREF: sub_4C4+1C p
.text:00000494
.text:00000494 var_C = -0xC
.text:00000494 var_8 = -8
.text:00000494 var_s0 = 0
.text:00000494
.text:00000494 <strong>STR R11, [SP,#-4+var_s0]!</strong>
.text:00000498 <strong>ADD R11, SP, #0</strong>
.text:0000049C SUB SP, SP, #0xC
.text:000004A0 <strong><span style="color:#ff0000;">STR R0, [R11,#var_8]</span></strong>
.text:000004A4 <strong><span style="color:#ff0000;">STR R1, [R11,#var_C]</span></strong>
.text:000004A8 <strong><span style="color:#ff0000;">LDR R2, [R11,#var_8]</span></strong>
.text:000004AC <strong><span style="color:#ff0000;">LDR R3, [R11,#var_C]</span></strong>
.text:000004B0 <strong><span style="color:#ff0000;">ADD R3, R2, R3</span></strong>
.text:000004B4 <em><strong><span style="color:#ff0000;"> MOV R0, R3</span></strong></em>
.text:000004B8 <strong>MOV SP, R11</strong>
.text:000004BC <strong>LDMFD SP!, {R11}</strong>
.text:000004C0 BX LR
加黑加粗的代码同样是栈幁的建立与销毁过程，我们只关注红色标注的代码，这里可以发现，程序将nOne和nTwo变量取值赋值给寄存器R2和R3，然后将R2和R3相加并将相加的结果赋值给寄存器R0，由此可知函数的返回值是保存在寄存器R0中的。
根据上述的分析实验，我基本上也就了解了ATPCS的基本规则，所谓ATPCS，也就是ARM-Thumb Procedure Call Standard 的缩写, 也就是ARM,Thumb的程序调用标准。现简要概括如下：
1、寄存器的使用必须满足下面的规则：
1）.子程序间通过寄存器R0一R3来传递参数，这时，寄存器R0～R3可以记作A1-A4。被调用的子程序在返回前无需恢复寄存器R0～R3的内容。
2）.在子程序中，使用寄存器R4～R11来保存局部变量．这时，寄存器 R4 ～ R11可以记作V1 ～ V8。如果在子程序中使用到了寄存器V1～V8中的某些寄存器，子程序进入时必须保存这些寄存器的值，在返回前必须恢复这些寄存器的值；对于子程序中没有用到的寄存器则不必进行这些操作。在Thumb程序中，通常只能使用寄存器R4～R7来保存局部变量。
3）.寄存器R12用作过程调用时的临时寄存器（用于保存SP，在函数返回时使用该寄存器出栈），记作ip。在子程序间的连接代码段中常有这种使用规则。
4）.寄存器R13用作数据栈指针，记作sp。在子程序中寄存器R13不能用作其他用途。寄存器sp在进入子程序时的值和退出子程序时的值必须相等。
5）.寄存器R14称为连接寄存器，记作lr。它用于保存子程序的返回地址。如果在子程序中保存了返回地址，寄存器R14则可以用作其他用途。
6）.寄存器R15是程序计数器，记作pc。它不能用作其他用途。
ATPCS下ARM寄存器的命名：
| R0 | a1 | 工作寄存器 |
| R1 | a2 | 工作寄存器 |
| R2 | a3 | 工作寄存器 |
| R3 | a4 | 工作寄存器 |
| R4 | v1 | 必须保护;局部变量寄存器 |
| R5 | v2 | 必须保护;局部变量寄存器 |
| R6 | v3 | 必须保护;局部变量寄存器 |
| R7 | v4 | 必须保护;局部变量寄存器 |
| R8 | v5 | 必须保护;局部变量寄存器 |
| R9 | v6 | 必须保护;局部变量寄存器 |
| R10 | sl | 栈限制 |
| R11 | fp | 帧指针 |
| R12 | ip | 指令指针 |
| R13 | sp | 栈指针 |
| R14 | lr | 连接寄存器 |
| R15 | pc | 程序计数器 |
2、堆栈使用规则：
ATPCS规定堆栈为FD类型，即满递减堆栈。并且堆栈的操作是8字节对齐。
而对于汇编程序来说,如果目标文件中包含了外部调用,则必须满足以下条件:
（1）、外部接口的数据栈一定是8位对齐的，也就是要保证在进入该汇编代码后,直到该汇编程序调用外部代码之间,数据栈的栈指针变化为偶数个字;
（2）、在汇编程序中使用PRESERVE8伪操作告诉连接器,本汇编程序是8字节对齐的.
3、参数的传递规则：
根据参数个数是否固定,可以将子程序分为参数个数固定的子程序和参数个数可变的子程序.这两种子程序的参数传递规则是不同的.
1.参数个数可变的子程序参数传递规则
对于参数个数可变的子程序,当参数不超过4个时,可以使用寄存器R0~R3来进行参数传递,当参数超过4个时,还可以使用数据栈来传递参数.
在参数传递时,将所有参数看做是存放在连续的内存单元中的字数据。然后,依次将各名字数据传送到寄存器R0,R1,R2,R3; 如果参数多于4个,将剩余的字数据传送到数据栈中,入栈的顺序与参数顺序相反,即最后一个字数据先入栈.
按照上面的规则,一个浮点数参数可以通过寄存器传递,也可以通过数据栈传递,也可能一半通过寄存器传递，另一半通过数据栈传递.
2.参数个数固定的子程序参数传递规则
对于参数个数固定的子程序,参数传递与参数个数可变的子程序参数传递规则不同,如果系统包含浮点运算的硬件部件。
浮点参数将按照下面的规则传递:
（1）各个浮点参数按顺序处理;
（2）为每个浮点参数分配FP寄存器;
分配的方法是,满足该浮点参数需要的且编号最小的一组连续的FP寄存器.第一个整数参数通过寄存器R0~R3来传递,其他参数通过数据栈传递.
3、子程序结果返回规则
1.结果为一个32位的整数时,可以通过寄存器R0返回.
2.结果为一个64位整数时,可以通过R0和R1返回，依此类推.
3.结果为一个浮点数时,可以通过浮点运算部件的寄存器f0,d0或者s0来返回.
4.结果为一个复合的浮点数时,可以通过寄存器f0-fN或者d0~dN来返回.
5.对于位数更多的结果,需要通过调用内存来传递.
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
