Q6Compiler Design

When a compiler transforms abstract source code into a physical executable binary, it must mathematically dictate exactly how the operating system will allocate silicon RAM to the program's variables, objects, and function calls during execution. Compiler engineers classify memory allocation into three rigid, highly optimized architectural strategies: Static Allocation, Stack Allocation, and Heap Allocation.

1. Static Storage Allocation

In this primitive but ultra-fast strategy, memory is violently and permanently locked in during the actual compilation phase (Compile-Time), long before the program ever runs. The exact memory addresses for variables are hard-coded into the binary executable. - Application: Used for global variables, static variables, and constants. - Merits: Zero runtime overhead; execution is blindingly fast because there is no dynamic memory calculation. - Demerits: It catastrophically fails to support recursion, because a recursive function requires multiple separate memory blocks for each instance, which static allocation physically cannot provide. The memory size must be mathematically known in advance.

2. Stack Storage Allocation (Dynamic)

This is a dynamic, runtime strategy that organizes memory into a strict Last-In-First-Out (LIFO) architecture. Whenever a function is called, the CPU aggressively pushes a new "Activation Record" (or Stack Frame) onto the stack. This frame contains the function's local variables, return address, and parameters. - Application: Used exclusively for local variables inside functions and methods. - Merits: It flawlessly supports infinite recursion, as every recursive call simply pushes a new frame onto the stack. Memory is automatically and violently freed (popped) the exact millisecond the function returns, completely preventing memory leaks. - Demerits: Variables are destroyed upon function exit; they cannot persist.

3. Heap Storage Allocation (Dynamic)

The Heap is an unstructured, massive pool of available RAM. Allocation and deallocation can occur randomly at any point during runtime, completely ignoring the strict LIFO rules of the stack. - Application: Used for dynamic memory requested manually by the programmer (e.g., using malloc() in C or new in C++/Java) for data structures like Linked Lists or Trees where the size is utterly unknown at compile-time. - Merits: Massive flexibility; data violently persists until explicitly deleted. - Demerits: Extremely slow overhead to track fragmented memory. If the programmer forgets to free the memory, it causes a catastrophic Memory Leak.