Compare and branch patterns in ARM Architecture - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding ARM Compare and Branch Instructions

In ARM assembly, compare and branch instructions are used to control program flow based on conditions. Which of the following best describes the purpose of the CBZ instruction?

A It compares a register to zero and branches if the register is zero.

B It compares two registers and branches if they are equal.

C It compares a register to zero and branches if the register is not zero.

D It unconditionally branches to a label.

💡 Hint

Think about what the abbreviation CBZ stands for.

CBZ stands for Compare and Branch on Zero. It checks if a register's value is zero and branches if true.

📋 Factual

intermediate

ARM Branch Instruction Condition Codes

Which ARM condition code suffix causes a branch if the previous comparison found the values to be not equal?

A NE

B EQ

C GT

D LT

💡 Hint

Recall that NE stands for 'Not Equal'.

The NE condition code means 'Not Equal' and causes a branch if the compared values differ.

🚀 Application

advanced

Predicting Branch Outcome from ARM Code

Given the following ARM assembly snippet, what will be the value of register R2 after execution if R1 contains 0?

    CMP R1, #0
    BNE skip
    MOV R2, #1
skip:
    MOV R2, #2

A 0

B 1

C Undefined

D 2

💡 Hint

Consider what the BNE instruction does when R1 is zero.

CMP R1, #0 sets flags comparing R1 to zero. Since R1 is zero, the zero flag is set. BNE branches if not equal (zero flag clear), so it does not branch. The instruction MOV R2, #1 executes, then MOV R2, #2 executes unconditionally, so final R2 is 2.

🔍 Analysis

advanced

Identifying Error in ARM Compare and Branch Sequence

Examine the following ARM code snippet. What error will occur when this code runs?

    CMP R0, R1
    BEQ label
    MOV R2, #5
label:
    MOV R2, #10

A Logical error: MOV R2, #5 is always skipped.

B No error; R2 will be 10 regardless of comparison.

C Runtime error because label is undefined.

D Syntax error due to missing colon after label.

💡 Hint

Check the label syntax and branching logic carefully.

The label syntax is correct with a colon. The branch BEQ jumps to label if R0 equals R1, skipping MOV R2, #5. Otherwise, MOV R2, #5 runs followed by MOV R2, #10. No syntax or runtime error occurs.

❓ Reasoning

expert

Choosing the Correct Branch Instruction for a Condition

You want to branch to done only if the value in R3 is less than the value in R4. Which ARM instruction should you use immediately after CMP R3, R4?

A BLE done

B BGT done

C BLT done

D BNE done

💡 Hint

Remember that BLT means 'Branch if Less Than'.

After CMP R3, R4, BLT branches if R3 is less than R4. Other options check different conditions.

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