5

clang我使用and编译了以下代码，gcc并使用-O3：

#include <stdio.h>
#include <stdlib.h>

static void a(int n) {
  if (n == 0) return;

  printf("descending; a=%i\n", n);
  a(n-1);
}

int main() {
  a(5);
  return 0;
}

这是生成的主要函数gcc（最后没有 NOP）：

08048310 <main>:
 8048310:   55                      push   %ebp
 8048311:   89 e5                   mov    %esp,%ebp
 8048313:   83 e4 f0                and    $0xfffffff0,%esp
 8048316:   83 ec 10                sub    $0x10,%esp
 8048319:   c7 44 24 04 05 00 00    movl   $0x5,0x4(%esp)
 8048320:   00 
 8048321:   c7 04 24 14 85 04 08    movl   $0x8048514,(%esp)
 8048328:   e8 c7 ff ff ff          call   80482f4 <printf@plt>
 804832d:   c7 44 24 04 04 00 00    movl   $0x4,0x4(%esp)
 8048334:   00 
 8048335:   c7 04 24 14 85 04 08    movl   $0x8048514,(%esp)
 804833c:   e8 b3 ff ff ff          call   80482f4 <printf@plt>
 8048341:   c7 44 24 04 03 00 00    movl   $0x3,0x4(%esp)
 8048348:   00 
 8048349:   c7 04 24 14 85 04 08    movl   $0x8048514,(%esp)
 8048350:   e8 9f ff ff ff          call   80482f4 <printf@plt>
 8048355:   c7 44 24 04 02 00 00    movl   $0x2,0x4(%esp)
 804835c:   00 
 804835d:   c7 04 24 14 85 04 08    movl   $0x8048514,(%esp)
 8048364:   e8 8b ff ff ff          call   80482f4 <printf@plt>
 8048369:   c7 44 24 04 01 00 00    movl   $0x1,0x4(%esp)
 8048370:   00 
 8048371:   c7 04 24 14 85 04 08    movl   $0x8048514,(%esp)
 8048378:   e8 77 ff ff ff          call   80482f4 <printf@plt>
 804837d:   31 c0                   xor    %eax,%eax
 804837f:   c9                      leave  
 8048380:   c3                      ret

这是来自clang：

080483d0 <main>:
 80483d0:   55                      push   %ebp
 80483d1:   89 e5                   mov    %esp,%ebp
 80483d3:   56                      push   %esi
 80483d4:   83 ec 0c                sub    $0xc,%esp
 80483d7:   be 05 00 00 00          mov    $0x5,%esi
 80483dc:   8d 74 26 00             lea    0x0(%esi,%eiz,1),%esi
 80483e0:   89 74 24 04             mov    %esi,0x4(%esp)
 80483e4:   c7 04 24 e0 84 04 08    movl   $0x80484e0,(%esp)
 80483eb:   e8 04 ff ff ff          call   80482f4 <printf@plt>
 80483f0:   4e                      dec    %esi
 80483f1:   75 ed                   jne    80483e0 <main+0x10>
 80483f3:   31 c0                   xor    %eax,%eax
 80483f5:   83 c4 0c                add    $0xc,%esp
 80483f8:   5e                      pop    %esi
 80483f9:   5d                      pop    %ebp
 80483fa:   c3                      ret

我的问题是：他们都生成代码，一遍又一遍地在堆栈上写入静态字符串的地址，是否有充分的理由？例如，为什么clang生成的代码看起来不像这样？

080483d0 <main>:
 80483d0:   55                      push   %ebp
 80483d1:   89 e5                   mov    %esp,%ebp
 80483d3:   56                      push   %esi
 80483d4:   83 ec 0c                sub    $0xc,%esp
 80483d7:   be 05 00 00 00          mov    $0x5,%esi
 80483dc:   8d 74 26 00             lea    0x0(%esi,%eiz,1),%esi
 80483e0:   c7 04 24 e0 84 04 08    movl   $0x80484e0,(%esp)
 80483e7:   89 74 24 04             mov    %esi,0x4(%esp)
 80483eb:   e8 04 ff ff ff          call   80482f4 <printf@plt>
 80483f0:   4e                      dec    %esi
 80483f1:   xx xx                   jne    80483e7 <main+0x17>
 80483f3:   31 c0                   xor    %eax,%eax
 80483f5:   83 c4 0c                add    $0xc,%esp
 80483f8:   5e                      pop    %esi
 80483f9:   5d                      pop    %ebp
 80483fa:   c3                      ret
4

3 回答 3

2

主要原因是ABI如何定义“堆栈框架”的所有权。简而言之，只要您调用一个函数，该函数就会获得当前堆栈帧的所有权（包括参数、返回地址和任何局部变量）。

它可以用它做任何事情。无法保证printf()堆栈框架中的任何内容都完好无损。虽然这样做是不好的做法，但函数可以这样做，并且我编写了与堆栈混淆的代码（例如在 C 解释器中，用 C 编写，它可以调用任何编译的函数，尤其是printf().

所以不能保证printf()返回时指向静态字符串的指针还在栈上。请注意，编译器不能假设它printf()会起作用，因为您可以使用自定义实现链接到不同的 C 运行时printf()。

尝试调用 GCC 可以看到源代码的函数。对于这些，它可能会进一步优化堆栈。

[编辑]也许一个不同的例子使这更容易理解。在某些情况下，GCC 会优化函数参数传递。不是将它们压入堆栈，而是将它们传递到 CPU 寄存器中。让我们假设它%eax用于此目的。如果参数归调用函数所有，则不允许被调用函数修改%eax.

于 2012-08-15T13:59:41.823 回答
2

在 Mac OS X 应用程序二进制接口中，堆栈上传递的参数可能会被调用的例程修改。因此，在调用例程将格式字符串的地址放入堆栈的地方，被调用例程被允许写入堆栈上的那个位置。（一般不允许写入堆栈上更高[较早]的​​位置。）因此，调用例程无法知道，在被调用例程返回后，调用例程写入堆栈的参数没有改变。

这对于在使用它们执行计算时可能会修改其参数的例程来说是一种便利。例如，您可以有如下代码：

int foo(int x)
{
    x *= x;
    return x+3;
}

显然，对于这么简单的代码，编译器实际上不需要将乘积存储在 x 中以完成计算返回值。但是，对于更复杂的例程，您可以看到编译器可能决定将值存储到 x 的位置。

作为一个 ABI 设计问题，您可能想知道是否最好禁止被调用例程使用此空间，以便调用者可以依赖不变的值。但是，以这种方式重复使用参数并不常见，而且编写新副本的成本很小。

另请注意，只有写入堆栈的格式字符串的地址可以更改。C 语义要求格式字符串的内容在被调用的例程中保持不变，因为它是 const char。

于 2012-08-15T14:05:15.807 回答
-1

简短的问题是函数调用。C 编译器不能真正保证函数调用中发生的事情（除非它是 C 内置函数之一，例如strlen）。因此，它不必围绕它们进行优化。考虑：

pthread_mutex_lock(&mutex);
val = 5;
pthread_mutex_unlock(&mutex);

如果编译器推断对 val 的写入独立于对 的调用pthread_mutex_lock，那么它可以在锁定之前将其推送，然后就会出现大量混乱。

编译器必须假定必须完成函数调用之前的最后一次写入。如果写入发生在它确切知道发生了什么的代码块中（即，没有函数调用或只有内置函数），那么它可以随意优化并拉出不需要的写入。

编译器无法推断函数是否可以访问变量（至少在没有解决停止问题的情况下不能）。另一个函数可能在之前设置了地址，或者使用类似dlsym的东西来找出它自己的二进制文件的地址，即使那个符号没有被导出。

于 2012-08-15T14:03:59.300 回答