【问题标题】:How do I check if gcc is performing tail-recursion optimization?如何检查 gcc 是否正在执行尾递归优化?
【发布时间】:2010-10-04 04:04:20
【问题描述】:

我如何判断 gcc(更具体地说,g++)是否正在优化特定函数中的尾递归? (因为它出现过几次:我不想测试 gcc 一般是否可以优化尾递归。我想知道它是否优化了 my 尾递归函数。)

如果您的答案是“查看生成的汇编程序”,我想确切地知道我在寻找什么,以及是否可以编写一个简单的程序来检查汇编程序以查看是否有优化。

PS。我知道这出现在 5 个月前的问题 Which, if any, C++ compilers do tail-recursion optimization? 中。但是,我认为该问题的这部分没有得到令人满意的回答。 (答案是“检查编译器是否进行了优化(据我所知)的最简单方法是执行一个调用,否则会导致堆栈溢出 - 或查看程序集输出。”)

【问题讨论】:

标签: gcc g++ tail-recursion


【解决方案1】:

让我们使用the example code from the other question。编译它,但告诉 gcc 不要汇编:

gcc -std=c99 -S -O2 test.c

现在让我们看看生成的 test.s 文件(Mac OS 10.5 上的 gcc 4.0.1)中的 _atoi 函数:

        .text
        .align 4,0x90
_atoi:
        pushl   %ebp
        testl   %eax, %eax
        movl    %esp, %ebp
        movl    %eax, %ecx
        je      L3
        .align 4,0x90
L5:
        movzbl  (%ecx), %eax
        testb   %al, %al
        je      L3
        leal    (%edx,%edx,4), %edx
        movsbl  %al,%eax
        incl    %ecx
        leal    -48(%eax,%edx,2), %edx
        jne     L5
        .align 4,0x90
L3:
        leave
        movl    %edx, %eax
        ret

编译器对此函数进行了尾调用优化。我们可以判断,因为该代码中没有 call 指令,而原始 C 代码显然有一个函数调用。此外,我们可以看到jne L5指令,它在函数中向后跳转,当C代码中明显没有循环时表示循环。如果你在关闭优化的情况下重新编译,你会看到一行写着call _atoi,你也不会看到任何向后跳转。

您是否可以将其自动化是另一回事。汇编代码的细节将取决于您正在编译的代码。

我认为,您可以通过编程方式发现它。使函数打印出堆栈指针的当前值(在 x86 上注册 ESP)。如果函数在第一次调用时打印与递归调用相同的值,则编译器执行了尾调用优化。但是,这个想法需要修改您希望观察的函数,这可能会影响编译器选择优化函数的方式。如果测试成功(两次打印相同的 ESP 值),那么我认为可以合理地假设优化也将在没有您的仪器的情况下执行,但如果测试失败,我们将不知道失败是否是由于添加检测代码。

【讨论】:

    【解决方案2】:

    编辑 我原来的帖子还阻止了 GCC 实际进行尾调用消除。我在下面添加了一些额外的技巧,让 GCC 无论如何都要进行尾调用消除。

    扩展 Steven 的回答,您可以通过编程方式检查您是否有相同的堆栈帧:

    #include <stdio.h>
    
    // We need to get a reference to the stack without spooking GCC into turning
    // off tail-call elimination
    int oracle2(void) { 
        char oracle; int oracle2 = (int)&oracle; return oracle2; 
    }
    
    void myCoolFunction(params, ..., int tailRecursionCheck) {
        int oracle = oracle2();
        if( tailRecursionCheck && tailRecursionCheck != oracle ) {
            printf("GCC did not optimize this call.\n");
        }
        // ... more code ...
        // The return is significant... GCC won't eliminate the call otherwise
        return myCoolFunction( ..., oracle);
    }
    
    int main(int argc, char *argv[]) {
        myCoolFunction(..., 0);
        return 0;
    }
    

    非递归调用函数时,传入0检查参数。否则传入oracle。如果本应消除的尾递归调用没有出现,则会在运行时通知您。

    在对此进行测试时,我的 GCC 版本似乎没有优化第一个尾调用,但优化了剩余的尾调用。很有趣。

    【讨论】:

    • +1 聪明,不必使用 GCC 内部函数
    • 可爱。这也对我有用,尽管它确实涉及修改代码。顺便说一句,我的函数也是 void 并且执行“call_myself(); return;”而不是“返回 call_myself();”。据我所知,gcc 现在正在优化两者,但不是几年前。
    • 嗯。在这里,我在想没有任何可移植的方式来查看您自己的堆栈......当然(有点)是。 +1
    • 很好的答案。最好使用void* 而不是int,因为后者不能保证足够大以存储指针。
    • 不保证有效。特别是,这不适用于 Ubuntu、14.04、x64 上的 g++-4.9.2。
    【解决方案3】:

    查看生成的汇编代码,看它是否使用call 或jmp 指令在x86 上进行递归调用(对于其他架构,请查找相应的指令)。您可以使用nm 和objdump 来获取与您的函数相对应的程序集。考虑以下函数:

    int fact(int n)
    {
      return n <= 1 ? 1 : n * fact(n-1);
    }
    

    编译为

    gcc fact.c -c -o fact.o -O2
    

    然后,测试它是否使用尾递归:

    # get starting address and size of function fact from nm
    ADDR=$(nm --print-size --radix=d fact.o | grep ' fact$' | cut -d ' ' -f 1,2)
    # strip leading 0's to avoid being interpreted by objdump as octal addresses
    STARTADDR=$(echo $ADDR | cut -d ' ' -f 1 | sed 's/^0*\(.\)/\1/')
    SIZE=$(echo $ADDR | cut -d ' ' -f 2 | sed 's/^0*//')
    STOPADDR=$(( $STARTADDR + $SIZE ))
    
    # now disassemble the function and look for an instruction of the form
    # call addr <fact+offset>
    if objdump --disassemble fact.o --start-address=$STARTADDR --stop-address=$STOPADDR | \
        grep -qE 'call +[0-9a-f]+ <fact\+'
    then
        echo "fact is NOT tail recursive"
    else
        echo "fact is tail recursive"
    fi
    

    当在上述函数上运行时,此脚本会打印“fact is tail recursive”。当使用-O3 而不是-O2 编译时,这会奇怪地打印出“fact is NOT tail recursive”。

    请注意,正如 ehemient 在他的评论中指出的那样,这可能会产生假阴性。如果函数根本不包含对自身的递归调用,并且它也没有检测到兄弟递归(例如,A() 调用 B() 而调用 A()),此脚本只会产生正确的答案。目前我想不出一种更强大的方法,它不涉及人工查看生成的程序集,但至少您可以使用此脚本轻松获取与目标文件中特定函数相对应的程序集。

    【讨论】:

    • 朴素的阶乘和斐波那契函数不是很好的例子。编译器经常使用它们进行愚蠢的基准测试,因此编译器编写者确保添加专门适用于看起来像 fact/fib 的函数的特殊优化。
    • 查看我的回答,了解检测器何时报告尾调用优化函数“非尾递归”的示例。
    • @Adam Rosenfield:你的解决方案对我有用,只是做了一些小的改动。例如,我使用的是 C++,而我的函数是一个成员函数,所以函数名称变成了类似“_ZN5cycle4stepEib”的东西。
    • @Adam Rosenfield:我觉得有趣的是,它使用 -O2 使调用完全尾递归。同时,使用 -O3 它会“展开循环”大约 10 次,然后实际调用自身。
    • 刚发现这个问题,忍不住指出代码本质上甚至不是尾递归,因为函数中的最后一个操作实际上是乘法,不是 对fact 的递归调用。
    【解决方案4】:

    扩展 PolyThinker 的答案,这里有一个具体的例子。

    int foo(int a, int b) {
        if (a && b)
            return foo(a - 1, b - 1);
        return a + b;
    }
    

    i686-pc-linux-gnu-gcc-4.3.2 -Os -fno-optimize-sibling-calls 输出:

    00000000 :
       0: 55 推 %ebp
       1: 89 e5 移动 %esp,%ebp
       3: 8b 55 08 移动 0x8(%ebp),%edx
       6: 8b 45 0c 移动 0xc(%ebp),%eax
       9: 85 d2 测试 %edx,%edx
       b: 74 16 je 23 
       d: 85 c0 测试 %eax,%eax
       f: 74 12 je 23 
      11:51 推送 %ecx
      12:12 月 48 日
      13: 51 推送 %ecx
      14: 50 推%eax
      15: 8d 42 ff lea -0x1(%edx),%eax
      18: 50 推%eax
      19: e8 fc ff ff ff 调用 1a 
      1e: 83 c4 10 添加 $0x10,%esp
      21: eb 02 jmp 25 
      23: 01 d0 添加 %edx,%eax
      25:c9离开
      26:c3 回复
    

    i686-pc-linux-gnu-gcc-4.3.2 -Os 输出:

    00000000 :
       0: 55 推 %ebp
       1: 89 e5 移动 %esp,%ebp
       3: 8b 55 08 移动 0x8(%ebp),%edx
       6: 8b 45 0c 移动 0xc(%ebp),%eax
       9: 85 d2 测试 %edx,%edx
       b: 74 08 je 15 
       d: 85 c0 测试 %eax,%eax
       f: 74 04 je 15 
      11:12 月 48 日
      12: 12 月 4 日 %edx
      13: eb f4 jmp 9 
      15: 5d 弹出 %ebp
      16: 01 d0 添加 %edx,%eax
      18:c3 雷特
    

    在第一种情况下,&lt;foo+0x11&gt;-&lt;foo+0x1d&gt; 推送函数调用的参数,而在第二种情况下,&lt;foo+0x11&gt;-&lt;foo+0x14&gt; 将变量和jmps 修改为同一个函数,位于序言之后的某个位置。这就是您要寻找的。​​p>

    我认为您不能以编程方式执行此操作;有太多可能的变化。函数的“肉”可能离开始更近或更远,不看就无法区分jmp 与循环或条件。它可能是条件跳转而不是jmp。 gcc 可能会在某些情况下保留 call,但在其他情况下应用同级调用优化。

    仅供参考,gcc 的“兄弟调用”比尾递归调用更通用——实际上,任何可以重复使用相同堆栈帧的函数调用都可能是兄弟调用。

    [编辑]

    作为一个例子,当只是寻找一个自递归 call 会误导你,

    int bar(int n) {
        if (n == 0)
            return bar(bar(1));
        if (n % 2)
            return n;
        return bar(n / 2);
    }
    

    GCC 将对三个bar 调用中的两个应用同级调用优化。我仍将其称为尾调用优化,因为单个未优化的调用永远不会超过单个级别,即使您会在生成的程序集中找到 call &lt;bar+..&gt;。

    【讨论】:

    • 谢谢。关于你的例子:我想知道是否有任何编译器有足够的能力将第一个返回优化为“return 1”......似乎它所要做的就是不断地将“bar(1)”折叠成“1”。 (我知道这不是你的例子的重点;我只是想知道。)
    • 如果你用'const'属性标记bar()(见gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html),那么gcc会将bar(bar(1))折叠成1。
    • @Adam Rosenfield:酷。你知道为什么 gcc 不够聪明,无法自己解决这个问题吗?
    【解决方案5】:

    我懒得看反汇编了。试试这个:

    void so(long l)
    {
        ++l;
        so(l);
    }
    int main(int argc, char ** argv)
    {
        so(0);
        return 0;
    }
    

    编译并运行这个程序。如果它永远运行,尾递归就被优化掉了。如果它破坏了堆栈,则不是。

    编辑:抱歉,读得太快了,OP 想知道 他的特定函数 是否优化了尾递归。好的...

    ...原理还是一样的——如果尾递归被优化掉,那么堆栈帧将保持不变。您应该能够使用backtrace function 从您的函数中捕获堆栈帧,并确定它们是否在增长。如果尾递归被优化掉,你将缓冲区中只有一个返回指针。

    【讨论】:

    • OP 想要测试是否正在优化 specific 功能。这个微不足道的例子对此毫无用处,因为这不是他的职责。他的功能(希望)对于大多数/所有输入都终止。
    • 亲爱的路过投票者:这怎么没有帮助?你试过了吗?
    • @[Adam Rosenfield]:OP 的问题没有说明这一点!
    • @[Adam Rosenfield]:哦,等等,我现在看到了“在特定函数中”的斜体字。哦!将编辑...
    • (我没有对此投反对票。)@Adam Rosenfield 是对的;我想在我的代码中测试一个特定的函数,而不是 gcc 是否总体优化。
    【解决方案6】:

    我检查的另一种方法是:

    1. 使用“gcc -O2”编译您的代码
    2. 启动“gdb”
    3. 在您希望进行尾递归优化/消除的函数中放置一个断点
    4. 运行您的代码
    5. 如果已经消除了尾调用,则断点将只被命中一次或永远不会命中。有关更多信息,请参阅this

    【讨论】:

      【解决方案7】:

      一个简单的方法:构建一个简单的尾递归程序,编译,反汇编,看是否优化。

      刚刚意识到您的问题中已经包含了这一点。如果您知道如何阅读汇编,则很容易分辨。递归函数将从函数体内调用自己(使用“调用标签”),并且循环将只是“jmp 标签”。

      【讨论】:

      • 你答案的第一部分根本不是我想要的。对于第二部分,您是说我所做的只是检查该函数是“调用标签”还是“jmp 标签”?
      • x86 上的尾递归优化几乎完全是用跳转替换调用。 call 会生成一个新的堆栈帧,但 jmp 不会。如果反汇编的函数在返回之前没有调用,则已对其进行了优化。
      【解决方案8】:

      如果没有优化,您可以制作会导致堆栈溢出的输入数据,因为该函数调用的递归太深,并查看它是否发生。当然,这不是微不足道的,有时足够大的输入会使函数运行时间过长。

      【讨论】:

        猜你喜欢
        • 1970-01-01
        • 2012-11-15
        • 2011-09-04
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 2010-10-23
        • 2012-04-18
        • 2011-07-16
        相关资源
        最近更新 更多