Stack pointer (R13/SP) in ARM Architecture

Introduction

The stack pointer (R13 or SP) keeps track of the top of the stack in memory. It helps the processor know where to add or remove data during function calls and interrupts.

When saving the current function's local variables before calling another function.

When restoring data after a function finishes to continue execution correctly.

During interrupt handling to save the processor state safely.

When pushing or popping data to or from the stack manually in assembly code.

To manage temporary data storage in nested function calls.

Core Concept

ARM Architecture

Register R13 is reserved as the Stack Pointer (SP).

Common instructions involving SP:

PUSH {registers}    ; Decrement SP and store registers on stack
POP {registers}     ; Load registers from stack and increment SP

Example:
SUB SP, SP, #4      ; Make space on stack (push)
STR R0, [SP]        ; Store R0 at top of stack
LDR R1, [SP]        ; Load from top of stack into R1
ADD SP, SP, #4      ; Remove space from stack (pop)

R13 is a special register dedicated as the stack pointer in ARM architecture.

Stack grows downward in memory, so pushing data decreases SP, popping increases SP.

Key Points

This pushes the value of R0 onto the stack and moves SP down by 4 bytes.

ARM Architecture

PUSH {R0}
; Stack pointer (SP) decreases by 4 bytes
; R0 value stored at new SP address

This pops the top value from the stack into R1 and moves SP up by 4 bytes.

ARM Architecture

POP {R1}
; Value at SP loaded into R1
; SP increases by 4 bytes

Manually moves SP down by 8 bytes to allocate space.

ARM Architecture

SUB SP, SP, #8
; Reserve 8 bytes on stack for local variables

Manually moves SP up by 8 bytes to free space.

ARM Architecture

ADD SP, SP, #8
; Release 8 bytes from stack after use

Detailed Explanation

This program loads two values into registers R0 and R1, pushes them onto the stack using the stack pointer (SP), clears the registers, then pops the values back from the stack. It demonstrates how SP moves down when pushing and up when popping.

ARM Architecture

; Simple ARM assembly example showing stack pointer usage

AREA StackPointerExample, CODE, READONLY
ENTRY

    MOV R0, #10          ; Load 10 into R0
    MOV R1, #20          ; Load 20 into R1

    ; Push R0 and R1 onto stack
    PUSH {R0, R1}        ; SP decreases by 8 bytes

    ; Clear R0 and R1 to show values come from stack
    MOV R0, #0
    MOV R1, #0

    ; Pop values back into R0 and R1
    POP {R0, R1}         ; SP increases by 8 bytes

    ; End program (infinite loop)
    B .

END

Important Notes

Time complexity: Stack pointer operations like PUSH and POP run in constant time O(1).

Space complexity: Uses stack memory; careful management prevents overflow.

Common mistake: Forgetting that stack grows downward, so pushing decreases SP.

Use stack pointer operations to save and restore registers during function calls and interrupts.

Summary

The stack pointer (R13/SP) tracks the top of the stack in ARM processors.

Stack grows downward; pushing data decreases SP, popping increases SP.

Use PUSH and POP instructions to save and restore register values safely.

Practice

1. What is the primary role of the stack pointer (R13/SP) in ARM processors?

easy

A. It tracks the top of the stack during program execution.

B. It stores the current instruction being executed.

C. It holds the address of the program's entry point.

D. It manages the processor's clock speed.

Solution

1. Step 1: Understand the stack pointer's function

   The stack pointer (R13/SP) is a special register that points to the top of the stack in memory.

2. Step 2: Identify its role in program execution

   It helps manage data pushed onto or popped from the stack, such as function calls and local variables.

3. Final Answer:

   It tracks the top of the stack during program execution. -> Option A

4. Quick Check:

   Stack pointer = top of stack tracker [OK]

Hint: Stack pointer always points to the current top of the stack [OK]

Common Mistakes:

• Confusing stack pointer with program counter
• Thinking it stores instructions
• Assuming it controls processor speed

2. Which of the following is the register number for the stack pointer register in ARM assembly?

easy

A. R14

B. R13

C. SP

D. PC

Solution

1. Step 1: Recall ARM register naming

   In ARM architecture, R13 is the register used as the stack pointer.

2. Step 2: Match register names to functions

   R14 is the link register, PC is the program counter, and SP is an alias for R13.

3. Final Answer:

   R13 -> Option B

4. Quick Check:

   Stack pointer register = R13 [OK]

Hint: Remember R13 is SP, R14 is LR, PC is R15 [OK]

Common Mistakes:

• Confusing R13 with R14 (link register)
• Thinking SP is the register number
• Confusing it with PC (R15)

3. Consider this ARM assembly snippet:

SUB SP, SP, #4
STR R0, [SP]
ADD SP, SP, #4

What does this code do to the stack pointer?

medium

A. Moves SP down by 4, stores R0, then moves SP back up by 4

B. Moves SP up by 4, stores R0, then moves SP down by 4

C. Stores R0 without changing SP

D. Causes a runtime error due to invalid SP manipulation

Solution

1. Step 1: Analyze the SUB instruction

   SUB SP, SP, #4 decreases SP by 4, moving the stack pointer down to allocate space.

2. Step 2: Understand STR and ADD instructions

   STR R0, [SP] stores the value of R0 at the new top of the stack. ADD SP, SP, #4 restores SP back up by 4.

3. Final Answer:

   Moves SP down by 4, stores R0, then moves SP back up by 4 -> Option A

4. Quick Check:

   SUB decreases SP, ADD restores SP [OK]

Hint: SUB decreases SP (push), ADD increases SP (pop) [OK]

Common Mistakes:

• Mixing up SUB and ADD effects on SP
• Assuming SP does not change
• Thinking this causes an error

4. In ARM assembly, a programmer writes:

ADD SP, SP, #8
LDR R1, [SP, #-4]

What is the problem with this code?

medium

A. There is no problem; code works as intended.

B. The immediate value #8 is invalid for ADD instruction.

C. LDR cannot use negative offsets in ARM assembly.

D. SP is moved up before loading, causing incorrect address access.

Solution

1. Step 1: Examine ADD SP, SP, #8

   This moves SP up by 8, effectively popping 8 bytes off the stack.

2. Step 2: Analyze LDR with negative offset

   LDR R1, [SP, #-4] tries to load from SP minus 4 bytes, but since SP moved up, this address may not point to the intended data.

3. Step 3: Identify the problem

   Moving SP up before loading causes the load to access an incorrect or invalid memory location.

4. Final Answer:

   SP is moved up before loading, causing incorrect address access. -> Option D

5. Quick Check:

   SP must point correctly before LDR [OK]

Hint: Adjust SP after loading, not before, to avoid wrong addresses [OK]

Common Mistakes:

• Assuming negative offsets are invalid
• Ignoring SP movement effect on address
• Believing immediate #8 is illegal

5. You want to save registers R0 to R3 on the stack before a function call and restore them after. Which ARM assembly sequence correctly uses the stack pointer (R13/SP) to do this?

hard

A. SUB SP, SP, #4
STR R0, [SP]
STR R1, [SP, #4]
STR R2, [SP, #8]
STR R3, [SP, #12]
...function call...
LDMIA SP!, {R0-R3}

B. ADD SP, SP, #16
STR R0, [SP]
STR R1, [SP, #4]
STR R2, [SP, #8]
STR R3, [SP, #12]
...function call...
LDMFD SP!, {R0-R3}

C. SUB SP, SP, #16
STR R0, [SP]
STR R1, [SP, #4]
STR R2, [SP, #8]
STR R3, [SP, #12]
...function call...
LDMIA SP!, {R0-R3}

D. SUB SP, SP, #16
STR R0, [SP, #12]
STR R1, [SP, #8]
STR R2, [SP, #4]
STR R3, [SP]
...function call...
LDMIA SP!, {R0-R3}

Solution

1. Step 1: Allocate stack space for 4 registers

   SUB SP, SP, #16 reserves 16 bytes (4 registers x 4 bytes each) by moving SP down.

2. Step 2: Store registers in ascending order

   STR instructions store R0 at [SP], R1 at [SP+4], R2 at [SP+8], and R3 at [SP+12], matching stack layout.

3. Step 3: Restore registers after function call

   LDMIA SP!, {R0-R3} loads multiple registers and increments SP, restoring original SP value.

4. Final Answer:

   The sequence using SUB SP, SP, #16, ordered STRs, and LDMIA SP!, {R0-R3} -> Option C

5. Quick Check:

   SUB allocates, STR stores, LDMIA restores [OK]

Hint: Subtract before storing, add after loading with LDMIA SP! [OK]

Common Mistakes:

• Using ADD instead of SUB to allocate stack space
• Incorrect offsets for storing registers
• Reversing order of stored registers
• Using wrong load multiple instruction