Nested subroutine calls in ARM Architecture - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to call a subroutine named 'func1'.

ARM Architecture

[1] func1

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

ABL

BB

CBX

DMOV

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'B' instead of 'BL' which does not save the return address.

Forgetting to specify the subroutine name after the instruction.

The BL instruction is used to branch to a subroutine and link the return address.

2fill in blank

medium

Complete the code to call 'func2' from within 'func1'.

ARM Architecture

func1:
    BL [1]
    BX LR

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

Afunc2

Bmain

Cfunc3

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Calling the wrong subroutine name.

Using 'BX LR' instead of 'BL' to call the subroutine.

Inside 'func1', the subroutine 'func2' is called using the BL instruction followed by 'func2'.

3fill in blank

hard

Fix the error in the nested call where 'func3' is called incorrectly.

ARM Architecture

func2:
    BL [1]
    BX LR

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

Afunc2

Bmain

Cfunc1

Dfunc3

Attempts:

3 left

💡 Hint

Common Mistakes

Calling 'func1' or 'func2' instead of 'func3'.

Using 'BX LR' instead of 'BL' for the call.

The nested call inside 'func2' should call 'func3' using the BL instruction followed by 'func3'.

4fill in blank

hard

Fill both blanks to correctly call 'func2' and then return from 'func1'.

ARM Architecture

func1:
    [1] [2]
    BX LR

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

ABL

Bfunc2

CB

Dfunc3

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'B' instead of 'BL' for the call.

Calling the wrong subroutine name.

The instruction BL func2 calls 'func2' and saves the return address. Then BX LR returns from 'func1'.

5fill in blank

hard

Fill all three blanks to call 'func3' from 'func2' and then return properly.

ARM Architecture

func2:
    [1] [2]
    [3] LR

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

ABL

Bfunc3

CBX

Dfunc1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'B' instead of 'BL' for the call.

Calling the wrong subroutine name.

Using incorrect return instruction.

The instruction BL func3 calls 'func3' and saves the return address. Then BX LR returns from 'func2'.

Practice

1. What does a nested subroutine call mean in ARM assembly?

easy

A. A subroutine runs without calling any other subroutine

B. A subroutine calls itself repeatedly

C. One subroutine calls another subroutine inside it

D. A subroutine is called only once in the program

Solution

1. Step 1: Understand subroutine calls

   A subroutine is a small program block that can be called to perform a task.

2. Step 2: Define nested calls

   Nested calls happen when one subroutine calls another subroutine inside its code.

3. Final Answer:

   One subroutine calls another subroutine inside it -> Option C

4. Quick Check:

   Nested call = one subroutine calls another [OK]

Hint: Nested means calling a subroutine inside another [OK]

Common Mistakes:

• Confusing nested call with recursion
• Thinking subroutine runs alone without calls
• Mixing up call and return instructions

2. Which ARM instruction is used to call a subroutine?

easy

A. BX LR

B. BL

C. MOV

D. ADD

Solution

1. Step 1: Identify call instruction

   In ARM, the instruction to call a subroutine is 'BL' which means Branch with Link.

2. Step 2: Differentiate from return instruction

   'BX LR' is used to return from a subroutine, not to call it.

3. Final Answer:

   BL -> Option B

4. Quick Check:

   Call subroutine = BL instruction [OK]

Hint: BL calls subroutine; BX LR returns [OK]

Common Mistakes:

• Confusing BX LR as call instead of return
• Using MOV or ADD as call instructions
• Mixing up branch instructions without link

3. Given the following ARM assembly snippet, what is the final value in register R0 after execution?

main:
  MOV R0, #1
  BL sub1
  BX LR

sub1:
  ADD R0, R0, #2
  BL sub2
  BX LR

sub2:
  ADD R0, R0, #3
  BX LR

medium

A. 1

B. 3

C. 0

D. 6

Solution

1. Step 1: Trace main and sub1 execution

   Start with R0=1 in main. Then BL sub1 calls sub1. In sub1, R0 = 1 + 2 = 3.

2. Step 2: Trace sub1 calling sub2

   sub1 calls sub2. In sub2, R0 = 3 + 3 = 6. Then sub2 returns, sub1 returns, main returns.

3. Final Answer:

   6 -> Option D

4. Quick Check:

   1 + 2 + 3 = 6 [OK]

Hint: Add values stepwise through nested calls [OK]

Common Mistakes:

• Ignoring sub2 addition
• Not updating R0 after each call
• Confusing return with call instructions

4. Identify the error in this ARM assembly nested subroutine code:

main:
  BL sub1
  BX LR

sub1:
  ADD R0, R0, #1
  BL sub2
  BX LR

sub2:
  ADD R0, R0, #2
  BX R0

medium

A. Using BX R0 instead of BX LR to return in sub2

B. Missing MOV instruction in main

C. BL should be replaced with BX for calls

D. R0 should not be modified in subroutines

Solution

1. Step 1: Check return instructions

   Subroutines should return using 'BX LR' to jump back to caller address stored in LR.

2. Step 2: Identify incorrect return

   In sub2, 'BX R0' tries to jump to address in R0, which is incorrect and causes error.

3. Final Answer:

   Using BX R0 instead of BX LR to return in sub2 -> Option A

4. Quick Check:

   Return must use BX LR, not BX R0 [OK]

Hint: Return with BX LR, not BX R0 [OK]

Common Mistakes:

• Using BX R0 instead of BX LR
• Confusing BL and BX instructions
• Assuming R0 holds return address

5. You want to organize a complex ARM program by splitting tasks into subroutines that call each other. Which is the best practice for nested subroutine calls to avoid errors?

hard

A. Always use BL to call and BX LR to return, saving LR if calling another subroutine

B. Use BX LR to call and BL to return, no need to save LR

C. Avoid calling subroutines inside subroutines to prevent errors

D. Use MOV to jump between subroutines and ignore LR register

Solution

1. Step 1: Understand call and return instructions

   BL saves return address in LR and branches to subroutine; BX LR returns to caller.

2. Step 2: Handle nested calls safely

   If a subroutine calls another, it must save LR (e.g., on stack) before calling to avoid losing return address.

3. Final Answer:

   Always use BL to call and BX LR to return, saving LR if calling another subroutine -> Option A

4. Quick Check:

   BL call + BX LR return + save LR for nested calls [OK]

Hint: Save LR before nested BL calls, return with BX LR [OK]

Common Mistakes:

• Using BX LR to call instead of BL
• Not saving LR before nested calls
• Jumping with MOV ignoring LR