Preserving callee-saved registers in ARM Architecture - Mini Project: Build & Apply

Preserving Callee-Saved Registers in ARM Assembly

📖 Scenario: You are writing a simple ARM assembly function that calls another function. To keep your program stable, you need to save and restore certain registers that the called function might change.This is important because some registers must keep their values across function calls, so the caller function can continue correctly after the call.

🎯 Goal: Build a small ARM assembly code snippet that saves callee-saved registers at the start of a function and restores them before returning.This will help you understand how to preserve important data during function calls.

📋 What You'll Learn

Create a function named my_function.

At the start of my_function, push registers r4, r5, and lr onto the stack.

Add a configuration variable saved_registers that lists the registers to save.

Inside my_function, simulate some operations (can be a comment).

Before returning, pop the registers r4, r5, and lr from the stack.

End the function with a bx lr instruction to return.

💡 Why This Matters

🌍 Real World

In embedded systems and low-level programming, preserving callee-saved registers ensures that functions do not accidentally overwrite important data, preventing bugs and crashes.

💼 Career

Understanding register preservation is essential for ARM assembly programmers, firmware developers, and anyone working close to hardware or optimizing performance-critical code.

1

Create the function and push registers

Write ARM assembly code to create a function named my_function. At the start of this function, push the registers r4, r5, and lr onto the stack using the push instruction.

ARM Architecture

; Define function my_function
; Your code here

Hint

Use the push instruction with the registers inside curly braces.

2

Add a configuration variable for saved registers

Add a variable named saved_registers that contains the list of registers r4, r5, and lr as a comment or label to indicate which registers are saved.

ARM Architecture

my_function:
    push {r4, r5, lr}

; Define saved_registers list
; Your code here

Hint

Use a comment to define saved_registers as {r4, r5, lr}.

3

Add core logic placeholder

Inside my_function, add a comment line that says Perform operations here to simulate the function's main work.

ARM Architecture

my_function:
    push {r4, r5, lr}

; saved_registers = {r4, r5, lr}

    ; Your code here

Hint

Just add a comment line inside the function body.

4

Pop registers and return

Before the function ends, pop the registers r4, r5, and lr from the stack using the pop instruction. Then add bx lr to return from the function.

ARM Architecture

my_function:
    push {r4, r5, lr}

; saved_registers = {r4, r5, lr}

    ; Perform operations here

    ; Your code here

Hint

Use pop with the same registers as push, then bx lr to return.

Practice

1. What is the main purpose of preserving callee-saved registers in ARM architecture?

easy

A. To speed up the execution of the program

B. To allow the caller to modify registers freely

C. To keep the values intact across function calls

D. To reduce the number of registers used

Solution

1. Step 1: Understand the role of callee-saved registers

   Callee-saved registers must keep their values unchanged after a function call to avoid breaking the caller's data.

2. Step 2: Identify the purpose of preserving these registers

   Preserving means saving and restoring their values so the caller sees no change.

3. Final Answer:

   To keep the values intact across function calls -> Option C

4. Quick Check:

   Preserving registers = keeping values intact [OK]

Hint: Remember: callee saves to protect caller's data [OK]

Common Mistakes:

• Thinking callee-saved registers speed up execution
• Confusing callee-saved with caller-saved registers
• Believing registers can be freely modified without saving

2. Which ARM assembly instruction is commonly used to save callee-saved registers at the start of a function?

easy

A. MOV

B. ADD

C. CMP

D. PUSH

Solution

1. Step 1: Identify instruction to save registers

   The PUSH instruction stores registers onto the stack, preserving their values.

2. Step 2: Confirm PUSH is used at function start

   Functions use PUSH to save callee-saved registers before modifying them.

3. Final Answer:

   PUSH -> Option D

4. Quick Check:

   Save registers = PUSH [OK]

Hint: PUSH saves registers on stack at function start [OK]

Common Mistakes:

• Using MOV which copies but doesn't save to stack
• Using ADD which changes values, not saves
• Using CMP which compares values, not saves

3. Consider this ARM function snippet:

func:
  PUSH {r4, r5}
  MOV r4, #10
  MOV r5, #20
  POP {r4, r5}
  BX lr

What will be the value of registers r4 and r5 after returning to the caller?

medium

A. r4 and r5 unchanged from caller

B. r4 and r5 contain random values

C. r4 = 0, r5 = 0

D. r4 = 10, r5 = 20

Solution

1. Step 1: Analyze PUSH and POP effect

   PUSH saves original r4 and r5 values on stack; POP restores them before return.

2. Step 2: Understand MOV instructions inside function

   Inside function, r4 and r5 are changed, but POP restores original values before returning.

3. Final Answer:

   r4 and r5 unchanged from caller -> Option A

4. Quick Check:

   Saved and restored registers = unchanged after call [OK]

Hint: PUSH then POP restores original register values [OK]

Common Mistakes:

• Assuming MOV changes persist after POP
• Ignoring that POP restores saved registers
• Thinking registers reset to zero automatically

4. A function modifies callee-saved registers but forgets to restore them before returning. What problem can this cause?

medium

A. The program may crash or behave unpredictably

B. The function will run faster

C. The caller's registers remain unchanged

D. The stack pointer will not be affected

Solution

1. Step 1: Understand callee-saved register role

   These registers must be restored to keep caller's data intact.

2. Step 2: Consequence of not restoring

   If not restored, caller sees wrong values, causing crashes or wrong behavior.

3. Final Answer:

   The program may crash or behave unpredictably -> Option A

4. Quick Check:

   Not restoring callee-saved = crashes/unpredictable [OK]

Hint: Not restoring callee-saved causes crashes [OK]

Common Mistakes:

• Thinking it improves speed
• Believing caller's registers stay safe without restore
• Ignoring stack pointer effects

5. You have a function that uses registers r4, r5, and r6 (all callee-saved). Which sequence correctly preserves and restores these registers?

hard

A. MOV r4, #0
MOV r5, #0
MOV r6, #0
...function body...
BX lr

B. PUSH {r4, r5, r6}
...function body...
POP {r4, r5, r6}

C. PUSH {r4}
PUSH {r5}
PUSH {r6}
...function body...
POP {r4}
POP {r5}
POP {r6}

D. POP {r4, r5, r6}
...function body...
PUSH {r4, r5, r6}

Solution

1. Step 1: Identify correct saving method

   Registers must be pushed together at function start to save their original values.

2. Step 2: Identify correct restoring method

   Registers must be popped in the same order before returning to restore original values.

3. Step 3: Check options for correct sequence

   PUSH {r4, r5, r6} ...function body... POP {r4, r5, r6} pushes all three registers at once and pops them before return, which is correct.

4. Final Answer:

   PUSH {r4, r5, r6} ...function body... POP {r4, r5, r6} -> Option B

5. Quick Check:

   Push all then pop all = correct preservation [OK]

Hint: Push all callee-saved at start, pop all before return [OK]

Common Mistakes:

• Pushing and popping registers separately in wrong order
• Using POP before PUSH
• Overwriting registers without saving