Saturating arithmetic instructions in ARM Architecture - Step-by-Step Execution

Concept Flow - Saturating arithmetic instructions

Start with two numbers

↓

Add or subtract numbers

↓

Check if result > max limit

↓

Set result = max

↓

Set result = min

↓

Output result

The instruction adds or subtracts two numbers, then checks if the result exceeds the allowed range. If it does, it sets the result to the maximum or minimum limit instead of wrapping around.

Execution Sample

ARM Architecture

ADD.SAT R0, R1, R2
// R0 = R1 + R2 with saturation

SUB.SAT R3, R4, R5
// R3 = R4 - R5 with saturation

These instructions add or subtract two registers and store the result in a third register, but if the result goes beyond the allowed range, it is set to the closest limit instead of overflowing.

Analysis Table

Step	Operation	Operands	Raw Result	Check Saturation	Final Result
1	ADD.SAT	R1=200, R2=100	300	300 > 255? Yes	255 (max limit)
2	ADD.SAT	R1=50, R2=30	80	80 > 255? No	80
3	SUB.SAT	R4=50, R5=100	-50	-50 < 0? Yes	0 (min limit)
4	SUB.SAT	R4=150, R5=50	100	100 < 0? No	100
5	END	-	-	-	-

💡 Execution stops after processing all operations with saturation checks.

State Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
R0	undefined	255	255	255	255	255
R3	undefined	undefined	undefined	0	100	100

Key Insights - 2 Insights

Why does the result not wrap around when it exceeds the maximum limit?

Because saturating instructions check if the result is greater than the max limit and set it to that max instead of letting it overflow, as shown in execution_table step 1.

What happens if the subtraction result is negative?

The instruction sets the result to the minimum limit (usually zero) instead of wrapping to a large positive number, as seen in execution_table step 3.

Visual Quiz - 3 Questions

Look at the execution table, what is the final value of R0 after step 1?

A 0

B 300

C 255

D 200

💡 Hint

Check the 'Final Result' column in row for step 1.

At which step does the subtraction result become saturated to the minimum limit?

A Step 2

B Step 3

C Step 4

D Step 1

💡 Hint

Look at the 'Check Saturation' and 'Final Result' columns for subtraction operations.

If R1 was 100 and R2 was 50 in step 1, what would the final result be?

A 150

B 255

C 100

D 50

💡 Hint

Refer to how addition and saturation work in the execution_table steps 1 and 2.

Concept Snapshot

Saturating arithmetic instructions add or subtract numbers.
If the result exceeds max or min limits, it is set to those limits.
This prevents overflow or underflow wrap-around.
Used in ARM to safely handle fixed-size data.
Syntax example: ADD.SAT R0, R1, R2

Full Transcript

Saturating arithmetic instructions in ARM add or subtract two numbers and then check if the result goes beyond the allowed range. If it does, instead of wrapping around like normal arithmetic, the result is set to the maximum or minimum limit. For example, adding 200 and 100 normally gives 300, but if the max allowed is 255, the result becomes 255. Similarly, subtracting 100 from 50 would normally give -50, but with saturation, it becomes 0. This helps avoid errors caused by overflow or underflow in fixed-size registers. The instructions are written like ADD.SAT or SUB.SAT followed by the registers involved.

Practice

1. What is the main purpose of saturating arithmetic instructions like QADD and QSUB in ARM architecture?

easy

A. To convert numbers between different bases

B. To perform floating-point calculations

C. To speed up multiplication operations

D. To keep numbers within fixed limits and avoid overflow or underflow

Solution

1. Step 1: Understand saturating arithmetic concept

   Saturating arithmetic limits the result to a maximum or minimum value instead of wrapping around.

2. Step 2: Identify the role of QADD and QSUB

   QADD and QSUB perform addition and subtraction with saturation to prevent overflow or underflow errors.

3. Final Answer:

   To keep numbers within fixed limits and avoid overflow or underflow -> Option D

4. Quick Check:

   Saturating arithmetic = Keep numbers within limits [OK]

Hint: Saturating means stopping at limits, not wrapping around [OK]

Common Mistakes:

• Confusing saturating with normal addition
• Thinking it speeds up multiplication
• Assuming it changes number bases

2. Which of the following is the correct syntax for the ARM instruction that adds two registers with saturation?

easy

A. ADDQ Rd, Rn, Rm

B. QADD Rd, Rn, Rm

C. QSUB Rd, Rn, Rm

D. ADDS Rd, Rn, Rm

Solution

1. Step 1: Recall ARM saturating addition syntax

   The correct instruction for saturating addition is QADD followed by destination and source registers.

2. Step 2: Compare options

   QADD Rd, Rn, Rm matches the correct syntax: QADD Rd, Rn, Rm. Others are either incorrect or different instructions.

3. Final Answer:

   QADD Rd, Rn, Rm -> Option B

4. Quick Check:

   QADD syntax = QADD Rd, Rn, Rm [OK]

Hint: QADD means saturating add; syntax is QADD Rd, Rn, Rm [OK]

Common Mistakes:

• Mixing QADD with ADDQ
• Confusing QSUB with QADD
• Using ADDS which is not saturating

3. Consider the following ARM assembly code snippet:

  MOV R0, #2147483647  ; Max positive 32-bit int
  MOV R1, #1
  QADD R2, R0, R1

What will be the value in register R2 after execution?

medium

A. 2147483648

B. -2147483648

C. 2147483647

D. 0

Solution

1. Step 1: Understand the initial values

   R0 holds the maximum 32-bit signed integer (2147483647), R1 holds 1.

2. Step 2: Apply QADD saturating addition

   Adding 2147483647 + 1 would overflow normal int, but QADD saturates at max value 2147483647.

3. Final Answer:

   2147483647 -> Option C

4. Quick Check:

   QADD saturates at max int = 2147483647 [OK]

Hint: QADD stops at max int, no overflow wrap-around [OK]

Common Mistakes:

• Assuming normal addition overflow
• Thinking result wraps to negative
• Confusing QADD with normal ADD

4. Identify the error in this ARM assembly code using saturating subtraction:

  MOV R0, #-2147483648  ; Min signed 32-bit int
  MOV R1, #1
  QSUB R2, R0, R1

What is the problem?

medium

A. No error; QSUB saturates and sets R2 to minimum value

B. QSUB will cause underflow and crash the processor

C. QSUB does not exist in ARM instruction set

D. MOV instructions are invalid for immediate values

Solution

1. Step 1: Check instruction validity

   QSUB is a valid ARM instruction for saturating subtraction.

2. Step 2: Understand saturating subtraction behavior

   Subtracting 1 from -2147483648 would underflow in normal arithmetic, but QSUB saturates at minimum signed int (-2147483648).

3. Final Answer:

   No error; QSUB saturates and sets R2 to minimum value -> Option A

4. Quick Check:

   QSUB saturates at min int, no crash [OK]

Hint: QSUB saturates at min int, no crash or error [OK]

Common Mistakes:

• Thinking QSUB causes processor crash
• Believing QSUB is invalid instruction
• Assuming MOV can't load immediate values

5. You want to safely add two signed 16-bit numbers in ARM assembly without overflow. Which approach correctly uses saturating arithmetic to achieve this?

hard

A. Use QADD16 instruction to add two 16-bit values with saturation

B. Use QADD instruction after sign-extending 16-bit numbers to 32-bit

C. Use normal ADD instruction and check overflow flag manually

D. Use QSUB instruction to add the numbers

Solution

1. Step 1: Understand 16-bit addition with saturation

   QADD16 performs two parallel 16-bit saturating additions on the low and high halves of the registers.

2. Step 2: Identify correct saturating addition for two 16-bit numbers

   Place the numbers in the low halves of source registers and use QADD16 Rd, Rn, Rm for saturation to 16-bit range.

3. Step 3: Evaluate other options

   Sign-extending to 32-bit then QADD saturates to 32-bit limits (e.g., 32767+32767=65534, not 32767). Normal ADD does not saturate; QSUB is subtraction.

4. Final Answer:

   Use QADD16 instruction to add two 16-bit values with saturation -> Option A

5. Quick Check:

   QADD16 = 16-bit lane saturating add [OK]

Hint: QADD16 for 16-bit saturating adds [OK]

Common Mistakes:

• Using QADD on sign-extended values (saturates to 32-bit range)
• Using normal ADD with manual overflow check
• Using QSUB for addition