Preserving callee-saved registers in ARM Architecture - Step-by-Step Execution

Concept Flow - Preserving callee-saved registers

Function Entry

↓

Save callee-saved registers on stack

↓

Execute function body

↓

Restore callee-saved registers from stack

↓

Return to caller

When a function starts, it saves certain registers on the stack to keep their values safe. After running, it restores them before returning.

Execution Sample

ARM Architecture

push {r4, r5, lr}
...function body...
pop {r4, r5, pc}

This code saves registers r4, r5, and the return address (lr) at the start, runs the function, then restores them before returning.

Analysis Table

Step	Action	Registers Saved	Stack State	Registers Restored	Return Address
1	Function Entry	None	Empty	None	Unknown
2	Push r4, r5, lr	r4, r5, lr	r4, r5, lr saved on stack	None	Unknown
3	Execute function body	r4, r5, lr	r4, r5, lr saved on stack	None	Unknown
4	Pop r4, r5, pc	r4, r5, lr	Empty	r4, r5 restored	Return to caller
5	Return	None	Empty	All restored	Returned

💡 Function returns after restoring callee-saved registers and loading return address into pc

State Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
r4	Original value	Saved on stack	Unchanged	Restored from stack	Original value
r5	Original value	Saved on stack	Unchanged	Restored from stack	Original value
lr	Return address	Saved on stack	Unchanged	Used to return	N/A (used)
Stack	Empty	r4, r5, lr pushed	Unchanged	Popped empty	Empty

Key Insights - 3 Insights

Why do we save callee-saved registers at the start of the function?

Because these registers must keep their values after the function finishes, saving them on the stack protects their original values during the function execution (see execution_table step 2).

What happens if we forget to restore callee-saved registers before returning?

The caller might get wrong values in those registers, causing errors. The execution_table step 4 shows restoring them before return is essential.

Why is the link register (lr) saved and restored?

The lr holds the return address. Saving it ensures the function can return correctly after execution (see execution_table steps 2 and 4).

Visual Quiz - 3 Questions

Look at the execution_table at step 2. Which registers are saved on the stack?

A r4, r5, lr

B r0, r1, r2

C pc, sp, lr

D r6, r7, r8

💡 Hint

Check the 'Registers Saved' column at step 2 in the execution_table.

At which step does the function restore the saved registers?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the 'Registers Restored' column in the execution_table.

If the function did not save the lr register, what would happen?

A The stack would overflow.

B The function would still return correctly.

C The return address might be lost, causing incorrect return.

D Registers r4 and r5 would be corrupted.

💡 Hint

Refer to the key_moments about why lr is saved and restored.

Concept Snapshot

Preserving callee-saved registers:
- Save registers like r4, r5, lr on function entry (push).
- Execute function code safely.
- Restore registers before returning (pop).
- Ensures caller's register values stay unchanged.
- lr holds return address; must be saved/restored.

Full Transcript

When a function starts in ARM architecture, it saves certain registers called callee-saved registers, such as r4, r5, and the link register (lr), onto the stack. This protects their values while the function runs. After the function finishes its work, it restores these registers from the stack before returning to the caller. This process ensures that the caller's register values remain unchanged and the function returns correctly using the saved return address in lr.