General purpose registers (R0-R12) in ARM Architecture - Deep Dive

Overview - General purpose registers (R0-R12)

What is it?

General purpose registers R0 to R12 are a set of 13 registers in ARM processors used to hold data and addresses temporarily during program execution. They act like small, fast storage locations inside the CPU that help perform calculations and manage information quickly. Each register can store a 32-bit value, which can be a number, a memory address, or other data. These registers are essential for the CPU to work efficiently and execute instructions.

Why it matters

Without general purpose registers, the CPU would have to access slower memory every time it needs data, making programs run much slower. These registers allow the processor to keep important data close at hand, speeding up calculations and decision-making. They are the backbone of how the CPU handles tasks, so understanding them helps you grasp how computers run software smoothly and quickly.

Where it fits

Before learning about general purpose registers, you should understand basic computer architecture concepts like what a CPU and memory are. After this, you can learn about special registers, instruction sets, and how the CPU uses registers during function calls and interrupts.

Mental Model

Core Idea

General purpose registers R0 to R12 are the CPU's quick-access storage spots that hold data and addresses temporarily to speed up processing.

Think of it like...

Imagine a chef with 13 small bowls on the counter (the registers), each holding ingredients needed right now. Instead of going back to the pantry (memory) every time, the chef grabs from these bowls quickly to prepare the dish faster.

┌───────────────┐
│ General Purpose│
│ Registers R0-R12│
├───────────────┤
│ R0  │ R1  │ R2 │
│ R3  │ R4  │ R5 │
│ R6  │ R7  │ R8 │
│ R9  │ R10 │ R11│
│ R12 │           │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

What Are CPU Registers?

Concept: Registers are small storage locations inside the CPU used to hold data temporarily.

A CPU register is like a tiny, super-fast memory inside the processor. It stores data that the CPU needs immediately while running programs. Registers are faster than regular memory, so CPUs use them to speed up calculations and data handling.

Result

You understand that registers are essential for fast data access inside the CPU.

Knowing that registers are the CPU's fastest storage helps explain why they are critical for performance.

2

Foundation

Introducing ARM General Purpose Registers

Concept: ARM processors have 13 general purpose registers named R0 through R12 used for various tasks.

In ARM architecture, R0 to R12 are general purpose registers. They can hold numbers, addresses, or other data. Unlike special registers, these are flexible and used by programs to store temporary values during execution.

Result

You can identify the general purpose registers and their role in ARM CPUs.

Recognizing these registers as flexible storage spots clarifies how ARM CPUs manage data during instructions.

3

Intermediate

How Registers Store Data and Addresses

🤔Before reading on: do you think registers can only store numbers or also memory addresses? Commit to your answer.

Concept: General purpose registers can hold both data values and memory addresses, making them versatile.

Registers like R0-R12 can store any 32-bit value. This includes integers for calculations or addresses pointing to memory locations. This dual role allows the CPU to quickly access data or jump to different parts of a program.

Result

You understand that registers are not limited to one type of data but can hold anything needed for processing.

Knowing registers can hold addresses explains how CPUs efficiently manage program flow and data access.

4

Intermediate

Using Registers in Arithmetic and Logic

🤔Before reading on: do you think arithmetic operations happen directly in registers or only in memory? Commit to your answer.

Concept: Most arithmetic and logic operations in ARM happen directly using values stored in general purpose registers.

When the CPU adds, subtracts, or compares numbers, it uses the values in registers like R0-R12. This avoids slow memory access and speeds up calculations. For example, adding two numbers stored in R1 and R2 and saving the result in R0 is common.

Result

You see how registers enable fast math and logic operations inside the CPU.

Understanding that registers are the main operands for calculations reveals why they are central to CPU speed.

5

Intermediate

Register Usage in Function Calls

🤔Before reading on: do you think all registers keep their values after a function call or some get reused? Commit to your answer.

Concept: Certain registers (like R0-R3) are used to pass arguments to functions, while others may be preserved or reused.

In ARM calling conventions, R0 to R3 often hold input values for functions. When a function runs, it uses these registers to receive data quickly. Other registers like R4-R11 may be saved and restored to keep data safe across calls.

Result

You understand how registers help pass data between functions efficiently.

Knowing register roles in function calls clarifies how programs manage data flow and maintain state.

6

Advanced

Register Bank and Context Switching

🤔Before reading on: do you think registers keep their values when the CPU switches tasks or do they change? Commit to your answer.

Concept: Registers are saved and restored during context switches to allow multitasking without data loss.

When the CPU switches from one program or task to another, it saves the current register values (including R0-R12) to memory. Later, it restores them so the program can continue exactly where it left off. This process is called context switching and is vital for multitasking.

Result

You see how registers are managed to support multiple programs running seemingly at once.

Understanding context switching shows why registers must be carefully saved and restored to avoid errors.

7

Expert

Hidden Uses and Constraints of R9 and R12

🤔Before reading on: do you think all general purpose registers are equally free to use or some have special roles? Commit to your answer.

Concept: Some registers like R9 and R12 have special or platform-specific uses that can affect how programmers use them.

While R0-R8 and R10-R11 are generally free for any use, R9 is often reserved as a platform register for special purposes like thread-local storage. R12, called the Intra-Procedure-call scratch register, is used internally by some instructions and calling conventions. Misusing these can cause subtle bugs.

Result

You learn that not all general purpose registers are equally free, and some have hidden roles.

Knowing these special roles prevents bugs and helps write more reliable low-level code.

Under the Hood

Inside the ARM CPU, general purpose registers are implemented as fast flip-flop circuits that hold 32 bits each. When an instruction executes, the CPU reads values from these registers, performs operations in the Arithmetic Logic Unit (ALU), and writes results back to registers. This avoids slower memory access. The CPU pipeline and control logic manage which registers are read or written each cycle, enabling rapid instruction throughput.

Why designed this way?

ARM's design emphasizes simplicity and speed, so having 13 general purpose registers provides enough fast storage for most operations without complicating the CPU design. This balance allows efficient instruction encoding and fast execution. Alternatives with fewer registers slow down programs due to memory access, while too many registers increase hardware complexity and power use.

┌───────────────┐
│ ARM CPU Core   │
│               │
│ ┌───────────┐ │
│ │ Registers │ │
│ │ R0 - R12  │ │
│ └───────────┘ │
│       │       │
│       ▼       │
│    ALU (Math) │
│       │       │
│       ▼       │
│   Control Unit│
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think R9 is always free to use like other general purpose registers? Commit to yes or no.

Common Belief: All general purpose registers R0-R12 are equally free for any use.

Reality: R9 is often reserved for special platform-specific purposes like thread-local storage and should be used carefully.

Why it matters: Using R9 without caution can cause conflicts and bugs, especially in multi-threaded or OS-level code.

Quick: Do you think registers keep their values automatically after a function call? Commit to yes or no.

Common Belief: All registers keep their values unchanged after a function call.

Reality: Some registers are caller-saved and may be overwritten by called functions; others must be preserved by the callee.

Why it matters: Assuming registers keep values can cause data loss and unpredictable program behavior.

Quick: Do you think registers can store only numbers, not memory addresses? Commit to yes or no.

Common Belief: Registers only store numeric data, not memory addresses.

Reality: Registers can store any 32-bit value, including memory addresses used for accessing data.

Why it matters: Misunderstanding this limits comprehension of how programs manage memory and data flow.

Quick: Do you think the CPU can access data faster from memory than registers? Commit to yes or no.

Common Belief: Memory access is as fast as register access.

Reality: Registers are much faster than memory, which is why CPUs use them for immediate data storage.

Why it matters: Ignoring this leads to inefficient programming and misunderstanding CPU performance.

Expert Zone

1

R9's role varies by platform and ABI, sometimes reserved for thread-local storage or special OS functions, requiring careful use.

2

R12 is often used as a scratch register during function calls and instruction sequences, so its value can be unpredictable after certain operations.

3

Compiler optimizations heavily rely on register allocation strategies to minimize memory access and improve execution speed.

When NOT to use

General purpose registers are limited in number and volatile during function calls; for persistent data, use stack memory or dedicated special registers. For very large data, memory is necessary. Also, in some ARM modes or extensions, other registers or banked registers are preferred.

Production Patterns

In real-world ARM software, R0-R3 are used for passing function arguments and return values, R4-R11 are callee-saved registers, and R12 is a scratch register. OS kernels use R9 for thread-local storage. Compilers and assemblers follow these conventions to ensure interoperability and stability.

Connections

CPU Cache

Both registers and cache are fast storage layers but registers are inside the CPU core, while cache is a small memory outside the core.

Understanding registers helps grasp the CPU's memory hierarchy and why multiple fast storage layers exist.

Function Calling Conventions

General purpose registers are used according to calling conventions to pass data between functions.

Knowing register roles clarifies how programs communicate internally and maintain state across calls.

Human Working Memory

Registers are like the brain's working memory, holding information temporarily for immediate use.

This cross-domain link shows how temporary storage is a universal concept in processing systems.

Common Pitfalls

#1 Using R9 freely without considering platform conventions.

Wrong approach:

MOV R9, #10 ; Using R9 as a general register without reservation

Correct approach:

Use R9 only if the platform ABI allows or reserve it for special purposes; otherwise, use other registers.

Root cause:

Misunderstanding that R9 may have special reserved roles leads to conflicts and bugs.

#2 Assuming all registers keep their values after function calls.

Wrong approach:

After calling a function, using R0 without saving it first, expecting the value to remain unchanged.

Correct approach:

Save caller-saved registers before function calls if their values are needed afterward.

Root cause:

Not knowing which registers are caller-saved versus callee-saved causes data loss.

#3 Trying to store large data directly in registers.

Wrong approach:

Loading a large array or structure directly into R0-R12 registers.

Correct approach:

Store large data in memory and use registers to hold addresses or small pieces of data.

Root cause:

Registers have limited size and number; misunderstanding this leads to inefficient or impossible code.

Key Takeaways

General purpose registers R0 to R12 are fast, temporary storage inside ARM CPUs used to hold data and addresses during program execution.

These registers speed up processing by avoiding slower memory access and are central to arithmetic, logic, and function call operations.

Not all registers are equally free; some like R9 and R12 have special roles or conventions that must be respected.

Understanding how registers are saved and restored during function calls and context switches is key to writing reliable low-level code.

Registers represent a fundamental concept of temporary, fast storage that parallels ideas in other fields like human working memory.

Practice

1. Which of the following registers are considered general purpose registers in ARM architecture?

easy

A. R0 to R12

B. R13 to R15

C. Program Counter and Status Register

D. Floating Point Registers

Solution

1. Step 1: Identify general purpose registers in ARM

   Registers R0 through R12 are used for general data storage and manipulation.

2. Step 2: Differentiate special registers

   Registers R13 to R15 and others like Program Counter are special purpose, not general.

3. Final Answer:

   R0 to R12 -> Option A

4. Quick Check:

   General purpose registers = R0-R12 [OK]

Hint: General purpose registers are R0 to R12 only [OK]

Common Mistakes:

• Confusing R13-R15 as general purpose
• Including special registers like Program Counter
• Thinking floating point registers are general purpose

2. Which of the following is the correct way to refer to the 5th general purpose register in ARM assembly?

easy

A. R6

B. R5

C. R4

D. R7

Solution

1. Step 1: Understand register numbering

   Registers start at R0, so the 1st is R0, 2nd is R1, and so on.

2. Step 2: Count to the 5th register

   Counting from R0: R0(1), R1(2), R2(3), R3(4), R4(5). So the 5th register is R4.

3. Step 3: Verify options

   R5 is R5, which is actually the 6th register, so the correct is R4 (R4).

4. Final Answer:

   R4 -> Option C

5. Quick Check:

   5th register = R4 [OK]

Hint: Count from R0 to find the register number [OK]

Common Mistakes:

• Starting count from R1 instead of R0
• Mixing register numbers with their positions
• Choosing R5 thinking it is the 5th register

3. Given the ARM assembly instructions:
MOV R0, #10
ADD R1, R0, #5
SUB R2, R1, R0
What is the final value stored in register R2?

medium

A. 5

B. 15

C. 10

D. 0

Solution

1. Step 1: Execute MOV and ADD instructions

   MOV R0, #10 sets R0 = 10. ADD R1, R0, #5 sets R1 = 10 + 5 = 15.

2. Step 2: Execute SUB instruction

   SUB R2, R1, R0 sets R2 = 15 - 10 = 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   R2 = R1 - R0 = 15 - 10 = 5 [OK]

Hint: Calculate step-by-step register values [OK]

Common Mistakes:

• Mixing up source and destination registers
• Forgetting immediate values in ADD
• Assuming R2 equals R1 or R0 directly

4. Identify the error in the following ARM assembly snippet:
MOV R13, #20
ADD R0, R13, #5
What is the issue?

medium

A. ADD instruction requires three registers, not two registers and an immediate

B. Immediate value #5 is invalid

C. MOV instruction cannot move immediate values

D. R13 is not a general purpose register and should not be used like this

Solution

1. Step 1: Check register usage

   R13 is the stack pointer, a special purpose register, not general purpose.

2. Step 2: Validate instruction correctness

   Using R13 like a general purpose register is incorrect; MOV and ADD with immediate values are valid.

3. Final Answer:

   R13 is not a general purpose register and should not be used like this -> Option D

4. Quick Check:

   R13 is special purpose, not general [OK]

Hint: Remember R13-R15 are special, not general registers [OK]

Common Mistakes:

• Assuming R13 is general purpose
• Thinking immediate values are invalid
• Believing ADD can't use immediate values

5. You want to swap the values of registers R2 and R3 using only R0 as a temporary register. Which sequence of instructions correctly achieves this?

hard

A. MOV R2, R3MOV R3, R2MOV R0, R2

B. MOV R0, R2MOV R2, R3MOV R3, R0

C. MOV R0, R3MOV R3, R2MOV R3, R0

D. MOV R0, R2MOV R3, R2MOV R2, R0

Solution

1. Step 1: Save R2 value temporarily

   MOV R0, R2 stores R2's value in R0 to keep it safe.

2. Step 2: Move R3 value to R2

   MOV R2, R3 copies R3's value into R2, overwriting original R2.

3. Step 3: Restore original R2 value to R3

   MOV R3, R0 moves saved R2 value from R0 into R3, completing the swap.

4. Final Answer:

   MOV R0, R2; MOV R2, R3; MOV R3, R0 -> Option B

5. Quick Check:

   Use temp register R0 to swap R2 and R3 [OK]

Hint: Use R0 as temp: save R2, copy R3 to R2, restore R2 to R3 [OK]

Common Mistakes:

• Overwriting R2 before saving it
• Swapping without a temporary register
• Mixing source and destination registers