Activation Records: Structure and Role During Procedure Execution
An activation record (also called a stack frame or stack frame record) is the per-call memory region created when a procedure is invoked. It stores (1) control-flow information needed to return and (2) data needed to execute the procedure correctly, such as parameters, local variables, and sometimes temporaries or bookkeeping for nested scopes. During procedure execution, the program transitions from caller to callee by establishing the callee’s activation record, then transitions back by dismantling it.
Below is a conceptual structure (layout varies by compiler/ABI), followed by the lifecycle of how an activation record is used during a call.
Key ideas:
- The program counter or return address lets the machine resume at the correct instruction after the call.
- The stack pointer identifies the current top of stack memory and moves as frames are pushed/popped.
- A frame pointer may be used so the compiler can reliably address arguments and locals at constant offsets.
Important: Exact field names and ordering are ABI- and compiler-dependent (e.g., x86-64 SysV vs. Windows x64), but the conceptual roles are consistent.
Stack Frames & Activation Records (Intro) — Lecture-style walkthrough
Typical components of an activation record
An activation record generally contains these categories:
-
Control-flow data
- Return address: where execution should continue after the callee completes. Usually stored near the top/bottom of the frame.
- Dynamic link (if supported): helps restore the caller’s frame during return.
- Static link (used for nested scopes): supports lexical scoping so inner functions can access variables from enclosing blocks.
-
Call data / procedure interface
- Arguments (parameters): values passed by the caller.
- Saved registers (callee-saved): if the procedure must preserve certain registers per calling convention.
-
Execution data
- Local variables: storage for variables declared in the procedure.
- Temporaries / spilled values: intermediate results and register spill locations.
- Saved control state: sometimes includes bookkeeping for exception handling or alignment padding.
Canonical (conceptual) layout (left-to-right as “growing direction” varies)
A common conceptual stack-frame layout (not universal) is:
- Lower addresses: caller data
- Higher addresses: callee frame data (or vice versa depending on architecture)
Example conceptual fields:
| Field category | What it stores | Why it’s needed |
|---|---|---|
| Return address | Call-site continuation point | Implements procedure return |
| Saved frame pointer / base pointer | Caller’s frame reference | Restores caller’s access base |
| Dynamic link | Link to caller frame | Restores caller context |
| Static link | Link to enclosing scope frame | Implements lexical access |
| Arguments | Procedure inputs | Callee reads its parameters |
| Local variables | Procedure locals | Callee stores computation state |
| Temporaries/spills | Intermediate values | Supports code generation & register pressure |
Use this as a mental model: compilers may omit dynamic/static links if language features don’t require them, and modern ABIs often pass many arguments in registers, keeping the frame for locals and spill slots.
Procedure call lifecycle: how the activation record is created, used, and removed
- 1Step 1
The caller computes argument values and places them where the calling convention expects them (registers or stack).
- 2Step 2
A call/branch instruction transfers control; hardware/ABI semantics make the return address available or stores it explicitly in the callee’s frame.
- 3Step 3
The callee allocates space on the stack (moves the stack pointer) and may save the old frame pointer/base pointer so it can be restored later.
- 4Step 4
Per calling convention, the callee saves any callee-saved registers it will overwrite and may set up access links (dynamic/static) for nested scopes.
- 5Step 5
The compiler generates load/store instructions that reference parameters and locals at stable offsets from the frame pointer (or stack pointer).
- 6Step 6
Before returning, the callee restores saved registers and reclaims stack space by moving the stack pointer back.
- 7Step 7
The callee jumps to the stored return address, resuming execution in the caller with its previous frame pointer and stack state restored.
Role of the activation record during execution
During execution, the activation record acts as the runtime environment for one invocation:
- Addressing locals and parameters
- With a frame pointer, locals and arguments are addressed at known offsets, enabling efficient and correct memory access.
- Maintaining correct control flow
- The return address ensures that after the procedure finishes, execution resumes exactly at the call-site continuation.
- Supporting nested procedures / lexical scoping
- When the language has nested functions/blocks, the static link allows the callee to find variables in enclosing scopes without global search.
- Ensuring calling-convention correctness
- The allocation and restoration of saved registers and stack pointer state guarantees that the caller’s assumptions remain valid.
Pro Tip: Think in “what must be restored?” terms
If you can identify what the caller must still be able to rely on after the call (e.g., return location, register values, stack pointer/frame pointer), those become the activation-record fields and epilogue actions.
Warning: Don’t assume a single universal frame layout
Stack-frame layouts vary with ABI, optimization level, and language features (e.g., nested functions). Always separate the conceptual components from the exact physical ordering. Misassumptions here are a common source of bugs in low-level reasoning.
Activation record during a single procedure invocation
Prepare inputs
Call-siteCaller computes arguments and performs the call instruction."
Create frame
Entry / PrologueCallee allocates stack space, saves needed context, and sets up links."
Use frame
BodyCallee reads parameters, updates locals/temporaries, possibly accesses enclosing scope via static link."
Tear down frame
Exit / EpilogueCallee restores saved state, releases stack space."
Resume caller
ReturnControl jumps to return address; caller continues with its original runtime environment restored."
Visual summary: control and data flow
Common questions about activation records
Knowledge Check
Which activation-record component is most directly responsible for resuming execution after a procedure finishes?