Activation records and call stack in Compiler Design - Step-by-Step Execution

Concept Flow - Activation records and call stack

Function Call

↓

Create Activation Record

↓

Push Record on Call Stack

↓

Execute Function Body

↓

Function Returns

↓

Pop Activation Record from Stack

↓

Resume Caller Execution

When a function is called, a new activation record is created and pushed onto the call stack. The function runs, then its record is popped off when it returns, resuming the caller.

Execution Sample

Compiler Design

def main():
    print('Start')
    greet('Alice')
    print('End')

def greet(name):
    print('Hello,', name)

This code calls greet from main, showing how activation records are created and removed on the call stack.

Analysis Table

Step	Action	Call Stack State	Current Function	Output
1	main() called	[main]	main
2	print('Start')	[main]	main	Start
3	greet('Alice') called	[main, greet]	greet
4	print('Hello, Alice')	[main, greet]	greet	Hello, Alice
5	greet returns	[main]	main
6	print('End')	[main]	main	End
7	main returns	[]	none

💡 main function finishes, call stack is empty, program ends

State Tracker

Variable	Start	After Step 1	After Step 3	After Step 5	Final
Call Stack	[]	[main]	[main, greet]	[main]	[]
Current Function	none	main	greet	main	none

Key Insights - 3 Insights

Why does the call stack grow when a function is called?

Each function call creates a new activation record pushed onto the stack to keep track of that call's data and return point, as shown in steps 1 and 3 of the execution table.

What happens to the activation record when a function finishes?

The activation record is popped off the call stack to free space and return control to the caller, as seen in steps 5 and 7.

Why is the call stack empty at the end?

Because all functions have returned and their activation records removed, leaving no active calls, shown in the final step 7.

Visual Quiz - 3 Questions

Look at the execution table at step 3. What is the call stack state?

A []

B [main]

C [main, greet]

D [greet]

💡 Hint

Check the 'Call Stack State' column at step 3 in the execution table.

At which step does the function greet return and its activation record get removed?

A Step 4

B Step 5

C Step 6

D Step 7

💡 Hint

Look for the 'greet returns' action in the execution table.

If main called another function before printing 'End', how would the call stack change at step 6?

A It would have two activation records

B It would be empty

C It would have only main

D It would have three activation records

💡 Hint

Refer to the call stack growth pattern in the variable tracker and execution table.

Concept Snapshot

Activation records store function call info.
Each call pushes a record on the call stack.
Function runs using its record.
Return pops the record off.
Call stack tracks active calls.
Empty stack means program end.

Full Transcript

When a function is called, the program creates an activation record that holds information like parameters, local variables, and return address. This record is pushed onto the call stack, which keeps track of all active function calls. The function executes using its activation record. When the function finishes, its activation record is popped off the stack, and control returns to the caller. This process repeats for every function call. The call stack grows with each call and shrinks as functions return. When the main function returns, the call stack is empty, and the program ends.