假设有一个递归函数foo()，类似于斐波那契数列：

constexpr inline int foo(const int i)
{
    if(i == 0) 
        return 1;
    return foo(i - 1) + foo(i - 2);
}

int main(int argc, const char* argv[])
{
    const int ret = foo(argc);
    return ret;
}

然后在https://gcc.godbolt.org/z/fETb6Px33to上使用GCC在-Os -std=c++2b -fno-exceptions等不同的优化级别下编译，我想知道为什么O2/O3版本看起来比O1/Os版本大，就像怪兽哥斯拉一样。显然，一些关键的优化触发了二进制大小的膨胀，也许O3试图以大小为代价提高运行时的执行速度。
O0

foo(int):
        push    rbp
        mov     rbp, rsp
        push    rbx
        sub     rsp, 24
        mov     DWORD PTR [rbp-20], edi
        cmp     DWORD PTR [rbp-20], 0
        jne     .L2
        mov     eax, 1
        jmp     .L3
.L2:
        mov     eax, DWORD PTR [rbp-20]
        sub     eax, 1
        mov     edi, eax
        call    foo(int)
        mov     ebx, eax
        mov     eax, DWORD PTR [rbp-20]
        sub     eax, 2
        mov     edi, eax
        call    foo(int)
        add     eax, ebx
.L3:
        mov     rbx, QWORD PTR [rbp-8]
        leave
        ret
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        mov     DWORD PTR [rbp-20], edi
        mov     QWORD PTR [rbp-32], rsi
        mov     eax, DWORD PTR [rbp-20]
        mov     edi, eax
        call    foo(int)
        mov     DWORD PTR [rbp-4], eax
        mov     eax, DWORD PTR [rbp-4]
        leave
        ret

O3

foo(int):
        test    edi, edi
        je      .L44
        push    r15
        push    r14
        xor     r14d, r14d
        push    r13
        push    r12
        lea     r12d, [rdi-1]
        push    rbp
        mov     ebp, r12d
        push    rbx
        sub     rsp, 56
.L7:
        test    ebp, ebp
        je      .L45
.L3:
        lea     r13d, [rbp-1]
        xor     ebx, ebx
        mov     eax, r14d
        mov     r15d, ebp
.L10:

        lea     ebx, [r15-1]
 .... // much much more to follow

Os

foo(int):
        push    rbp
        xor     ebp, ebp
        push    rbx
        mov     ebx, edi
        push    rcx
.L3:
        test    ebx, ebx
        je      .L5
        lea     edi, [rbx-1]
        sub     ebx, 2
        call    foo(int)
        add     ebp, eax
        jmp     .L3
.L5:
        lea     eax, [rbp+1]
        pop     rdx
        pop     rbx
        pop     rbp
        ret
main:
        jmp     foo(int)