sparc v8 stack frame calling convention

main.c

int enable=;

int main()
{
    int a, b;
    int sum;

    a = ;
    b = ;

    sum = add(a, b);

    return ;
}

int add(int a, int b)
{
    int x, y;
    x = a;
    y = b;
    return (x+y);
}

int del()
{
    return ;
}

汇编如下：

main.elf:     file format elf32-sparc

Disassembly of section .text:

 <main>:
:    9d e3 bf      save  %sp, -, %sp
:            mov  , %o0
:    d0  bf f4     st  %o0, [ %fp + - ]
7000000c:            mov  , %o0
:    d0  bf f0     st  %o0, [ %fp + - ]
:    d0  bf f4     ld  [ %fp + - ], %o0
:    d2  bf f0     ld  [ %fp + - ], %o1
7000001c:            call  7000003c <add>
:            nop
:    d0  bf ec     st  %o0, [ %fp + - ]
:            clr  %o0
7000002c:    b0        mov  %o0, %i0
:            nop
:     c7 e0      ret
:     e8       restore 

7000003c <add>:
7000003c:    9d e3 bf      save  %sp, -, %sp
:    f0  a0      st  %i0, [ %fp + 0x44 ]
:    f2  a0      st  %i1, [ %fp + 0x48 ]
:    f0  a0      ld  [ %fp + 0x44 ], %i0
7000004c:    f0  bf f4     st  %i0, [ %fp + - ]
:    f0  a0      ld  [ %fp + 0x48 ], %i0
:    f0  bf f0     st  %i0, [ %fp + - ]
:    f2  bf f4     ld  [ %fp + - ], %i1
7000005c:    f0  bf f0     ld  [ %fp + - ], %i0
:    b0        add  %i1, %i0, %i0
:            nop
:     c7 e0      ret
7000006c:     e8       restore 

 <del>:
:    9d e3 bf      save  %sp, -, %sp
:    b0        clr  %i0
:            nop
7000007c:     c7 e0      ret
:     e8       restore
Disassembly of section .data:

 <enable>:
:            unimp  0x1

混合源程序的反汇编如下：局部变量的定义不会增加程序指令。

main.elf:     file format elf32-sparc

Disassembly of section .text:

 <main>:
int enable=;

int main()
{
:    9d e3 bf      save  %sp, -, %sp
    int a, b;
    int sum;

    a = ;
:            mov  , %o0
:    d0  bf f4     st  %o0, [ %fp + - ]
    b = ;
7000000c:            mov  , %o0
:    d0  bf f0     st  %o0, [ %fp + - ]

    sum = add(a, b);
:    d0  bf f4     ld  [ %fp + - ], %o0
:    d2  bf f0     ld  [ %fp + - ], %o1
7000001c:            call  7000003c <add>
:            nop
:    d0  bf ec     st  %o0, [ %fp + - ]

    return ;
:            clr  %o0
}
7000002c:    b0        mov  %o0, %i0
:            nop
:     c7 e0      ret
:     e8       restore 

7000003c <add>:

int add(int a, int b)
{
7000003c:    9d e3 bf      save  %sp, -, %sp
:    f0  a0      st  %i0, [ %fp + 0x44 ]
:    f2  a0      st  %i1, [ %fp + 0x48 ]
    int x, y;
    x = a;
:    f0  a0      ld  [ %fp + 0x44 ], %i0
7000004c:    f0  bf f4     st  %i0, [ %fp + - ]
    y = b;
:    f0  a0      ld  [ %fp + 0x48 ], %i0
:    f0  bf f0     st  %i0, [ %fp + - ]
    return (x+y);
:    f2  bf f4     ld  [ %fp + - ], %i1
7000005c:    f0  bf f0     ld  [ %fp + - ], %i0
:    b0        add  %i1, %i0, %i0
}
:            nop
:     c7 e0      ret
7000006c:     e8       restore 

 <del>:

int del()
{
:    9d e3 bf      save  %sp, -, %sp
    return ;
:    b0        clr  %i0
}
:            nop
7000007c:     c7 e0      ret
:     e8       restore 

1、3个局部变量，共12字节，按照8字节对齐，需要16字节，即104+16=120

: 9d e3 bf  save  %sp, -, %sp

2、main.c将局部变量a，b分配在%fp + -12，%fp + -16

:            mov  , %o0
:    d0  bf f4     st  %o0, [ %fp + - ]
7000000c:            mov  , %o0
:    d0  bf f0     st  %o0, [ %fp + - ]

3、将输入参数放在o0和o1中，然后调用add

:    d0  bf f4     ld  [ %fp + - ], %o0
:    d2  bf f0     ld  [ %fp + - ], %o1
7000001c:            call  7000003c <add>

4、将局部变量sum，放在%fp + -20，调用结束，从o0取得add的返回值。

:    d0  bf ec     st  %o0, [ %fp + - ]

5、add现将i0和i1放在%fp + 0x44，%fp + 0x48，这是为什么？0x44=68, 0x48=72

:    f0  a0      st  %i0, [ %fp + 0x44 ]
:    f2  a0      st  %i1, [ %fp + 0x48 ]

6、然后，赋值局部变量

:    f0  a0      ld  [ %fp + 0x44 ], %i0
7000004c:    f0  bf f4     st  %i0, [ %fp + - ]
:    f0  a0      ld  [ %fp + 0x48 ], %i0
:    f0  bf f0     st  %i0, [ %fp + - ]

add函数里的%fp + 0x44感觉又到了main的堆栈里了，这是怎么回事？见下面分析。

The caller’s stack pointer %sp (%o6) automatically becomes the current procedure’s frame pointer %fp (%i6) when the SAVE instruction is executed.

SAVE同时也具有ADD的效果。

3803手册中，%fp + 0x44位置处写着，用于存储被调函数的寄存器变量，也就是add函数。在调用函数的堆栈中，为什么要存储被调函数的东西呢？见下面分析

System V Application Binary Interface - SPARC Processor Supplement -3dt，p24描述如下：

Although the first 6 words of arguments reside in registers, the standard stack frame reserves space
for them. ‘‘Coding Examples’’ below explains how these words may be used to implement variable
argument lists. Arguments beyond the sixth reside on the stack.

虽然前6个参数放在寄存器中，但是标准的栈帧也给它们预留了空间。

下面图来自abi_sparc，p24。

其中previous帧中说six words into which function may write incoming arguments 0 to 5，这是里may可能，调用函数可能将前6个输入参数既放入i0~i5，又放在这里。

current帧中说six words into which callee may write outgoing arguments 0 to 5，这是里may可能，被调函数可能将前6个输出参数既放入i0~i5，又放在这里。

但从实际sparc-elf-gcc的使用来看，被调函数做了调用函数的工作，即被调函数将输入参数i0~i5放在了调用函数栈帧的该位置处。

reference：

SYSTEM V APPLICATION BINARY INTERFACE, SPARC Processor Supplement, Third Edition

链接：https://pan.baidu.com/s/1lRCz7Z0nol-8gOzed3Rmyw
提取码：0kjr

BM3803MGRH用户手册

链接：https://pan.baidu.com/s/1T3sNflIAdCUGGcON3-tWpQ
提取码：xkty
复制这段内容后打开百度网盘手机App，操作更方便哦