Stack frame setup in ARM Architecture - Step-by-Step Execution

Concept Flow - Stack frame setup

Function call

↓

Push return address (LR) onto stack

↓

Push previous frame pointer (FP) onto stack

↓

Set new FP to current SP

↓

Allocate space for local variables by adjusting SP

↓

Function body executes

↓

Restore SP from FP

↓

Pop FP from stack

↓

Pop return address (LR) from stack

↓

Return to caller

This flow shows how a function sets up its stack frame on ARM: saving return address and frame pointer, allocating space, then restoring on return.

Execution Sample

ARM Architecture

push {lr}
push {fp}
add fp, sp, #0
sub sp, sp, #16
; function body
add sp, fp, #0
pop {fp}
pop {pc}

ARM assembly instructions to set up and tear down a stack frame during a function call.

Analysis Table

Step	Action	SP (Stack Pointer)	FP (Frame Pointer)	Stack Content (Top to Bottom)
1	Function call starts	0x1000	0x0000	Empty
2	Push LR (return address)	0x0FFC	0x0000	LR
3	Push FP (previous frame pointer)	0x0FF8	0x0000	FP, LR
4	Set FP = SP	0x0FF8	0x0FF8	FP, LR
5	Allocate locals (sub SP by 16)	0x0FE8	0x0FF8	Local vars space, FP, LR
6	Function body executes	0x0FE8	0x0FF8	Local vars space, FP, LR
7	Restore SP from FP	0x0FF8	0x0FF8	FP, LR
8	Pop FP	0x0FFC	0x0000	LR
9	Pop LR (return address)	0x1000	0x0000	Empty
10	Return to caller	0x1000	0x0000	Empty

💡 Function returns; SP and FP restored to original values; stack cleaned.

State Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 7	After Step 8	Final
SP	0x1000	0x0FFC	0x0FF8	0x0FF8	0x0FE8	0x0FF8	0x0FFC	0x1000
FP	0x0000	0x0000	0x0000	0x0FF8	0x0FF8	0x0FF8	0x0000	0x0000
Stack Content	Empty	LR	FP, LR	FP, LR	Local vars, FP, LR	FP, LR	LR	Empty

Key Insights - 3 Insights

Why do we push the LR (return address) onto the stack at the start?

Because the function may call other functions and overwrite LR, saving it on the stack preserves the return address (see Step 2 in execution_table).

What is the purpose of setting FP = SP after pushing FP?

Setting FP to SP marks the base of the current stack frame, so local variables and parameters can be accessed relative to FP (see Step 4).

Why do we restore SP from FP before popping FP and LR?

Restoring SP from FP deallocates local variables, returning SP to the frame base before popping saved registers (see Step 7).

Visual Quiz - 3 Questions

Look at the execution_table at Step 5, what is the SP value after allocating space for local variables?

A 0x0FF8

B 0x0FFC

C 0x0FE8

D 0x1000

💡 Hint

Check the SP column at Step 5 in the execution_table.

At which step is the FP set to the current SP?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look for the action 'Set FP = SP' in the execution_table.

If the function did not push FP onto the stack, what would be missing after Step 8?

A Previous frame pointer (FP)

B Local variables space

C Return address (LR)

D Stack pointer (SP)

💡 Hint

See what is popped at Step 8 in the execution_table.

Concept Snapshot

Stack frame setup in ARM:
- Push LR (return address) to stack
- Push FP (previous frame pointer)
- Set FP = SP (new frame base)
- Allocate locals by subtracting from SP
- On return, restore SP from FP
- Pop FP and LR
- Return to caller

Full Transcript

When a function is called in ARM architecture, it sets up a stack frame to manage local variables and return information. First, it pushes the return address (LR) onto the stack to save where to return after finishing. Then it pushes the previous frame pointer (FP) to keep track of the caller's frame. The FP is updated to the current SP to mark the new frame base. The stack pointer (SP) is then moved down to allocate space for local variables. After the function body runs, SP is restored from FP to deallocate locals. Finally, FP and LR are popped off the stack to restore the caller's context, and the function returns. This process ensures each function call has its own safe workspace on the stack.

Practice

1. What is the primary purpose of setting up a stack frame in ARM architecture during a function call?

easy

A. To save the return address and local variables safely

B. To increase the CPU clock speed

C. To clear all registers before execution

D. To allocate memory for global variables

Solution

1. Step 1: Understand stack frame role

   A stack frame stores important data like return address and local variables for each function call.

2. Step 2: Identify the main purpose

   This setup ensures the function can return correctly and use local data safely.

3. Final Answer:

   To save the return address and local variables safely -> Option A

4. Quick Check:

   Stack frame purpose = Save return address and locals [OK]

Hint: Stack frame saves return address and locals [OK]

Common Mistakes:

• Confusing stack frame with CPU speed control
• Thinking it clears all registers
• Mixing local and global variable storage

2. Which ARM instruction is commonly used to save the link register (return address) onto the stack during stack frame setup?

easy

A. MOV LR, SP

B. POP {LR}

C. PUSH {LR}

D. ADD SP, SP, #4

Solution

1. Step 1: Identify instruction to save LR

   The link register (LR) holds the return address and is saved on the stack using PUSH.

2. Step 2: Match correct instruction

   PUSH {LR} stores LR on the stack; POP {LR} restores it. MOV and ADD do not save LR on stack.

3. Final Answer:

   PUSH {LR} -> Option C

4. Quick Check:

   Save LR with PUSH {LR} [OK]

Hint: Use PUSH to save LR on stack [OK]

Common Mistakes:

• Using POP instead of PUSH to save
• Confusing MOV with stack operations
• Adding to SP instead of saving LR

3. Consider this ARM assembly snippet for function entry:

SUB SP, SP, #16
PUSH {LR}

What is the effect on the stack pointer (SP) after these instructions?

medium

A. SP increases by 16 bytes

B. SP decreases by 16 bytes, then by 4 bytes

C. SP decreases by 20 bytes

D. SP remains unchanged

Solution

1. Step 1: Analyze SUB SP, SP, #16

   This subtracts 16 from SP, moving it down by 16 bytes to allocate space.

2. Step 2: Analyze PUSH {LR}

   PUSH stores LR on stack, which decreases SP by 4 bytes (ARM uses 4-byte words).

3. Final Answer:

   SP decreases by 16 bytes, then by 4 bytes -> Option B

4. Quick Check:

   SP moves down 16 + 4 bytes = 20 bytes total [OK]

Hint: SUB reduces SP, PUSH reduces SP by 4 bytes [OK]

Common Mistakes:

• Adding to SP instead of subtracting
• Ignoring PUSH effect on SP
• Assuming SP stays same after PUSH

4. In this ARM function prologue, what is the error?

SUB SP, SP, #8
POP {LR}

medium

A. LR should not be used in function prologue

B. SUB should add to SP, not subtract

C. SP should not be changed in prologue

D. POP should be PUSH to save LR first

Solution

1. Step 1: Understand stack frame setup order

   Function prologue saves LR by PUSH before changing SP to allocate space.

2. Step 2: Identify incorrect instruction

   POP removes data from stack; here it tries to restore LR before saving it, which is wrong.

3. Final Answer:

   POP should be PUSH to save LR first -> Option D

4. Quick Check:

   Save LR with PUSH before POP [OK]

Hint: Save LR with PUSH before POP [OK]

Common Mistakes:

• Using POP instead of PUSH to save LR
• Changing SP incorrectly
• Ignoring function prologue conventions

5. You want to create a stack frame that saves LR and allocates 24 bytes for local variables. Which sequence correctly sets up the stack frame in ARM assembly?

hard

A. SUB SP, SP, #24
PUSH {LR}

B. PUSH {LR}
SUB SP, SP, #24

C. PUSH {LR, R4}
SUB SP, SP, #20

D. SUB SP, SP, #28
PUSH {LR}

Solution

1. Step 1: Save LR before allocating locals

   Correct order is to allocate space first by subtracting from SP, then save LR with PUSH.

2. Step 2: Check options for correct order and size

   SUB SP, SP, #24 PUSH {LR} subtracts 24 bytes first, then saves LR, which is the correct order to allocate space and save registers.

3. Step 3: Re-examine options carefully

   SUB SP, SP, #24 PUSH {LR}: SUB SP, SP, #24 then PUSH {LR} - correct order and size.
   PUSH {LR} SUB SP, SP, #24: PUSH {LR} then SUB SP, SP, #24 - wrong order.
   PUSH {LR, R4} SUB SP, SP, #20: PUSH {LR, R4} then SUB SP, SP, #20 - wrong registers and size.
   SUB SP, SP, #28 PUSH {LR}: SUB SP, SP, #28 then PUSH {LR} - wrong size.

4. Final Answer:

   SUB SP, SP, #24 PUSH {LR} -> Option A

5. Quick Check:

   Allocate locals first, then save LR [OK]

Hint: SUB SP first to allocate locals, then PUSH LR [OK]

Common Mistakes:

• Allocating space after saving LR
• Using wrong register sets in PUSH
• Mismatching allocated bytes and saved registers