arm gcc栈帧结构(1)

摘要：先看个例子： void test2(int a,int b,int c) { int k=a,j=b,m=c; } GCC反汇编： 00000064 test2: mov ip, sp //IP=SP;保管SP stmdb sp!, {fp, ip, lr, pc} //先对SP加4，再对fp，ip，lr，pc压栈。---------1 sub fp, ip, #4 ; 0x4 /]

先看个例子：

void test2(int a,int b,int c)
{
int k=a,j=b,m=c;

}
GCC反汇编：
00000064 <test2>:
mov      ip, sp                   //IP=SP;保存SP
stmdb    sp!, {fp, ip, lr, pc}    //先对SP减4，再对fp，ip，lr，pc压栈。---------1
sub      fp, ip, #4       ; 0x4    //fp=ip-4；此时fp指向栈里面的“fp”
sub      sp, sp, #24      ; 0x18  //分配空间
str      r0, [fp, #-28]           //
str      r1, [fp, #-32]           //
str      r2, [fp, #-36]           //参数压栈
ldr      r3, [fp, #-28]           //
str      r3, [fp, #-24]           //
ldr      r3, [fp, #-32]           //
str      r3, [fp, #-20]           //
ldr      r3, [fp, #-36]           //
str      r3, [fp, #-16]           //
sub      sp, fp, #12      ; 0xc    //sp=fp-12；此时sp指向栈里面的lr
ldmia    sp, {fp, sp, pc}         //弹栈pc=lr，sp=ip，fp=fp。而后地址加4---------1

汇编基础：
stmdb    sp!, {fp, ip, lr, pc} //sp=sp-4,sp=pc;先压PC
                               //sp=sp-4,sp=lr;再压lr
                               //sp=sp-4,sp=ip;再压ip
                               //sp=sp-4,sp=fp;再压fp
ldmia    sp, {fp, sp, pc}       //和stmdb成对使用，
                               //fp=sp,sp=sp+4;先弹fp
                               //sp=sp,sp=sp+4;先弹sp，此处的弹出不会影响sp，由于ldmia是一个机器周期执行完的。
                               //pc=sp,sp=sp+4;先弹pc
LDRH           R0, [R13, #0xC] //加载无符号半字数据，即低16位
LDRB           R0, [R13, #0x4] //加载一字节数据，即低8位。

注意：R11=fp;R12=ip;R13=SP；R14=LR；R15=PC；R0,R1,R2用于传递参数和存放函数返回值。
注意；低地址的寄存器被压入低地址内存中，也就是说若是向下增加，高地址寄存器先压，向上增加测试低地址先压。
注意：根据“ARM-thumb 过程调用标准”：
1，  r0-r3 用做传入函数参数，传出函数返回值。在子程序调用之间，能够将 r0-r3 用于任何用途。被调用函数在返回以前没必要恢复 r0-r3。---若是调用函数须要再次使用 r0-r3 的内容，则它必须保留这些内容。
2， r4-r11 被用来存放函数的局部变量。若是被调用函数使用了这些寄存器，它在返回以前必须恢复这些寄存器的值。
3， r12 是内部调用暂时寄存器 ip。它在过程连接胶合代码（例如，交互操做胶合代码）中用于此角色。在过程调用之间，能够将它用于任何用途。被调用函数在返回以前没必要恢复 r12。

4，寄存器 r13 是栈指针 sp。它不能用于任何其它用途。sp 中存放的值在退出被调用函数时必须与进入时的值相同。
5，寄存器 r14 是连接寄存器 lr。若是您保存了返回地址，则能够在调用之间将 r14 用于其它用途，程序返回时要恢复

6，寄存器 r15 是程序计数器 PC。它不能用于任何其它用途。

7，在中断程序中，全部的寄存器都必须保护，编译器会自动保护R4～R11，因此通常你本身只要在程序的开头
sub lr,lr,#4
stmfd sp!,{r0-r3,r12,lr}；保护R0～R3，R12,LR就能够了，除非你用汇编人为的去改变R4~R11的值。（具体去看UCOS os_cpu_a.S中的IRQ中断的代码）

 

补充：

寄存器名字
Reg #  APCS   意义
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 程序计数器

回溯结构

寄存器 fp (桢指针)应当是零或者是指向栈回溯结构的列表中的最后一个结构，提供了一种追溯程序的方式，来反向跟踪调用的函数。

回溯结构是:

地址高端

    保存代码指针         [fp]          fp 指向这里

    返回 lr 值           [fp, #-4]

    返回 sp 值           [fp, #-8]

    返回 fp 值           [fp, #-12]  指向下一个结构

    [保存的 sl]

    [保存的 v6]

    [保存的 v5]

    [保存的 v4]

    [保存的 v3]

    [保存的 v2]

    [保存的 v1]

    [保存的 a4]

    [保存的 a3]

    [保存的 a2]

    [保存的 a1]

    [保存的 f7]                           三个字

    [保存的 f6]                           三个字

    [保存的 f5]                           三个字

    [保存的 f4]                           三个字

pc 老是包含下一个要被执行的指令的位置。
lr (老是)包含着退出时要装载到 pc 中的值。在 26-bit 位代码中它还包含着 PSR。
sp 指向当前的栈块(chunk)限制，或它的上面。这是用于复制临时数据、寄存器和相似的东西到其中的地方。在 RISC OS 下，你有可选择的至少 256 字节来扩展它。
fp 要么是零，要么指向回溯结构的最当前的部分。

 

 

example:

 咱们以jemalloc 中的ifree 方法分析:

1297void
1298je_free(void *ptr)
1299{
1300
1301	UTRACE(ptr, 0, 0);
1302	if (ptr != NULL)
1303		ifree(ptr);
1304}

1209
1210JEMALLOC_INLINE_C void
1211ifree(void *ptr)
1212{
1213	size_t usize;
1214	UNUSED size_t rzsize JEMALLOC_CC_SILENCE_INIT(0);
1215
1216	assert(ptr != NULL);
1217	assert(malloc_initialized || IS_INITIALIZER);
1218
1219	if (config_prof && opt_prof) {
1220		usize = isalloc(ptr, config_prof);
1221		prof_free(ptr, usize);
1222	} else if (config_stats || config_valgrind)
1223		usize = isalloc(ptr, config_prof);
1224	if (config_stats)
1225		thread_allocated_tsd_get()->deallocated += usize;
1226	if (config_valgrind && in_valgrind)
1227		rzsize = p2rz(ptr);
1228	iqalloc(ptr);
1229	JEMALLOC_VALGRIND_FREE(ptr, rzsize);
1230}

  这是ifree 方法的backtrace

 

  图1

  下面是栈帧信息;能够看出fram 0---2 是inline 没有正真的栈帧,fram0--2 都属于fram 3

  (gcc 加-fon-inline 编译选项能够忽略inline 关键字,达到fram0-2都有栈帧的效果)
 

 

  图2

    看fram 3 能够看出下面信息,以及当前的reg 值:

 

  图3

 

(gdb) info frame 3

 pc = 0xb6ec503c in ifree (external/jemalloc/src/jemalloc.c:1223); saved pc 0xb6e8e7ac
 called by frame at 0xbefd65d8, caller of frame at 0xbefd65d0
 source language c.
 Arglist at 0xbefd6578, args: ptr=0xb2cfee20
 Locals at 0xbefd6578, Previous frame's sp is 0xbefd65d0
 Saved registers:
  r4 at 0xbefd65ac, r5 at 0xbefd65b0, r6 at 0xbefd65b4, r7 at 0xbefd65b8, r8 at 0xbefd65bc, r9 at 0xbefd65c0, r10 at 0xbefd65c4, r11 at 0xbefd65c8, lr at 0xbefd65cc

 

  翻译:

      当前fp 栈帧基地址:Stack frame at 0xbefd65d0,是上一个栈帧的栈顶sp.

      当前执行的指令是pc(0xb6ec503c) in ifree (external/jemalloc/src/jemalloc.c:1223); 保存上一个调用要执行的下一条指令 pc 0xb6e8e7ac,即函数返回点地址,上一个调用过程的PC 的值会赋值给当前调用的LR.

      源文件是.c

      参数列表存储的边界是 0xbefd6578, 参数: ptr=0xb2cfee20

  本地变量存储边界是0xbefd6578, 上一个栈帧的栈顶sp 0xbefd65d0;本栈帧的地址范围就是0xbefd65d0------0xbefd6578 sp 向低地址增加.

保存的上一个调用的调用场景(参照图4,图5):

         r4 存放在0xbefd65ac ......
      r4 at 0xbefd65ac, r5 at 0xbefd65b0, r6 at 0xbefd65b4, r7 at 0xbefd65b8, r8 at 0xbefd65bc, r9 at 0xbefd65c0, r10 at 0xbefd65c4, r11 at 0xbefd65c8, lr at 0xbefd65cc

  fram 3 的栈帧数据透析:

  咱们能够看出ptr=0xb2cfee20 位于地址0xbefd65ac r4 存放的地址,为何会用r4 的值传递参数?

   通常r4~r11 在上层调用中用来存放局部变量的值,须要在返回的时候恢复的,这个值得思考,猜测是优化的结果,可是优化的条件是?

 

  图4

  lr 中保存的过程调用返回点.

 

  图5 fram 3 ,ifree 方法的汇编:

   看ifree+0~~~~ifree+8 汇编代码;sp=sp-4 以后传输lr的值给sp ,sp=sp-4 以后传输lr的值给sp

    连续入栈lr,r4~r11.总共4*9=36=0x20个字节,以后sp = sp - 0x34从大地址到小地址依次存放

    arglist locals;

   总共和sp 到sp 原值的offset是0x54; 看图3正好是0xbefd65d0------0xbefd6578=0x58

   0xb6ec5008 <+0>:    ldmia    r7, {r3, r4, r7}
   0xb6ec500a <+2>:    movs    r2, r0
   0xb6ec500c <+4>:    stmdb    sp!, {r4, r5, r6, r7, r8, r9, r10, r11, lr}
   0xb6ec5010 <+8>:    sub    sp, #52    ; 0x34

 

  图6

 

  图7