汇编 - 如何找到一个函数为自己分配了多少堆栈空间答案

【问题标题】：Assembly - How To Find How Much Stack Space A Function Allocates For Itself汇编 - 如何找到一个函数为自己分配了多少堆栈空间
【发布时间】：2015-04-28 08:07:41
【问题描述】：

我现在正在使用 GDB 调试器。问题：在反汇编文件中，找到main的定义。这个函数为自己分配了多少堆栈空间（十进制数）？

函数如下：

08048460 <main>:
8048460:       55                      push   %ebp
8048461:       89 e5                   mov    %esp,%ebp
8048463:       83 e4 f0                and    $0xfffffff0,%esp
8048466:       83 ec 40                sub    $0x40,%esp
8048469:       b8 db 0f 49 40          mov    $0x40490fdb,%eax
804846e:       89 44 24 08             mov    %eax,0x8(%esp)
8048472:       b8 ec 78 ad e0          mov    $0xe0ad78ec,%eax
8048477:       89 44 24 04             mov    %eax,0x4(%esp)
804847b:       b8 ec 78 ad 60          mov    $0x60ad78ec,%eax
8048480:       89 04 24                mov    %eax,(%esp)
8048483:       e8 bc ff ff ff          call   8048444 <fn1>
8048488:       d9 5c 24 3c             fstps  0x3c(%esp)
804848c:       b8 db 0f 49 40          mov    $0x40490fdb,%eax
8048491:       89 44 24 08             mov    %eax,0x8(%esp)
8048495:       b8 ec 78 ad e0          mov    $0xe0ad78ec,%eax
804849a:       89 44 24 04             mov    %eax,0x4(%esp)
804849e:       b8 ec 78 ad 60          mov    $0x60ad78ec,%eax
80484a3:       89 04 24                mov    %eax,(%esp)
80484a6:       e8 a7 ff ff ff          call   8048452 <fn2>
80484ab:       d9 5c 24 38             fstps  0x38(%esp)
80484af:       c7 04 24 e0 85 04 08    movl   $0x80485e0,(%esp)
80484b6:       e8 c5 fe ff ff          call   8048380 <puts@plt>
80484bb:       d9 44 24 3c             flds   0x3c(%esp)
80484bf:       d8 64 24 38             fsubs  0x38(%esp)
80484c3:       dd 1c 24                fstpl  (%esp)
80484c6:       e8 95 fe ff ff          call   8048360 <abs@plt>
80484cb:       89 44 24 2c             mov    %eax,0x2c(%esp)
80484cf:       db 44 24 2c             fildl  0x2c(%esp)
80484d3:       dd 05 20 86 04 08       fldl   0x8048620
80484d9:       d9 c9                   fxch   %st(1)
80484db:       da e9                   fucompp
80484dd:       df e0                   fnstsw %ax
80484df:       9e                      sahf
80484e0:       0f 97 c0                seta   %al
80484e3:       84 c0                   test   %al,%al
80484e5:       74 21                   je     8048508 <main+0xa8>
80484e7:       d9 44 24 38             flds   0x38(%esp)
80484eb:       d9 44 24 3c             flds   0x3c(%esp)
80484ef:       d9 c9                   fxch   %st(1)
80484f1:       b8 e8 85 04 08          mov    $0x80485e8,%eax
80484f6:       dd 5c 24 0c             fstpl  0xc(%esp)
80484fa:       dd 5c 24 04             fstpl  0x4(%esp)
80484fe:       89 04 24                mov    %eax,(%esp)
8048501:       e8 6a fe ff ff          call   8048370 <printf@plt>
8048506:       eb 0c                   jmp    8048514 <main+0xb4>
8048508:       c7 04 24 08 86 04 08    movl   $0x8048608,(%esp)
804850f:       e8 6c fe ff ff          call   8048380 <puts@plt>
8048514:       b8 00 00 00 00          mov    $0x0,%eax
8048519:       c9                      leave
804851a:       c3                      ret
804851b:       90                      nop
804851c:       90                      nop
804851d:       90                      nop
804851e:       90                      nop
804851f:       90                      nop

我不明白如何确定这一点。问题是询问函数在调用之前或在调用过程中为自己分配了多少堆栈空间？是问这个函数占用了多少字节或栈中的多少寄存器？

我是组装新手，所以我应该使用某种技术来回答这个问题吗？

【问题讨论】：

这个问题的答案对您正在查看的功能序言有很好的解释。 stackoverflow.com/questions/15655553/…

标签： c assembly gdb stack

【解决方案1】：

这一行：

8048466:       83 ec 40                sub    $0x40,%esp

告诉你分配的空间是 0x40 (64) 字节。

【讨论】：

我阅读了在线资源 thar sub %esp, x 其中 x 是一个数字，在堆栈上保留空间。那么这是同一件事吗？
那种。堆栈帧用 push %ebp; 初始化。移动 %esp,%ebp;以下指令通常是保留空间的指令。这可能取决于编译标志和其他因素，这不是一个固定的规则。另请注意，这是“AT&T 语法”，它的参数颠倒了，左边从右边减去。
在重新阅读您上面的评论后，我认为 AT&T 语法让您感到困惑。尝试set disassembly-flavor intel 以查看指令为sub esp,N。

【解决方案2】：

首先有一个 push ebp，然后将 esp 向下舍入到 16 字节边界，然后从 esp 中减去 0x40。如果使用 _alloca() 之类的东西从堆栈中动态分配空间，这可能会变得更加复杂。

【讨论】：

只是好奇，所以程序看到了所有正在使用的变量，并且知道在对变量进行任何操作之前要在堆栈上分配多少空间？
是的，没错。一些编译器可能会在运行时分配空间，例如如果您在函数中打开一个块并在其中声明变量，如下所示：main() { int i; ... { int j; ... } ... } 一些编译器，甚至是具有不同选项的同一个编译器，将在开始时保留所有空间，而其他的则保留。