Nested subroutine calls in ARM Architecture - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the stack behavior in nested subroutine calls

In ARM architecture, when a subroutine calls another subroutine, what happens to the return address of the first subroutine?

A It is saved directly to memory without using the stack.

B It is discarded because only the second subroutine's return address is needed.

C It is stored in a general-purpose register unrelated to the link register.

D It is stored in the link register (LR) before the second subroutine call.

💡 Hint

Think about how ARM preserves return addresses during nested calls.

In ARM, the link register (LR) holds the return address. Before calling another subroutine, the current LR is usually saved on the stack to preserve the return address of the first subroutine.

📋 Factual

intermediate

ARM instruction for nested subroutine call

Which ARM instruction is used to call a subroutine and save the return address for nested calls?

A BL (Branch with Link)

B B (Branch)

C MOV LR, PC

D PUSH {PC}

💡 Hint

Look for the instruction that branches and saves the return address automatically.

The BL instruction branches to the target address and saves the return address in the link register (LR), enabling nested subroutine calls.

🔍 Analysis

advanced

Stack frame management in nested calls

Consider a nested subroutine call sequence where Subroutine A calls Subroutine B, which calls Subroutine C. Which of the following best describes the stack frame behavior?

A Return addresses are stored in registers only; the stack is not used.

B Each subroutine pushes its return address and local variables onto the stack, creating separate stack frames.

C Only the first subroutine pushes data; others reuse the same stack frame.

D All subroutines share a single global stack frame without pushing return addresses.

💡 Hint

Think about how local variables and return addresses are preserved during nested calls.

Each subroutine creates its own stack frame by pushing return addresses and local variables onto the stack. This preserves the context for each call.

❓ Reasoning

advanced

Effect of missing stack push in nested calls

What is the likely outcome if a subroutine in a nested call sequence fails to save the link register (LR) on the stack before calling another subroutine?

A The return address of the calling subroutine is overwritten, causing incorrect return behavior.

B The called subroutine will automatically save the LR, so no problem occurs.

C The program will run normally without any issues.

D The CPU will generate an exception and halt execution.

💡 Hint

Consider what happens to the LR register during nested calls.

If the LR is not saved before a nested call, it gets overwritten by the new return address, causing the original subroutine to return to the wrong place.

❓ Comparison

expert

Comparing nested subroutine call mechanisms

Which statement correctly compares the use of the link register (LR) and the stack in managing nested subroutine calls in ARM architecture?

A The stack is never used for return addresses; LR alone manages all nested returns.

B LR is used only for the first call; subsequent calls use a dedicated return address register.

C LR holds the immediate return address, but for nested calls, return addresses are saved on the stack to preserve all return points.

D Return addresses are saved in general-purpose registers instead of LR or stack.

💡 Hint

Think about how ARM handles multiple nested calls and return addresses.

The LR holds the return address for the current subroutine. When a nested call occurs, the LR is saved on the stack to preserve the return address of the caller, allowing multiple nested returns.

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