Explain the strange assembly of empty C `main` function by Visual C++ compiler.

Question

Hello,

I just noticed some strange assembly language code of empty main method.

//filename: main.c
void main()
{

}

disassembly:

push        ebp  
mov         ebp,esp  
sub         esp,0C0h; why on the earth is it reserving 192 bytes?  
push        ebx  
push        esi  
push        edi  ; good compiler. Its saving ebx, esi & edi values.
lea         edi,[ebp-0C0h]  ; line 1
mov         ecx,30h  ; line 2
mov         eax,0CCCCCCCCh  ; line 3
rep stos    dword ptr es:[edi]  ; line 4


xor         eax,eax  ; returning value 0. Code following this line is explanatory.
pop         edi  ; restoring the original states of edi,esi & ebx
pop         esi  
pop         ebx  
mov         esp,ebp  
pop         ebp  
ret   

1. why on the earth is it reserving 192 bytes for function where there aren't any variables
2. whats up with the four lines: line 1, line 2, line 3, line 4? what is it trying to do & WHY?

Answer 1

The four code lines you've indicated are the debug build clearing out the local variable space with the "clear" special value (0xCCCCCCCC).

I'm not sure why there are 192 bytes of seemingly dead space, but that might be VC++ building some guard space into your local variable area to try to detect stack smashing.

You will probably get a very different output if you switch from Debug to Release build.

Answer 2

Greg already explained how the compiler generates code to diagnose uninitialized local variables, enabled by the /RTCu compile option. The 0xcccccccc value was chosen to be distinctive and easily recognized in the debugger and to ensure the program bombs when an uninitialized pointer is dereferenced. The debug allocator initializes its memory to a similar value, 0xcdcdcdcd.

The mysterious 192 bytes that are allocated in the stack frame are there to support the Edit + Continue feature, /ZI compile option. It allows you to edit the code while a breakpoint is active. And add local variables to a function. Those 192 bytes are available to provide the space for those added locals. Exceeding that space with your edits will make the IDE rebuild your program, depending on the current execution address.

Btw: this can cause a problem if you use recursion in your code. The debug build will bomb on a stack overflow exception a lot quicker.