Parameter passing in registers in ARM Architecture - Step-by-Step Execution

Concept Flow - Parameter passing in registers

Function Call

↓

Place Arguments in Registers

↓

Jump to Function

↓

Function Uses Registers to Access Parameters

↓

Function Executes

↓

Return Value in Register

↓

Caller Continues

When a function is called, its input values (parameters) are placed into specific CPU registers. The function then reads these registers to get its inputs and returns the result in a register.

Execution Sample

ARM Architecture

int add(int a, int b) {
  return a + b;
}

// Caller:
int result = add(3, 5);

This code calls a function 'add' with two numbers, which are passed via registers, and returns their sum in a register.

Analysis Table

Step	Action	Register State (r0, r1, r2...)	Description
1	Caller prepares arguments	r0=3, r1=5	First argument 3 in r0, second argument 5 in r1
2	Call function 'add'	r0=3, r1=5	Jump to function with arguments in registers
3	Function reads parameters	r0=3, r1=5	Function accesses a=3 from r0, b=5 from r1
4	Function computes sum	r0=3, r1=5	Calculate 3 + 5 = 8
5	Function places result in r0	r0=8, r1=5	Return value 8 stored in r0
6	Return to caller	r0=8, r1=5	Caller receives result in r0
7	Caller stores result	r0=8	Result 8 saved in variable 'result'
8	End	r0=8	Function call complete

💡 Function returns after placing result in r0, caller continues execution

State Tracker

Variable/Register	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	Final
r0 (arg1/result)	undefined	3	3	3	3	8	8	8
r1 (arg2)	undefined	5	5	5	5	5	5	5
result (caller variable)	undefined	undefined	undefined	undefined	undefined	undefined	undefined	8

Key Insights - 3 Insights

Why are the first two arguments placed in registers r0 and r1?

In ARM calling conventions, the first four arguments are passed in registers r0 to r3 to speed up function calls by avoiding memory access. This is shown in execution_table rows 1 and 2.

How does the function return the result to the caller?

The function places the return value in register r0 before returning, as seen in execution_table row 5. The caller then reads r0 to get the result.

What happens if there are more than four parameters?

Only the first four parameters go into registers r0 to r3; additional parameters are passed on the stack (not shown here). This example shows just two parameters in registers.

Visual Quiz - 3 Questions

Look at the execution_table at Step 3. What values do registers r0 and r1 hold?

A r0=0, r1=0

B r0=8, r1=5

C r0=3, r1=5

D r0=5, r1=3

💡 Hint

Check the 'Register State' column at Step 3 in the execution_table.

At which step does the function place the result into register r0?

A Step 2

B Step 5

C Step 4

D Step 7

💡 Hint

Look for the step where 'Function places result in r0' in the execution_table.

If the caller passed 10 and 20 instead of 3 and 5, what would r0 be after Step 5?

A 30

B 15

C 10

D 20

💡 Hint

Recall that the function adds the two arguments and returns the sum in r0.

Concept Snapshot

Parameter passing in registers:
- First 4 function arguments go into registers r0 to r3.
- Function reads parameters directly from these registers.
- Return value is placed in r0.
- This speeds up calls by avoiding memory.
- Extra arguments use the stack.

Full Transcript

When a function is called in ARM architecture, the first four parameters are placed into registers r0 through r3. The function accesses these registers to read its input values. After computing, the function places the return value in register r0. The caller then reads r0 to get the result. This method avoids slower memory access and makes function calls faster. If there are more than four parameters, the extra ones are passed on the stack, but this example shows only two parameters passed in registers.

Practice

1. In ARM architecture, which registers are primarily used to pass the first four function parameters?

easy

A. r8 to r11

B. r4 to r7

C. r0 to r3

D. r12 to r15

Solution

1. Step 1: Understand ARM calling convention basics

   ARM uses registers r0 to r3 to pass the first four parameters to functions for speed.

2. Step 2: Identify correct register range

   Registers r0, r1, r2, and r3 are used, not the higher registers.

3. Final Answer:

   r0 to r3 -> Option C

4. Quick Check:

   First four parameters = r0 to r3 [OK]

Hint: Remember first four params go in r0-r3 registers [OK]

Common Mistakes:

• Confusing r4-r7 as parameter registers
• Thinking all parameters fit in registers
• Assuming stack is always used for parameters

2. Which of the following is the correct syntax to pass five parameters to a function in ARM, considering register usage?

easy

A. First four in r0-r3, fifth on stack

B. All five in r0-r4

C. All five on stack

D. First three in r0-r2, last two in r3-r4

Solution

1. Step 1: Recall register parameter limits

   Only the first four parameters fit in registers r0 to r3.

2. Step 2: Understand handling of extra parameters

   Any parameter beyond the fourth is passed on the stack.

3. Final Answer:

   First four in r0-r3, fifth on stack -> Option A

4. Quick Check:

   5th parameter goes on stack [OK]

Hint: Only 4 params in registers; extras go to stack [OK]

Common Mistakes:

• Assuming registers can hold more than 4 parameters
• Passing all parameters on stack unnecessarily
• Misplacing parameters in wrong registers

3. Consider a function call in ARM with six integer parameters. Which registers and memory locations hold these parameters?

medium

A. r0, r1 hold first two; r2 to r5 hold next four

B. r0, r1, r2, r3 hold first four; stack holds 5th and 6th

C. Stack holds all six parameters

D. r0 to r5 hold all six parameters

Solution

1. Step 1: Identify register usage for parameters

   ARM passes first four parameters in r0 to r3 registers.

2. Step 2: Determine location for extra parameters

   Parameters beyond the fourth (5th and 6th) are passed on the stack.

3. Final Answer:

   r0, r1, r2, r3 hold first four; stack holds 5th and 6th -> Option B

4. Quick Check:

   Extra params after 4th go to stack [OK]

Hint: First 4 params in r0-r3; rest on stack [OK]

Common Mistakes:

• Assuming registers beyond r3 hold parameters
• Ignoring stack usage for extra parameters
• Mixing register order

4. A programmer passes seven parameters to a function in ARM but notices incorrect values for the last three parameters inside the function. What is the most likely cause?

medium

A. Registers r4 to r6 should be used for last three parameters

B. All parameters must be passed in registers; stack is never used

C. Parameters beyond four are ignored by ARM

D. Only first four parameters are passed in registers; last three must be on stack but were not

Solution

1. Step 1: Recall ARM parameter passing rules

   Only the first four parameters are passed in registers r0 to r3.

2. Step 2: Identify cause of incorrect values

   If last three parameters are not placed on the stack properly, their values will be incorrect inside the function.

3. Final Answer:

   Only first four parameters are passed in registers; last three must be on stack but were not -> Option D

4. Quick Check:

   Extra params must be on stack [OK]

Hint: Extra params need stack space; missing stack causes errors [OK]

Common Mistakes:

• Assuming all params fit in registers
• Using wrong registers for extra params
• Ignoring stack for extra parameters

5. You need to optimize a function call in ARM that takes eight parameters. How should you arrange parameter passing to maximize speed and follow ARM conventions?

hard

A. Pass first four parameters in r0-r3 registers; place remaining four on the stack

B. Pass all eight parameters on the stack to keep registers free

C. Pass first six parameters in r0-r5 registers; last two on stack

D. Pass first two parameters in r0-r1; remaining six on stack

Solution

1. Step 1: Understand ARM calling convention for parameters

   ARM passes up to four parameters in registers r0 to r3 for speed.

2. Step 2: Arrange remaining parameters

   Parameters beyond the fourth must be passed on the stack as per convention.

3. Step 3: Apply to eight parameters

   First four go in r0-r3; last four go on the stack to maximize speed and follow rules.

4. Final Answer:

   Pass first four parameters in r0-r3 registers; place remaining four on the stack -> Option A

5. Quick Check:

   4 in registers + rest on stack = fastest [OK]

Hint: Use r0-r3 for first 4 params; stack for others [OK]

Common Mistakes:

• Trying to pass more than 4 params in registers
• Passing all params on stack unnecessarily
• Ignoring ARM calling convention rules