Why subroutines enable modular assembly code in ARM Architecture - Why It Works This Way

Overview - Why subroutines enable modular assembly code

What is it?

Subroutines are small, reusable blocks of assembly code that perform specific tasks. They allow programmers to write a piece of code once and call it whenever needed, instead of repeating the same instructions multiple times. This makes assembly programs easier to organize and maintain. Using subroutines helps break down complex programs into manageable parts.

Why it matters

Without subroutines, assembly code would be long, repetitive, and hard to understand or fix. Every time a task needed to be done, the same instructions would have to be copied, increasing errors and making changes difficult. Subroutines solve this by enabling code reuse and clearer structure, which saves time and reduces mistakes in programming.

Where it fits

Before learning about subroutines, you should understand basic assembly instructions and how the processor executes them. After mastering subroutines, you can learn about advanced topics like parameter passing, stack management, and interrupt handling in ARM assembly.

Mental Model

Core Idea

Subroutines let you package a set of instructions into a named block that can be reused anywhere, making assembly code modular and easier to manage.

Think of it like...

Using subroutines in assembly is like having a recipe card for a dish you cook often; instead of writing the whole recipe every time, you just refer to the card whenever you want to make that dish.

Main Program
  │
  ├─ Call Subroutine A ──▶ [Subroutine A: Task 1]
  │                       │
  ├─ Call Subroutine B ──▶ [Subroutine B: Task 2]
  │                       │
  └─ Continue Main Program

Each subroutine is a reusable block called from the main program.

Build-Up - 7 Steps

1

Foundation

Understanding Basic Assembly Instructions

Concept: Learn what assembly instructions are and how they execute sequentially.

Assembly language consists of simple instructions like moving data, arithmetic operations, and jumps. The processor executes these instructions one by one in order. Without any structure, the code is just a long list of commands.

Result

You can write simple programs that perform tasks step-by-step but with no reuse or organization.

Knowing how instructions run sequentially is essential before introducing ways to organize and reuse code.

2

Foundation

Introducing Code Repetition Problems

Concept: Recognize the problem of repeating the same instructions multiple times.

If a task needs to be done several times in a program, writing the same instructions repeatedly makes the code longer and harder to maintain. For example, adding two numbers in multiple places requires copying the same instructions each time.

Result

Programs become bulky and error-prone because changes must be made in many places.

Understanding repetition problems motivates the need for reusable code blocks.

3

Intermediate

What Are Subroutines in Assembly?

Concept: Learn that subroutines are named blocks of code that can be called from different places.

A subroutine is a section of assembly code with a label. The main program can jump to this label to execute the subroutine and then return to continue. This avoids repeating code and helps organize the program.

Result

You can write a task once and call it whenever needed, reducing code size and improving clarity.

Knowing that subroutines enable code reuse is key to modular programming in assembly.

4

Intermediate

How Subroutines Are Called and Returned

🤔Before reading on: do you think the program continues immediately after a subroutine call or waits until the subroutine finishes? Commit to your answer.

Concept: Understand the call and return mechanism using special instructions.

In ARM assembly, the 'BL' (Branch with Link) instruction calls a subroutine by jumping to its address and saving the return address in a register. The subroutine ends with a 'BX LR' instruction that returns control to the saved address, resuming the main program.

Result

The program temporarily jumps to the subroutine and then comes back to where it left off.

Understanding call and return instructions explains how subroutines fit seamlessly into program flow.

5

Intermediate

Passing Data to Subroutines

🤔Before reading on: do you think subroutines can access variables directly or need data passed explicitly? Commit to your answer.

Concept: Learn how data is passed to and from subroutines using registers or memory.

Subroutines receive input values through registers (like R0-R3 in ARM) or memory locations. They perform operations using these inputs and return results in registers. This allows subroutines to work with different data each time they are called.

Result

Subroutines become flexible and reusable for various inputs.

Knowing data passing methods is essential for writing useful and adaptable subroutines.

6

Advanced

Stack Usage in Subroutine Calls

🤔Before reading on: do you think subroutines always use the stack or only sometimes? Commit to your answer.

Concept: Understand how the stack stores return addresses and local data during nested calls.

When subroutines call other subroutines, the return addresses and sometimes local variables are saved on the stack to avoid overwriting. The stack is a special memory area that works like a stack of plates, allowing last-in, first-out storage and retrieval.

Result

Programs can have multiple nested subroutine calls without losing track of where to return.

Understanding stack management prevents bugs in complex programs with many subroutine calls.

7

Expert

Modularity Benefits and Compiler Support

🤔Before reading on: do you think subroutines only help humans or also tools like compilers? Commit to your answer.

Concept: Explore how subroutines enable modular design and how compilers optimize their use.

Subroutines allow programmers to divide programs into modules that can be developed and tested independently. Compilers use subroutines to generate efficient code, inline small functions, and manage resources. This modularity improves maintainability, debugging, and collaboration.

Result

Assembly programs become scalable and easier to evolve over time.

Knowing the broader impact of subroutines on software engineering reveals their critical role beyond simple code reuse.

Under the Hood

Subroutines work by saving the return address in a special register (link register in ARM) when called, then jumping to the subroutine's code. The subroutine executes its instructions and uses a return instruction to jump back to the saved address. When nested calls occur, the return addresses are pushed onto the stack to preserve the correct return points. Registers are used to pass parameters and return values, while the stack manages local variables and saved states.

Why designed this way?

This design balances simplicity and efficiency. Using a link register avoids memory access for simple calls, speeding up execution. The stack allows nested calls without losing return points. Alternatives like fixed memory locations for return addresses were slower and less flexible. This approach evolved from early processor designs to support structured programming in low-level code.

Main Program
  │
  ├─ BL Subroutine (save return addr in LR)
  │       │
  │       ├─ Execute Subroutine Code
  │       ├─ Use BX LR to return
  │       │
  └─ Resume Main Program

Nested Calls:
  ┌─────────────┐
  │ Return Addr │ ← Push on Stack
  ├─────────────┤
  │ Return Addr │ ← Push on Stack
  └─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do subroutines automatically save all registers before returning? Commit to yes or no.

Common Belief: Subroutines save all registers automatically, so you don't need to worry about preserving data.

Reality: Subroutines only save registers if the programmer explicitly writes code to do so. The caller or callee must follow conventions to save and restore registers to avoid data loss.

Why it matters: Failing to save registers can cause unexpected bugs where data changes unexpectedly after subroutine calls.

Quick: Can subroutines be called without using the stack? Commit to yes or no.

Common Belief: All subroutine calls must use the stack to save return addresses.

Reality: Simple subroutine calls use the link register to save return addresses without stack use. The stack is only needed for nested or complex calls.

Why it matters: Misunderstanding this can lead to inefficient code or incorrect stack management.

Quick: Do subroutines always make programs run slower? Commit to yes or no.

Common Belief: Using subroutines slows down programs because of extra jumps and returns.

Reality: While subroutines add some overhead, they improve code clarity and maintainability. Compilers can optimize calls, and modular code often runs faster overall due to fewer bugs and easier improvements.

Why it matters: Avoiding subroutines to save time can lead to complex, error-prone code that is harder to optimize.

Quick: Are subroutines only useful for large programs? Commit to yes or no.

Common Belief: Subroutines are only necessary in big programs with many instructions.

Reality: Even small programs benefit from subroutines by organizing code and enabling reuse, making development and debugging easier.

Why it matters: Ignoring subroutines in small projects can cause unnecessary complexity and duplication.

Expert Zone

1

Some ARM calling conventions specify which registers must be preserved by the callee and which by the caller, requiring careful coordination.

2

Inlining small subroutines can improve performance but reduces modularity and increases code size, so trade-offs must be considered.

3

Stack alignment is critical in ARM architecture to avoid faults; subroutines must maintain proper alignment when pushing/popping data.

When NOT to use

Subroutines are less suitable for extremely time-critical inner loops where the overhead of calls is too costly; in such cases, inline code or macros are preferred. Also, in very simple scripts or one-off tasks, subroutines may add unnecessary complexity.

Production Patterns

In real ARM assembly projects, subroutines are used to implement hardware drivers, math libraries, and system calls. Modular design allows teams to develop and test components independently. Compilers generate subroutine calls for functions, and hand-optimized assembly often uses subroutines for repeated tasks like context switching.

Connections

Functions in High-Level Programming

Subroutines in assembly are the low-level equivalent of functions in languages like C or Python.

Understanding subroutines clarifies how high-level functions work under the hood, bridging low-level and high-level programming concepts.

Stack Data Structure

Subroutine calls use the stack to save return addresses and local data.

Knowing how stacks operate helps understand how nested subroutine calls maintain correct program flow.

Modular Design in Engineering

Subroutines enable modularity in software similar to how modular parts simplify complex machines.

Recognizing modularity across fields shows how breaking complex systems into parts improves manageability and scalability.

Common Pitfalls

#1 Not saving registers that a subroutine modifies.

Wrong approach:

Subroutine:
MOV R0, #5
ADD R1, R1, R0
BX LR

Correct approach:

Subroutine:
PUSH {R1}
MOV R0, #5
ADD R1, R1, R0
POP {R1}
BX LR

Root cause:

Assuming subroutines do not need to preserve registers leads to overwriting important data.

#2 Forgetting to return to the caller after subroutine execution.

Wrong approach:

Subroutine:
MOV R0, #10
B EndLabel

Correct approach:

Subroutine:
MOV R0, #10
BX LR

Root cause:

Using a branch instruction instead of return causes the program to jump incorrectly, breaking flow.

#3 Passing parameters incorrectly by not following calling conventions.

Wrong approach:

Main:
MOV R4, #3
BL Subroutine

Subroutine:
ADD R0, R0, R4
BX LR

Correct approach:

Main:
MOV R0, #3
BL Subroutine

Subroutine:
ADD R0, R0, #0
BX LR

Root cause:

Misunderstanding which registers hold parameters causes subroutines to use wrong data.

Key Takeaways

Subroutines package assembly instructions into reusable blocks, enabling modular and maintainable code.

They work by saving the return address and jumping to the subroutine, then returning control after execution.

Passing data through registers and managing the stack allows flexible and nested subroutine calls.

Proper register saving and calling conventions are essential to avoid bugs in subroutine usage.

Subroutines form the foundation for structured programming and modular design in low-level ARM assembly.