🧠 Storage Organization and Stack Allocation of Space (Compiler Construction)

This topic belongs to the Runtime Environment / Code Generation phase of a compiler. It explains how memory is organized when a program runs and how space is allocated for functions, variables, and procedures.

---

📌 1. Storage Organization

📖 Definition

Storage organization refers to how memory is arranged and managed during program execution.

👉 It divides memory into different regions to store:

• Program code
• Variables
• Function calls
• Dynamic data

---

🧠 2. Memory Layout of a Running Program

A typical program memory is divided into 4 main sections:

---

📊 Memory Layout Diagram

+----------------------+
| Text Segment        |  ← Program code (instructions)
+----------------------+
| Static / Data Area  |  ← Global & static variables
+----------------------+
| Heap                |  ← Dynamic memory (malloc/new)
+----------------------+
| Stack              |  ← Function calls, local variables
+----------------------+

---

🔹 1. Text Segment

• Stores program instructions
• Read-only

---

🔹 2. Data Segment

• Stores global variables
• Static variables

---

🔹 3. Heap

• Dynamic memory allocation
• Grows upward

Example:

malloc(), new

---

🔹 4. Stack

• Stores function calls
• Local variables
• Grows downward

---

📌 3. Stack Allocation of Space

📖 Definition

Stack allocation is a method of allocating memory for function calls in a Last In First Out (LIFO) manner using a stack.

👉 Each function call gets a block called:

Activation Record (Stack Frame)

---

🧠 4. Activation Record (Very Important)

📖 Definition

An activation record is a block of memory used to store information about a function call.

---

📊 Structure of Activation Record

+----------------------+
| Parameters          |
+----------------------+
| Return Address      |
+----------------------+
| Control Link        |
+----------------------+
| Access Link         |
+----------------------+
| Local Variables     |
+----------------------+
| Temporary Values    |
+----------------------+

---

🔹 Explanation of Fields

1. Parameters

• Input arguments of function

2. Return Address

• Where to return after function execution

3. Control Link

• Points to previous activation record

4. Access Link

• Used for nested functions (static scope)

5. Local Variables

• Variables declared inside function

6. Temporaries

• Intermediate results

---

⚙️ 5. Stack Allocation Process

Step-by-step execution:

🔹 Step 1: Function Call Occurs

Memory block (activation record) is created

🔹 Step 2: Push on Stack

New frame is pushed

🔹 Step 3: Execution Happens

Function executes using its frame

🔹 Step 4: Return

Frame is popped from stack

---

📊 Stack Behavior Diagram

| Function C |
| Function B |
| Function A |  ← top of stack

When C finishes:

| Function B |
| Function A |

---

🧠 6. Example of Stack Allocation

int main() {
   int x = 10;
   fun();
}

void fun() {
   int y = 20;
}

Execution:

1. main() activation record created
2. fun() called → new activation record pushed
3. fun() completes → popped
4. return to main()

---

📌 7. Properties of Stack Allocation

✔ Fast allocation and deallocation ✔ Follows LIFO order ✔ Memory reused automatically ✔ Used for function calls ✔ Efficient for recursive programs

---

⚠️ 8. Limitations of Stack Allocation

❌ Cannot handle dynamic data (fully flexible structures) ❌ Limited lifetime of variables ❌ Not suitable for objects needing long-term storage

👉 That’s why heap is also used.

---

🧠 9. Stack vs Heap (Very Important Exam Comparison)

Feature	Stack	Heap
Allocation	Automatic	Manual
Speed	Fast	Slower
Structure	LIFO	Random
Lifetime	Temporary	Long-term
Used for	Functions	Dynamic memory

---

📌 10. Key Exam Points

✔ Memory is divided into text, data, heap, stack ✔ Stack stores function calls and local variables ✔ Each function uses Activation Record ✔ Stack follows LIFO order ✔ Stack allocation is fast and automatic ✔ Used heavily in recursive function calls

---

🎯 Final Exam Definition

Storage organization refers to how memory is divided into segments like text, data, heap, and stack during program execution. Stack allocation of space is a runtime memory management technique where function calls are handled using a stack, and each call creates an activation record containing parameters, return address, local variables, and control information.

---

📊 FINAL REVISION TABLE

Concept	Description
Storage organization	Memory layout of program
Stack	Stores function calls
Heap	Dynamic memory
Data segment	Global/static variables
Activation record	Function call memory block
Stack allocation	LIFO memory management

---