Stack operations (PUSH, POP) in ARM Architecture - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding PUSH operation in ARM

What happens to the stack pointer (SP) when the ARM instruction PUSH {R0, R1} is executed?

A SP remains unchanged and R0, R1 are stored at the current SP address

B SP decreases by 8 bytes and R0, R1 are stored at the new SP address

C SP increases by 8 bytes and R0, R1 are stored at the old SP address

D SP decreases by 4 bytes and only R0 is stored

💡 Hint

Remember that ARM stack grows downwards in memory.

In ARM, the stack grows downward. The PUSH instruction decreases the stack pointer by the total size of the registers pushed (4 bytes each). Then it stores the registers at the new SP address.

📋 Factual

intermediate

POP operation effect on registers

After executing POP {R2, R3} in ARM, what is true about R2 and R3?

A Only R2 is loaded, SP increases by 4 bytes

B R2 and R3 are loaded from the memory pointed by SP, then SP decreases by 8 bytes

C R2 and R3 remain unchanged, SP increases by 8 bytes

D R2 and R3 are loaded from the memory pointed by SP, then SP increases by 8 bytes

💡 Hint

Consider how the stack pointer moves after popping values.

The POP instruction loads registers from the memory at SP, then increments SP by the total size of the registers popped (4 bytes each).

🔍 Analysis

advanced

Stack pointer value after multiple PUSH and POP

Given SP starts at 0x1000, what is the value of SP after executing these instructions?

PUSH {R4, R5}
PUSH {R6}
POP {R5}
POP {R4, R6}

A 0x1000

B 0x1004

C 0x0FF8

D 0x0FF0

💡 Hint

Calculate SP changes step-by-step considering each PUSH decreases SP and each POP increases SP.

Each PUSH decreases SP by 4 bytes per register, each POP increases SP by 4 bytes per register. After all operations, SP returns to the original 0x1000.

❓ Comparison

advanced

Difference between PUSH and STMFD in ARM

Which statement correctly describes the difference between PUSH and STMFD SP!, {R0-R3} in ARM?

A <code>PUSH</code> stores registers in ascending order, <code>STMFD</code> in descending order

B <code>PUSH</code> stores registers without changing SP, <code>STMFD</code> changes SP

C <code>PUSH</code> is a shorthand for <code>STMFD SP!, {registers}</code> storing registers on the full descending stack

D <code>PUSH</code> only stores one register, <code>STMFD</code> stores multiple

💡 Hint

Think about how PUSH is implemented in ARM assembly.

PUSH is an alias for STMFD SP!, {registers}, which stores registers on a full descending stack and updates SP accordingly.

❓ Reasoning

expert

Identifying error in stack usage

Consider this ARM code snippet:

SUB SP, SP, #12
STR R0, [SP, #8]
STR R1, [SP, #4]
STR R2, [SP]
ADD SP, SP, #8

What is the main issue with this code regarding stack operations?

A SP is not restored correctly; it should be increased by 12, not 8

B Registers are stored in wrong order causing data corruption

C STR instructions use incorrect offsets causing memory overwrite

D SUB instruction should increase SP instead of decreasing

💡 Hint

Check how much SP was decreased and how much it is restored.

SP is decreased by 12 bytes but only increased by 8 bytes at the end, leaving SP misaligned and causing stack corruption.

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