Stack operations (PUSH, POP) in ARM Architecture

Introduction

A stack is a simple way to store data where you add or remove items in a last-in, first-out order. PUSH adds data to the stack, and POP removes data from it.

When you need to remember the order of tasks and go back step-by-step, like undo in apps.

When calling functions in a program, to save where to return after the function finishes.

When temporarily storing data during calculations or processing.

When managing memory in low-level programming like ARM assembly.

When you want to reverse the order of items easily.

Core Concept

ARM Architecture

PUSH {register_list}
POP {register_list}

PUSH saves the values of the listed registers onto the stack.

POP restores the values from the stack back into the listed registers.

Key Points

Push and pop a single register r0.

ARM Architecture

PUSH {r0}
POP {r0}

Push multiple registers and pop them in reverse order to restore correctly.

ARM Architecture

PUSH {r0, r1, r2}
POP {r2, r1, r0}

Push the link register (return address) and pop it into the program counter to return from a function.

ARM Architecture

PUSH {lr}
POP {pc}

Edge case: empty register list does nothing; stack remains unchanged.

ARM Architecture

PUSH {}
POP {}

Detailed Explanation

This ARM assembly program shows how to use PUSH and POP to save and restore register values. First, it sets r0 and r1 to 10 and 20. Then it pushes these registers onto the stack to save them. After changing r0 and r1 to zero, it pops the saved values back, restoring the original numbers.

ARM Architecture

    AREA StackExample, CODE, READONLY
    ENTRY

start
    MOV r0, #10          ; Load 10 into r0
    MOV r1, #20          ; Load 20 into r1

    ; Show initial values
    ; (In real ARM, printing requires OS calls; here we comment for clarity)

    PUSH {r0, r1}        ; Save r0 and r1 on stack

    MOV r0, #0           ; Change r0
    MOV r1, #0           ; Change r1

    ; Values changed to zero

    POP {r1, r0}         ; Restore r1 and r0 from stack

    ; Now r0=10 and r1=20 again

    END

Important Notes

Time complexity: Both PUSH and POP run in constant time, O(1), because they operate on fixed registers.

Space complexity: PUSH increases stack size by the number of registers saved; POP decreases it accordingly.

Common mistake: Popping registers in a different order than pushed can cause wrong values to be restored.

Use PUSH and POP to save registers before a function call and restore them after to keep data safe.

Summary

PUSH adds register values to the stack to save them.

POP removes values from the stack and restores them to registers.

Always pop registers in reverse order of push to keep data correct.

Practice

1. What does the PUSH instruction do in ARM architecture stack operations?

easy

A. It adds registers to the stack by decreasing the stack pointer.

B. It removes registers from the stack by increasing the stack pointer.

C. It clears the stack completely.

D. It duplicates the top value of the stack.

Solution

1. Step 1: Understand the role of PUSH

   PUSH adds data to the stack, which means it stores registers by moving the stack pointer downwards.

2. Step 2: Compare with POP

   POP removes data by moving the stack pointer upwards, opposite to PUSH.

3. Final Answer:

   It adds registers to the stack by decreasing the stack pointer. -> Option A

4. Quick Check:

   PUSH = add to stack [OK]

Hint: PUSH means add data, stack pointer moves down [OK]

Common Mistakes:

• Confusing PUSH with POP
• Thinking PUSH increases stack pointer
• Assuming PUSH clears the stack

2. Which of the following is the correct syntax to push registers R0 and R1 onto the stack in ARM assembly?

easy

A. PUSH [R0, R1]

B. PUSH (R0, R1)

C. PUSH {R0, R1}

D. PUSH R0 R1

Solution

1. Step 1: Recall ARM PUSH syntax

   ARM uses curly braces to list registers for PUSH, like PUSH {R0, R1}.

2. Step 2: Identify incorrect syntax

   Parentheses, spaces without braces, or square brackets are not valid for PUSH in ARM.

3. Final Answer:

   PUSH {R0, R1} -> Option C

4. Quick Check:

   Curly braces list registers in PUSH [OK]

Hint: Use curly braces {} to list registers in PUSH [OK]

Common Mistakes:

• Using parentheses instead of braces
• Listing registers without any brackets
• Using square brackets which are invalid

3. Given the following ARM instructions:
SUB SP, SP, #8
PUSH {R4, R5}
POP {R6, R7}
What happens to the stack pointer (SP) after these operations?

medium

A. SP decreases by 8, then decreases by 8, then increases by 8

B. SP decreases by 8, then increases by 8, then decreases by 8

C. SP decreases by 8, then decreases by 8, then increases by 16

D. SP decreases by 8, then decreases again by 8, then increases by 8

Solution

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

   This subtracts 8 from SP, moving it down by 8 bytes.

2. Step 2: Understand PUSH {R4, R5}

   PUSH stores two registers, so SP decreases by another 8 bytes (4 bytes each register).

3. Step 3: Understand POP {R6, R7}

   POP removes two registers, so SP increases by 8 bytes.

4. Final Answer:

   SP decreases by 8, then decreases by 8, then increases by 8 -> Option A

5. Quick Check:

   SP moves down for SUB and PUSH, up for POP [OK]

Hint: PUSH decreases SP, POP increases SP by register size times count [OK]

Common Mistakes:

• Forgetting SUB changes SP before PUSH
• Assuming POP decreases SP
• Miscounting bytes per register

4. Identify the error in this ARM assembly snippet:
PUSH R0, R1
POP {R2, R3}

medium

A. PUSH cannot push more than one register at a time.

B. PUSH syntax is incorrect; registers must be in braces.

C. POP syntax is incorrect; registers must be in parentheses.

D. POP cannot pop into different registers.

Solution

1. Step 1: Check PUSH syntax

   PUSH requires registers to be enclosed in curly braces, so PUSH R0, R1 is invalid.

2. Step 2: Check POP syntax

   POP syntax with curly braces is correct, so POP {R2, R3} is valid.

3. Final Answer:

   PUSH syntax is incorrect; registers must be in braces. -> Option B

4. Quick Check:

   PUSH needs braces { } [OK]

Hint: Always use braces {} for multiple registers in PUSH/POP [OK]

Common Mistakes:

• Using commas without braces in PUSH
• Confusing parentheses with braces
• Thinking POP cannot pop multiple registers

5. You want to save registers R0, R1, and R2 on the stack, then restore them later. Which sequence correctly uses PUSH and POP to do this without corrupting the stack?

hard

A. PUSH {R2, R1, R0}...POP {R0, R1, R2}

B. PUSH {R0, R1, R2}...POP {R0, R1, R2}

C. PUSH {R0, R1, R2}...POP {R1, R2, R0}

D. PUSH {R0, R1, R2}...POP {R2, R1, R0}

Solution

1. Step 1: Understand stack order with PUSH

   PUSH stores registers in order: R0, then R1, then R2, with R2 at the lowest address.

2. Step 2: POP must restore in reverse order

   POP restores registers in reverse order of PUSH to correctly restore the original values.

3. Step 3: Check options

   PUSH {R0, R1, R2}
   ...
   POP {R2, R1, R0} pops in reverse order as pushed, preserving correct values.

4. Final Answer:

   PUSH {R0, R1, R2} ... POP {R2, R1, R0} -> Option D

5. Quick Check:

   POP order is reverse of PUSH order to restore correctly [OK]

Hint: POP registers in reverse order of PUSH to restore correctly [OK]

Common Mistakes:

• Reversing POP order incorrectly
• Changing register order between PUSH and POP
• Assuming POP order does not matter