Stack operations (PUSH, POP) in ARM Architecture - Step-by-Step Execution

Concept Flow - Stack operations (PUSH, POP)

Start

↓

Check Operation

↓

PUSH

↓

Add item

↓

Update SP

↓

End

The stack operation flow checks if the command is PUSH or POP, then adds or removes an item accordingly, updating the stack pointer (SP) each time.

Execution Sample

ARM Architecture

PUSH R0
PUSH R1
POP R2
POP R3

This sequence pushes two registers onto the stack, then pops two values back into registers.

Analysis Table

Step	Operation	SP (Stack Pointer)	Stack Content (Top to Bottom)	Action
1	PUSH R0	SP-4	[R0]	Decrement SP by 4, store R0 at SP-4
2	PUSH R1	SP-8	[R1, R0]	Decrement SP by 4, store R1 at SP-8
3	POP R2	SP-4	[R0]	Load R1 at SP-8 into R2, increment SP by 4
4	POP R3	SP	[]	Load R0 at SP-4 into R3, increment SP by 4
5	End	SP	[]	Stack empty, SP back to original position

💡 All PUSH and POP operations completed, SP restored to initial value.

State Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
SP	SP	SP-4	SP-8	SP-4	SP	SP
Stack Content	[]	[R0]	[R1, R0]	[R0]	[]	[]
R0	R0	R0	R0	R0	R0	R0
R1	R1	R1	R1	R1	R1	R1
R2	undefined	undefined	undefined	R1	R1	R1
R3	undefined	undefined	undefined	undefined	R0	R0

Key Insights - 3 Insights

Why does the SP decrease when we PUSH but increase when we POP?

Because the stack grows downward in memory on ARM, pushing means moving SP to lower addresses (SP-4), popping moves it back up (SP+4). See execution_table steps 1 and 3.

What happens to the data in the stack after a POP?

The data remains in memory but is considered invalid since SP has moved up. The next PUSH will overwrite it. See execution_table steps 3 and 4.

Why do we decrement SP first on PUSH?

On ARM, SP points to the last used location, so we decrement SP first to reserve space, then store data. This is shown in step 1 where SP moves from SP to SP-4 before storing R0.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what is the SP value?

A SP

B SP-4

C SP-8

D SP+4

💡 Hint

Check the SP column in execution_table row for step 2.

At which step does the stack become empty again?

A Step 3

B Step 4

C Step 5

D Step 2

💡 Hint

Look at the Stack Content column in execution_table to see when it is empty.

If we POP before any PUSH, what would happen to SP?

A SP increases

B SP stays the same

C SP decreases

D SP becomes zero

💡 Hint

Recall that POP increments SP by 4, so it moves up in memory.

Concept Snapshot

Stack operations in ARM:
- PUSH: decrement SP by 4, store register at SP
- POP: load from SP, increment SP by 4
- Stack grows downward in memory
- SP always points to top of stack
- PUSH adds data, POP removes data

Full Transcript

This visual execution trace shows how stack operations PUSH and POP work in ARM architecture. The stack pointer (SP) moves down by 4 bytes when pushing data onto the stack, storing the register value at the new SP address. When popping, the value at SP is loaded into a register, and SP moves up by 4 bytes. The stack grows downward in memory. The execution table tracks SP and stack content after each operation, showing how data is added and removed. Key moments clarify why SP moves this way and what happens to data after popping. The quiz tests understanding of SP changes and stack state during these operations.

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