What is the difference between the ADD and ADDU instructions in MIPS

What is the difference between the ADD and ADDU instructions in MIPS?
A. ADD checks for overflow, while ADDU does not.
B. There is no difference between ADD and ADDU.
C. ADDU is used for signed arithmetic, while ADD is used for unsigned arit
D. ADDU checks for overflow, while ADD does not.

The Correct Answer and Explanation is :

The correct answer is A. ADD checks for overflow, while ADDU does not.

Explanation:

In MIPS, the ADD and ADDU instructions are both used for addition, but they differ in how they handle overflow conditions.

1. ADD Instruction:

• ADD performs signed integer addition.
• It checks for overflow during the addition. This means that if the result exceeds the representable range for a signed 32-bit integer (i.e., if the result is larger than 2^31 – 1 or smaller than -2^31), it will trigger an exception (overflow error).
• In other words, ADD will not allow arithmetic overflow for signed integers. If overflow occurs, the system will respond by signaling an error. Example:

   ADD $t0, $t1, $t2  # Adds contents of registers $t1 and $t2 and stores the result in $t0

If the sum of $t1 and $t2 exceeds the signed 32-bit integer limit, an overflow will occur.

2. ADDU Instruction:

• ADDU is used for unsigned integer addition.
• It does not check for overflow. If the result exceeds the range of an unsigned 32-bit integer (0 to 2^32 – 1), the result simply wraps around (i.e., it doesn’t throw an exception).
• This means that ADDU is used when the values involved are not expected to cause signed overflow issues. It can still wrap around on large sums without causing the program to halt. Example:

   ADDU $t0, $t1, $t2  # Adds contents of registers $t1 and $t2 and stores the result in $t0

Why the difference exists:

• The ADD instruction is primarily used when dealing with signed integers, where overflow detection is critical to avoid invalid computations or incorrect program behavior.
• The ADDU instruction is used for unsigned integers, where overflow detection isn’t necessary, and wraparound behavior is acceptable (such as when working with binary data or large non-negative numbers).

This distinction helps MIPS programmers manage arithmetic operations in a way that is appropriate for their data types, whether they are signed or unsigned integers.