7

as a beginner of asm, I am checking gcc -S generated asm code to learn.

why gcc 4.x default reserve 8 bytes for stack when calling a method?

func18 is the empty function with no return no param no local var defined. I can't figure out why 8 bytes is reserved here (neither any forum/site mention for the reason, ppl seems take it for granted) is it for the %ebp just push? or return type?! many thx!

      .globl _func18
  _func18:
     pushl   %ebp 
     movl    %esp, %ebp 
     subl    $8, %esp 
     .text
Tim Post
  • 33,371
  • 15
  • 110
  • 174
nikcname
  • 103
  • 1
  • 5
  • Actually, none of those instructions make sense... a function without any local variables shouldn't need to set up a frame pointer – Martin Mar 08 '10 at 03:26
  • It probably depends on the optimization level. Can you include the complete generated code for the function? – Richard Pennington Mar 08 '10 at 03:28
  • 2
    Isn't this space for the return address and stack frame pointer? – jdizzle Mar 08 '10 at 03:49
  • thx martin & richard, richard@ I just did with -Os, yes, you are right, now then the subl $8, %esp line is gone. but I still wonder the reason why it does so. I am attaching the code in the reply – nikcname Mar 08 '10 at 03:51
  • jdizzle@ that's what I wonder, but no way to confirm... – nikcname Mar 08 '10 at 03:52
  • The return address is already saved when the function is entered. the frame pointer is saved by the pushl. The 8 bytes might be reserved (in unoptimized code) for parameters to called functions. – Richard Pennington Mar 08 '10 at 03:58
  • @Richard Pennington: Reserved, or _padded_ ? – Tim Post Mar 08 '10 at 04:02
  • @Tim Post: Good question. But if the compiler were trying to align the stack it wouldn't go away with higher optimization levels. – Richard Pennington Mar 08 '10 at 04:05
  • 2
    Martin: A frame pointer is still useful in a function without locals, so that a debugger can access the function's parameters as a constant offset from `%ebp`. – caf Mar 08 '10 at 06:14

3 Answers3

7

Some instructions require certain data types to be aligned to as much as a 16-byte boundary (in particular, the SSE data type __m128). To meet this requirement, gcc ensures that the stack is initially 16-byte aligned, and allocates stack space in multiples of 16 bytes. If only a 4-byte return address and 4-byte frame pointer need to be pushed, 8 additional bytes are needed to keep the stack aligned to a 16-byte boundary. However, if gcc determines that the additional alignment is unnecessary (i.e. the fancy data types are not used and no external functions are called), then it may omit any additional instructions used to align the stack. The analysis necessary to determine this may require certain optimization passes to be performed.

See also the gcc documentation for the option -mpreferred-stack-boundary=num.

mark4o
  • 58,919
  • 18
  • 87
  • 102
  • thx mark, so it's all for data alignement when optimizing with sse, very sensible as I disable the optimization and the subl $8 %esp is gone. the gcc ref is very useful!!! just 1 thing, while I adj the -mpreferred-stack-boundary, the reservation only chg between 3 and 4, from 4 to 12, it sticks with 8 bytes, I thought the reservation should then be 20 bytes, no? – nikcname Mar 08 '10 at 06:59
  • If you used -mpreferred-stack-boundary=12, then in any function that calls external functions it will allocate stack space in multiples of 2^12=4096 bytes. If you are not calling any external functions then it will often be able to figure out that maintaining that alignment isn't needed for the code it is generating (depends on your exact gcc version, options, and target architecture). – mark4o Mar 08 '10 at 07:34
  • so you mean in the case func without calling external func, gcc just stick with 8 bytes whatsoever as default? – nikcname Mar 08 '10 at 10:40
  • @nikcname: I don't see that on gcc 4.4.1 (Ubuntu 9.10) with an empty function. What version and compile options are you using? – mark4o Mar 08 '10 at 15:17
0

As richard mentioned above, it's all because of optimization, showing below. but still I got no idea why 8 bytes reserved is something optimized?!

original c

void func18() {}
int main() {return 0;}

compile without optimization flag specified

    .text                                                                                   
.globl _func18
_func18:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $8, %esp
    leave
    ret
.globl _main
_main:                                                                                      
    pushl   %ebp
    movl    %esp, %ebp
    subl    $8, %esp
    movl    $0, %eax
    leave
    ret
    .subsections_via_symbols

with -Os optimization flag, no more stack reserve

    .text
.globl _func18
_func18:
    pushl   %ebp
    movl    %esp, %ebp
    leave
    ret
.globl _main
_main:
    pushl   %ebp
    xorl    %eax, %eax
    movl    %esp, %ebp
    leave
    ret
    .subsections_via_symbols
nikcname
  • 103
  • 1
  • 5
0

Easy way to find out: Have you empty function call another function with one parameter. If the parameter is stored directly to the stack (no push), then that's what the extra space is for.

Richard Pennington
  • 19,673
  • 4
  • 43
  • 72