Is the stack grown only when entering a function?

Question

In C, one can declare variables inside blocks. Is the space for variables declared inside these blocks allocated (i.e. the stack expands) when entering the function, or only later, when entering the block?

I know I could answer the question by firing up a debugger and looking at the disassembly, but I'm interested in knowing if the behavior is consistent across different platforms/compilers, and whether it can change as a result of optimizations.

EDIT: The answer is "it's implementation defined". It seems most implementation would indeed only do it when entering the function, excepted for dynamic-size arrays and alloca(). See the comments of this question and of the accepted answer for more details.

Answer 1

From the perspective of the C programming language, all that's guaranteed is that variables with automatic storage duration (local variables) will have their memory created and destroyed as appropriate when the program is run. To the best of my knowledge, it's completely implementation defined if and when the memory for each variable will be allocated and deallocated.

In the extreme, variables might not even get memory assigned to them if they're local variables that can be stored inside registers. In that case, many different variables might actually have the same location in memory even though technically speaking they all exist at the same time, provided that the compiler could notice that the variables never actually need to co-exist. At another extreme, space for variable-length arrays can't be allocated until the size is known, so unless the compiler can do static analysis and determine that the memory for the array is needed earlier on it probably has to defer allocation until the point where the VLA is declared.

Hope this helps!