Addressing modes (immediate, register, offset) in ARM Architecture - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to use the immediate addressing mode to load the value 5 into register R0.

ARM Architecture

MOV R0, #[1]

Drag options to blanks, or click blank then click option'

A5

BR1

C[R2]

D#R3

Attempts:

3 left

💡 Hint

Common Mistakes

Using a register name instead of an immediate value.

Omitting the '#' symbol before the number.

The immediate addressing mode uses a '#' followed by a constant value. Here, #5 loads the value 5 directly into R0.

2fill in blank

medium

Complete the code to move the value from register R1 into register R0 using register addressing mode.

ARM Architecture

MOV R0, [1]

Drag options to blanks, or click blank then click option'

A#R0

B#5

C[R1]

DR1

Attempts:

3 left

💡 Hint

Common Mistakes

Using immediate mode syntax with '#' instead of register name.

Using brackets which indicate memory access.

Register addressing mode uses the register name directly without '#' or brackets. Here, R1 moves the value from R1 to R0.

3fill in blank

hard

Fix the error in the code to correctly load the value from memory at an offset of 4 from register R2 into R0.

ARM Architecture

LDR R0, [R2[1]]

Drag options to blanks, or click blank then click option'

A, 4

B, #4

C#4

D4

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the comma between register and offset.

Not using '#' before the offset number.

Placing the offset outside the brackets.

In ARM offset addressing, the offset is specified with a comma and a '#' before the number inside the brackets. So, [R2, #4] correctly accesses memory at R2 plus 4 bytes.

4fill in blank

hard

Fill both blanks to create a store instruction that saves the value in R0 to the memory address at R3 plus an immediate offset of 8.

ARM Architecture

STR R0, [[1][2]]

Drag options to blanks, or click blank then click option'

AR3

B#8

C, #8

DR0

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting the comma before the offset.

Using the wrong register or immediate value.

The correct syntax for offset addressing in store instructions is STR R0, [R3, #8]. The comma separates the base register and the immediate offset.

5fill in blank

hard

Fill all three blanks to create a load instruction that loads into R1 the value from the memory address at R4 plus an offset stored in register R5.

ARM Architecture

LDR [1], [[2], [3]]

Drag options to blanks, or click blank then click option'

AR1

BR4

CR5

DR0

Attempts:

3 left

💡 Hint

Common Mistakes

Using immediate offset syntax instead of register offset.

Mixing up the order of registers inside the brackets.

This uses register offset addressing mode. The instruction LDR R1, [R4, R5] loads the value from the address computed by adding R4 and R5 into R1.

Practice

1. Which addressing mode uses a fixed number directly inside the instruction to provide data?

easy

A. Immediate addressing mode

B. Register addressing mode

C. Offset addressing mode

D. Indirect addressing mode

Solution

1. Step 1: Understand immediate addressing mode

   Immediate mode means the instruction contains the actual number (constant) to use.

2. Step 2: Compare with other modes

   Register mode uses CPU registers, offset mode calculates address by adding offset to a register, indirect mode uses memory address stored in a register.

3. Final Answer:

   Immediate addressing mode -> Option A

4. Quick Check:

   Fixed number inside instruction = Immediate mode [OK]

Hint: Immediate mode has the number right inside the instruction [OK]

Common Mistakes:

• Confusing immediate with register mode
• Thinking offset mode uses fixed numbers directly
• Mixing indirect addressing with immediate

2. Which of the following is the correct syntax for using register addressing mode in ARM assembly to move data from register R1 to R0?

easy

A. MOV R0, [R1]

B. MOV R0, #R1

C. MOV R0, R1

D. MOV [R0], R1

Solution

1. Step 1: Understand register addressing syntax

   Register addressing uses register names directly without # or brackets.

2. Step 2: Analyze options

   MOV R0, R1 uses MOV R0, R1 which copies data from R1 to R0 correctly. MOV R0, #R1 wrongly uses # which means immediate. MOV R0, [R1] uses brackets which means memory access. MOV [R0], R1 tries to move to memory location incorrectly.

3. Final Answer:

   MOV R0, R1 -> Option C

4. Quick Check:

   Register names without # or [] = Register mode [OK]

Hint: Register mode uses register names directly, no # or brackets [OK]

Common Mistakes:

• Using # before register name
• Using brackets [] for register mode
• Confusing immediate and register syntax

3. Given the ARM instruction LDR R2, [R3, #4], what does this instruction do?

medium

A. Loads the immediate value 4 into R2

B. Loads the value from memory address in R3 plus 4 into R2

C. Moves the value from R3 to R2

D. Stores the value of R2 into memory address R3 plus 4

Solution

1. Step 1: Identify addressing mode in LDR instruction

   The syntax [R3, #4] means offset addressing mode: base register R3 plus immediate offset 4.

2. Step 2: Understand LDR operation

   LDR loads data from memory address calculated by R3 + 4 into register R2.

3. Final Answer:

   Loads the value from memory address in R3 plus 4 into R2 -> Option B

4. Quick Check:

   Offset mode loads from (R3 + 4) into R2 [OK]

Hint: Brackets with # offset means load from memory address plus offset [OK]

Common Mistakes:

• Thinking #4 is immediate load into R2
• Confusing load with store instruction
• Ignoring the offset in brackets

4. Identify the error in this ARM instruction using addressing modes: ADD R1, R2, #R3

medium

A. Incorrect use of # before register R3

B. Missing brackets around R3

C. Wrong destination register

D. Immediate value cannot be used with ADD

Solution

1. Step 1: Analyze the use of # in ARM instructions

   The # symbol is used only before immediate (constant) values, not registers.

2. Step 2: Check the instruction syntax

   Here #R3 is invalid because R3 is a register, not an immediate value. Correct syntax is ADD R1, R2, R3 without #.

3. Final Answer:

   Incorrect use of # before register R3 -> Option A

4. Quick Check:

   # only for constants, not registers [OK]

Hint: # is only for numbers, never before register names [OK]

Common Mistakes:

• Using # before register names
• Adding brackets unnecessarily
• Confusing immediate and register operands

5. You want to load a value from memory address calculated by adding 8 to the value in register R4, then add an immediate value 5 to it and store in R0. Which sequence of ARM instructions correctly uses addressing modes?

hard

A. LDR R1, [R4, R5]
ADD R0, R1, #8

B. LDR R0, [R4, #5]
ADD R0, R0, #8

C. LDR R0, [R4]
ADD R0, R0, R5

D. LDR R1, [R4, #8]
ADD R0, R1, #5

Solution

1. Step 1: Load from memory address R4 + 8

   Use offset addressing mode: LDR R1, [R4, #8] loads from address R4 + 8 into R1.

2. Step 2: Add immediate 5 to loaded value

   ADD R0, R1, #5 adds immediate 5 to R1 and stores result in R0.

3. Final Answer:

   LDR R1, [R4, #8] ADD R0, R1, #5 -> Option D

4. Quick Check:

   Offset load then immediate add = LDR R1, [R4, #8] ADD R0, R1, #5 [OK]

Hint: Load with offset first, then add immediate value [OK]

Common Mistakes:

• Mixing immediate and offset values incorrectly
• Using register instead of immediate for offset
• Loading directly into R0 then adding wrong offset