Stack frame setup in ARM Architecture - Mini Project: Build & Apply

Stack Frame Setup in ARM Assembly

📖 Scenario: You are learning how ARM processors manage function calls using the stack. When a function starts, it creates a stack frame to save important information like the return address and local variables. This helps the program keep track of where to return after the function finishes.Imagine you are organizing your desk before starting a task: you put away your phone, open a notebook, and keep your pen ready. Similarly, the processor sets up a stack frame to keep things organized during a function call.

🎯 Goal: Build a simple ARM assembly code snippet that sets up a stack frame at the start of a function and tears it down before returning. You will create the initial stack pointer adjustment, save the link register, and restore everything properly.

📋 What You'll Learn

Create a function label called my_function

At the start, push the link register (lr) onto the stack

Adjust the stack pointer (sp) to allocate space for local variables

At the end, restore the stack pointer and pop the link register

Return from the function using bx lr

💡 Why This Matters

🌍 Real World

Stack frames are essential in ARM assembly for managing function calls, local variables, and return addresses, which is critical in embedded systems and low-level programming.

💼 Career

Understanding stack frame setup is important for roles in embedded software development, firmware engineering, and systems programming where ARM processors are common.

1

Create the function label and push lr onto the stack

Write the ARM assembly code to create a function label called my_function. Inside it, push the link register lr onto the stack using the push instruction.

ARM Architecture

my_function:
    // Your code here

Hint

Use push {lr} to save the return address on the stack.

2

Adjust the stack pointer to allocate space for local variables

After pushing lr, subtract 16 from the stack pointer sp to reserve space for local variables. Use the sub sp, sp, #16 instruction.

ARM Architecture

my_function:
    push {lr}
    // Your code here

Hint

Use sub sp, sp, #16 to move the stack pointer down by 16 bytes.

3

Restore the stack pointer before returning

Before returning from the function, add 16 back to the stack pointer sp to free the local variable space. Use the add sp, sp, #16 instruction.

ARM Architecture

my_function:
    push {lr}
    sub sp, sp, #16
    // Your code here

Hint

Use add sp, sp, #16 to restore the stack pointer.

4

Pop lr and return from the function

Finally, pop the link register lr from the stack using pop {lr} and return from the function with bx lr.

ARM Architecture

my_function:
    push {lr}
    sub sp, sp, #16
    add sp, sp, #16
    // Your code here

Hint

Use pop {lr} to restore the return address and bx lr to jump back.

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