从汇编的角度看递归

        我们先来看怎样实现阶乘的函数（我的代码是在X64环境下的）

要实现阶乘，我们先设计一下代码：

（1）判断参数是否为1

（2）是，则结果为1。

 ( 3）否则，数字乘以该数字减一。

然后分析下代码是如何工作的。

.section .data
.section .text

.globl _start
.globl factorial

_start:
    pushq $4            #将参数入栈
    call factorial     
    addq $8, %rsp       #恢复rsp
    movq %rax, %rbx     #保存结果到rbx(状态码)

    movq $1, %rax       #exit
    int $0x80

.type factorial, @function
factorial:
    pushq %rbp            
    movq %rsp, %rbp        #标准函数格式，建立函数栈帧
    movq 16(%rbp), %rax    #  取参数
    cmpq $1, %rax          #若为1，跳到end_factorial
    je end_factorial       
    decq %rax              
    pushq %rax             #参数入栈
    call factorial         
    movq 16(%rbp), %rbx      
    imulq %rbx, %rax
    
end_factorial:
    movq %rbp, %rsp    #标准函数格式，恢复原栈帧
    popq %rbp
    ret

让我们一步步来分析：

_start:    pushq $4               call factorial

    可以看到，这个程序用于计算4的阶乘。我们先将参数压到栈中，然后调用函数。这时栈中情况是这样的：

                    4            返回地址

     pushq %rbp                 movq %rsp, %rbp        

      然后，建立函数栈帧。即将原栈帧保存到栈中，然后建立函数栈帧。这时栈中情况是这样的：
      

             4       16(%rbp)           返回地址        8(%rbp)           旧%rbp         %rbp

        movq 16(%rbp), %rax   cmpq $1, %rax        je end_factorial         decq %rax                      pushq %rax        call factorial     

     接着，将参数与1比较，若是则跳到end_factorial；否则，将其减1，然后压入栈中，调用函数factorial，直到参数变为1为止。这时栈中情况是这样的：

             4           返回地址
           旧%rbp           ......            1           返回地址           旧%rbp

movq 16(%rbp), %rbx      imulq %rbx, %raxend_factorial:movq %rbp, %rsp    popq %rbpret

        这时，参数值和%rax的值肯定为1了，然后将1×1，保存到%rax。接着循环执行这段代码，直到所有的返回地址都被ret给popq。当然在此过程中，最终结果也保存在了%rax中。

addq $8, %rsp       movq %rax, %rbx     movq $1, %rax      int $0x80

        最后，我们恢复栈顶指针，并将结果保存到存放状态码的%rbx中，最后调用exit(1)结束程序。

       我们可以看到，在函数的递归过程中，栈的内存一直在被占用，而且越积越多，这也可以解释，为什么递归掉哟过会那么占内存了。而且我这里参数少，更是没有定义变量。