Compare and branch patterns in ARM Architecture - Step-by-Step Execution

Concept Flow - Compare and branch patterns

Start

↓

Compare Registers

↓

Set Condition Flags

↓

Evaluate Condition

Yes | No↓

Branch Taken

↓

Execute Branch Target

↓

End

The CPU compares values, sets flags, then decides to branch or continue based on conditions.

Execution Sample

ARM Architecture

CMP R0, R1
BEQ label
; next instructions
label: NOP

Compare R0 and R1; if equal, branch to label; otherwise continue.

Analysis Table

Step	Instruction	Operation	Condition Flags	Branch Taken	Next PC
1	CMP R0, R1	Compare R0 and R1	Z=0 (not equal)	No	PC+4
2	BEQ label	Check Z flag	Z=0	No	PC+4
3	Next instruction	Execute sequentially	-	No	PC+8
4	label: NOP	No operation	-	N/A	PC+12

💡 Branch not taken because Z flag is 0 (R0 != R1)

State Tracker

Variable	Start	After CMP	After BEQ	Final
R0	5	5	5	5
R1	3	3	3	3
Z flag	?	0	0	0
PC	1000	1004	1008	1012

Key Insights - 3 Insights

Why does the branch not happen even though there is a BEQ instruction?

Because the CMP sets the zero flag (Z) to 0 since R0 and R1 are not equal, so the BEQ condition is false (see execution_table step 2).

What does the CMP instruction actually do?

CMP subtracts the second register from the first and sets condition flags but does not store the result (see execution_table step 1).

How does the CPU decide where to go next after a compare and branch?

It checks the condition flags set by CMP and if the branch condition matches, it jumps to the label; otherwise, it continues sequentially (see execution_table steps 2 and 3).

Visual Quiz - 3 Questions

Look at the execution_table at step 1, what is the zero flag (Z) value after CMP?

A 1

B 0

C Undefined

D Not set

💡 Hint

Check the 'Condition Flags' column in execution_table row 1.

At which step does the CPU decide not to branch?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Branch Taken' column in execution_table row 2.

If R0 and R1 were equal, how would the 'Branch Taken' value change at step 2?

A Undefined

B No

C Yes

D Depends on PC

💡 Hint

BEQ branches if zero flag is 1, see execution_table step 2 logic.

Concept Snapshot

CMP compares two registers and sets flags.
BEQ branches if zero flag is set.
CPU checks flags after CMP to decide branch.
If condition false, execution continues sequentially.
Branch changes program counter to target label.

Full Transcript

In ARM assembly, compare and branch patterns work by first comparing two registers using the CMP instruction. CMP subtracts one register from another and sets condition flags like the zero flag (Z) based on the result. Then, a branch instruction like BEQ checks these flags. If the zero flag is set (meaning the compared values are equal), the branch is taken and the program counter jumps to the label. Otherwise, execution continues to the next instruction. This flow ensures decisions in code based on comparisons.

Practice

1. What is the main purpose of the CMP instruction in ARM assembly?

easy

A. To jump to a different part of the program unconditionally

B. To compare two values and set condition flags

C. To add two numbers and store the result

D. To load a value from memory into a register

Solution

1. Step 1: Understand the role of CMP

   The CMP instruction compares two values by subtracting one from the other without storing the result, but it sets flags based on the outcome.

2. Step 2: Identify what CMP affects

   These flags are then used by conditional branch instructions to decide program flow.

3. Final Answer:

   To compare two values and set condition flags -> Option B

4. Quick Check:

   CMP sets flags for branching decisions [OK]

Hint: CMP sets flags after comparing values for branching [OK]

Common Mistakes:

• Thinking CMP jumps directly
• Confusing CMP with arithmetic instructions
• Assuming CMP stores the subtraction result

2. Which of the following is the correct syntax for a conditional branch in ARM assembly that jumps if two values are equal?

easy

A. BGT label

B. BNE label

C. BEQ label

D. BLT label

Solution

1. Step 1: Recall condition codes for branching

   BEQ stands for 'Branch if Equal', which means it jumps if the zero flag is set after a CMP instruction.

2. Step 2: Match condition with instruction

   BNE means 'Branch if Not Equal', BGT is 'Branch if Greater Than', and BLT is 'Branch if Less Than'. Only BEQ matches the condition for equality.

3. Final Answer:

   BEQ label -> Option C

4. Quick Check:

   BEQ jumps when values are equal [OK]

Hint: BEQ means branch if equal (zero flag set) [OK]

Common Mistakes:

• Using BNE instead of BEQ for equality
• Confusing greater than and equal conditions
• Forgetting to use CMP before branch

3. Given the following ARM assembly code snippet, what will be the value in register r2 after execution?

CMP r0, r1
BEQ equal_label
MOV r2, #0
B end_label
equal_label:
MOV r2, #1
end_label:

Assume r0 = 5 and r1 = 5.

medium

A. Undefined

B. 0

C. 5

D. 1

Solution

1. Step 1: Analyze the CMP and BEQ instructions

   CMP compares r0 and r1. Since both are 5, they are equal, so the zero flag is set. BEQ will branch to equal_label.

2. Step 2: Follow the branch and MOV instructions

   The code jumps to equal_label and executes MOV r2, #1, setting r2 to 1. The instructions after BEQ are skipped.

3. Final Answer:

   1 -> Option D

4. Quick Check:

   Equal values cause BEQ to set r2 to 1 [OK]

Hint: If CMP finds equal, BEQ jumps to set r2=1 [OK]

Common Mistakes:

• Ignoring the branch and setting r2 to 0
• Confusing BEQ with BNE
• Assuming MOV after BEQ always runs

4. Identify the error in this ARM assembly snippet:

CMP r3, r4
BGT greater_label
MOV r5, #10
greater_label:
MOV r5, #20

What is the problem?

medium

A. Missing unconditional branch to skip MOV after BGT

B. CMP instruction is incorrect

C. MOV instructions use wrong registers

D. BGT should be BGE for correct branching

Solution

1. Step 1: Understand the flow of conditional branch

   BGT branches to greater_label if r3 > r4. If not, execution continues to MOV r5, #10.

2. Step 2: Identify missing jump to skip unwanted instruction

   After executing MOV r5, #10, the code falls through to greater_label and executes MOV r5, #20, overwriting the previous value. To avoid this, an unconditional branch is needed after MOV r5, #10.

3. Final Answer:

   Missing unconditional branch to skip MOV after BGT -> Option A

4. Quick Check:

   Need unconditional branch to prevent fall-through [OK]

Hint: Add unconditional branch after conditional MOV to avoid fall-through [OK]

Common Mistakes:

• Thinking CMP is wrong
• Assuming MOV instructions are incorrect
• Confusing BGT with BGE

5. You want to write ARM assembly code that sets r0 to 1 if r1 is less than r2, and to 0 otherwise. Which sequence correctly implements this using compare and branch patterns?

hard

A. CMP r1, r2
BLT set_one
MOV r0, #0
B end
set_one:
MOV r0, #1
end:

B. CMP r1, r2
BGT set_one
MOV r0, #0
B end
set_one:
MOV r0, #1
end:

C. CMP r2, r1
BLT set_one
MOV r0, #0
B end
set_one:
MOV r0, #1
end:

D. CMP r1, r2
BEQ set_one
MOV r0, #0
B end
set_one:
MOV r0, #1
end:

Solution

1. Step 1: Understand the comparison needed

   We want to check if r1 < r2. The CMP instruction compares r1 and r2, setting flags accordingly.

2. Step 2: Use the correct branch condition

   BLT (Branch if Less Than) jumps if r1 < r2. If true, branch to set_one to set r0 to 1. Otherwise, set r0 to 0.

3. Step 3: Confirm the flow

   If BLT is taken, r0 = 1; else r0 = 0. The unconditional branch after MOV r0, #0 skips the set_one label to avoid overwriting.

4. Final Answer:

   CMP r1, r2 BLT set_one MOV r0, #0 B end set_one: MOV r0, #1 end: -> Option A

5. Quick Check:

   Use CMP + BLT for less than check [OK]

Hint: Use CMP then BLT to branch if less, else set zero [OK]

Common Mistakes:

• Swapping operands in CMP
• Using BGT instead of BLT
• Forgetting unconditional branch after MOV 0