弱弱的问个问题。

djking1986

有人能说明下for循环的时候栈是如何变化的吗？如果能用汇编描述一下是最好的了。谢谢

towardWang

我已经可以想象到ebp来回增减的的运行状态了。
davelv 发表于 2010-08-27 12:36

是esp还是ebp？

djking1986

csdn中同一个问题的说法：
http://topic.csdn.net/u/20080318 ... d-37f9e967990b.html

djking1986

有人说一个{}之后就会自动释放局部变量。为什么？

pengjianbokobe

因为他的作用域就是在{}内！！！还不懂就找书看去

@sky

块变量你们都不知道吗

davelv

是esp还是ebp？
towardWang 发表于 2010-08-27 13:16

看了下代码，确认了下，gcc是用esp来操作栈变量的，想当然了，谢谢提醒。

beyond_touch

1. $ cat test.c
   
2. #include <stdio.h>
   
3. 
   
4. int main(int argc, char *argv[]) {
   
5.         int i;
   
6. 
   
7.         for (i = 0; i < 100; i++) {
   
8.                 char buffer[1024];
   
9.         }
   
10. 
    
11.         return 0;
    
12. }
    
13. $ gcc -S -O0 test.c
    
14. $ cat test.s
    
15.         .text
    
16. .globl _main
    
17. _main:
    
18. LFB3:
    
19.         pushq        %rbp
    
20. LCFI0:
    
21.         movq        %rsp, %rbp
    
22. LCFI1:
    
23.         subq        $1072, %rsp
    
24. LCFI2:
    
25.         movl        %edi, -1060(%rbp)
    
26.         movq        %rsi, -1072(%rbp)
    
27.         movq        ___stack_chk_guard@GOTPCREL(%rip), %rax
    
28.         movq        (%rax), %rdx
    
29.         movq        %rdx, -8(%rbp)
    
30.         xorl        %edx, %edx
    
31.         movl        $0, -1044(%rbp)
    
32.         jmp        L2
    
33. L3:
    
34.         incl        -1044(%rbp)
    
35. L2:
    
36.         cmpl        $99, -1044(%rbp)
    
37.         jle        L3
    
38.         movl        $0, %eax
    
39.         movq        ___stack_chk_guard@GOTPCREL(%rip), %rdx
    
40.         movq        -8(%rbp), %rcx
    
41.         xorq        (%rdx), %rcx
    
42.         je        L6
    
43.         call        ___stack_chk_fail
    
44. L6:
    
45.         leave
    
46.         ret
    
47. LFE3:
    
48.         .section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
    
49. EH_frame1:
    
50.         .set L$set$0,LECIE1-LSCIE1
    
51.         .long L$set$0
    
52. LSCIE1:
    
53.         .long        0x0
    
54.         .byte        0x1
    
55.         .ascii "zR\0"
    
56.         .byte        0x1
    
57.         .byte        0x78
    
58.         .byte        0x10
    
59.         .byte        0x1
    
60.         .byte        0x10
    
61.         .byte        0xc
    
62.         .byte        0x7
    
63.         .byte        0x8
    
64.         .byte        0x90
    
65.         .byte        0x1
    
66.         .align 3
    
67. LECIE1:
    
68. .globl _main.eh
    
69. _main.eh:
    
70. LSFDE1:
    
71.         .set L$set$1,LEFDE1-LASFDE1
    
72.         .long L$set$1
    
73. LASFDE1:
    
74.         .long        LASFDE1-EH_frame1
    
75.         .quad        LFB3-.
    
76.         .set L$set$2,LFE3-LFB3
    
77.         .quad L$set$2
    
78.         .byte        0x0
    
79.         .byte        0x4
    
80.         .set L$set$3,LCFI0-LFB3
    
81.         .long L$set$3
    
82.         .byte        0xe
    
83.         .byte        0x10
    
84.         .byte        0x86
    
85.         .byte        0x2
    
86.         .byte        0x4
    
87.         .set L$set$4,LCFI1-LCFI0
    
88.         .long L$set$4
    
89.         .byte        0xd
    
90.         .byte        0x6
    
91.         .align 3
    
92. LEFDE1:
    
93.         .subsections_via_symbols
    

复制代码

chinesedragon

确实会分票100次1024的

davelv

我在gcc 4.4.4下测试发现，gcc默认就把这种行为优化了。它取函数体内最大的块变量，加上函数体内的“全局变量”作为栈空间的长度。
例如如下代码
void test()
{
        int i;
        for(i=0; i>100; i++)
        {
                char  buf[1024];
                //do something
        }
        for(i=0; i>100; i++)
        {
                char buf[2096];
                //dong something;
        }
}
在给函数开辟栈空间的时候，编译器会把最长的块变量，就那个2096个元素的buf变量，加上int i，4个字节的长度，总共为2100字节为栈空间大小，然后用esp寄存器去操作这些变量。
可能不同版本优化不同，但我看楼上帖64位的汇编码也是这样子处理的，不过它多了栈检查的功能，而我x86的汇编码内没有检查栈，其他基本相似。