Storage of auto variables and parameters
Variables that are defined inside a function—and not declared static—are named auto variables by the C standard. A few of these variables are placed in processor registers, while the rest are placed on the stack. From a semantic point of view, this is equivalent. The main differences are that accessing registers is faster, and that less memory is required compared to when variables are located on the stack.
Auto variables can only live as long as the function executes—when the function returns, the memory allocated on the stack is released.
The stack
Temporary results of expressions
The return value of a function (unless it is passed in registers)
Processor registers that should be restored before the function returns (callee-save registers).
Canaries, used in stack-protected functions. See Stack protection.
The stack is a fixed block of memory, divided into two parts. The first part contains allocated memory used by the function that called the current function, and the function that called it, etc. The second part contains free memory that can be allocated. The borderline between the two areas is called the top of stack and is represented by the stack pointer, which is a dedicated processor register. Memory is allocated on the stack by moving the stack pointer.
A function should never refer to the memory in the area of the stack that contains free memory. The reason is that if an interrupt occurs, the called interrupt function can allocate, modify, and—of course—deallocate memory on the stack.
See also Stack considerations and Setting up stack memory.
Advantages
The main advantage of the stack is that functions in different parts of the program can use the same memory space to store their data. Unlike a heap, a stack will never become fragmented or suffer from memory leaks.
It is possible for a function to call itself either directly or indirectly—a recursive function—and each invocation can store its own data on the stack.
Potential problems
The way the stack works makes it impossible to store data that is supposed to live after the function returns. The following function demonstrates a common programming mistake. It returns a pointer to the variable x, a variable that ceases to exist when the function returns.
int *MyFunction()
{
int x;
/* Do something here. */
return &x; /* Incorrect */
}Another problem is the risk of running out of stack space. This will happen when one function calls another, which in turn calls a third, etc., and the sum of the stack usage of each function is larger than the size of the stack. The risk is higher if large data objects are stored on the stack, or when recursive functions are used.