- 2-1 Manipulating Rightmost Bits
- 2-2 Addition Combined with Logical Operations
- 2-3 Inequalities among Logical and Arithmetic Expressions
- 2-4 Absolute Value Function
- 2-5 Average of Two Integers
- 2-6 Sign Extension
- 2-7 Shift Right Signed from Unsigned
- 2-8 Sign Function
- 2-9 Three-Valued Compare Function
- 2-10 Transfer of Sign Function
- 2-11 Decoding a "Zero Means 2 **n" Field
- 2-12 Comparison Predicates
- 2-13 Overflow Detection
- 2-14 Condition Code Result of Add, Subtract, and Multiply
- 2-15 Rotate Shifts
- 2-16 Double-Length Add/Subtract
- 2-17 Double-Length Shifts
- 2-18 Multibyte Add, Subtract, Absolute Value
- 2-19 Doz, Max, Min
- 2-20 Exchanging Registers
- 2-21 Alternating among Two or More Values
- 2-22 A Boolean Decomposition Formula
- 2-23 Implementing Instructions for All 16 Binary Boolean Operations

## 2–13 Overflow Detection

“Overflow” means that the result of an arithmetic operation is too large or too small to be correctly represented in the target register. This section discusses methods that a programmer might use to detect when overflow has occurred, without using the machine’s “status bits” that are often supplied expressly for this purpose. This is important, because some machines do not have such status bits (e.g., MIPS), and even if the machine is so equipped, it is often difficult or impossible to access the bits from a high-level language.

### Signed Add/Subtract

When overflow occurs on integer addition and subtraction, contemporary machines invariably discard the high-order bit of the result and store the low-order bits that the adder naturally produces. Signed integer overflow of addition occurs if and only if the operands have the same sign and the sum has a sign opposite to that of the operands. Surprisingly, this same rule applies even if there is a carry into the adder—that is, if the calculation is ** x** +

**+ 1. This is important for the application of adding multiword signed integers, in which the last addition is a signed addition of two fullwords and a carry-in that may be 0 or +1.**

*y*To prove the rule for addition, let *x* and *y* denote the values of the one-word signed integers being added, let *c* (carry-in) be 0 or 1, and assume for simplicity a 4-bit machine. Then if the signs of *x* and *y* are different,

or similar bounds apply if *x* is nonnegative and *y* is negative. In either case, by adding these inequalities and optionally adding in 1 for *c*,

–8 ≤ *x* + *y* + *c* ≤ 7.

This is representable as a 4-bit signed integer, and thus overflow does not occur when the operands have opposite signs.

Now suppose *x* and *y* have the same sign. There are two cases:

Thus,

Overflow occurs if the sum is not representable as a 4-bit signed integer—that is, if

In case (a), this is equivalent to the high-order bit of the 4-bit sum being 0, which is opposite to the sign of ** x** and

**. In case (b), this is equivalent to the high-order bit of the 4-bit sum being 1, which again is opposite to the sign of**

*y***and**

*x***.**

*y*For subtraction of multiword integers, the computation of interest is ** x** −

**−**

*y***, where again**

*c***is**

*c***0**or

**1**, with a value of

**1**representing a borrow-in. From an analysis similar to the above, it can be seen that overflow in the final value of

**−**

*x***−**

*y***occurs if and only if**

*c***and**

*x***have opposite signs and the sign of**

*y***−**

*x***−**

*y***is opposite to that of**

*c***(or, equivalently, the same as that of**

*x***).**

*y*This leads to the following expressions for the overflow predicate, with the result being in the sign position. Following these with a *shift right* or *shift right signed* of 31 produces a 1/0- or a −1/0-valued result.

By choosing the second alternative in the first column, and the first alternative in the second column (avoiding the *equivalence* operation), our basic RISC can evaluate these tests with three instructions in addition to those required to compute ** x + y + c** or

**−**

*x***−**

*y***. A fourth instruction (**

*c**branch if negative*) can be added to branch to code where the overflow condition is handled.

If executing with overflow interrupts enabled, the programmer may wish to test to see if a certain addition or subtraction will cause overflow, in a way that does not cause it. One branch-free way to do this is as follows:

The assignment to ** z** in the left column sets

**=**

*z***0x80000000**if

**and**

*x***have the same sign, and sets**

*y***=**

*z***0**if they differ. Then, the addition in the second expression is done with

**and**

*x*⊕*z***having different signs, so it can’t overflow. If**

*y***and**

*x***are nonnegative, the sign bit in the second expression will be 1 if and only if (**

*y***−**

*x***2**) +

^{31}**+**

*y***—that is, iff**

*c*≥ 0*x*+

*y*+

*c*≥ 2

^{31}, which is the condition for overflow in evaluating

**+**

*x***+**

*y***. If**

*c***and**

*x***are negative, the sign bit in the second expression will be 1 iff (**

*y***+**

*x***2**) +

^{31}**+**

*y***<**

*c***0**—that is, iff

*x*+

*y*+

*c*< −2

^{31}, which again is the condition for overflow. The

*and*with

**ensures the correct result (0 in the sign position) if**

*z***and**

*x***have opposite signs. Similar remarks apply to the case of subtraction (right column). The code executes in nine instructions on the basic RISC.**

*y*It might seem that if the carry from addition is readily available, this might help in computing the signed overflow predicate. This does not seem to be the case; however, one method along these lines is as follows.

If ** x** is a signed integer, then

**+**

*x***2**is correctly represented as an unsigned number and is obtained by inverting the high-order bit of

^{31}**. Signed overflow in the positive direction occurs if**

*x**x*+

*y*≥ 2

^{31}—that is, if (

*x*+ 2

^{31}) + (

*y*+ 2

^{31}) ≥ 3 · 2

^{31}. This latter condition is characterized by carry occurring in the unsigned add (which means that the sum is greater than or equal to 2

^{32}) and the high-order bit of the sum being 1. Similarly, overflow in the negative direction occurs if the carry is 0 and the high-order bit of the sum is also 0.

This gives the following algorithm for detecting overflow for signed addition:

- Compute (
) + (*x*⊕ 2^{31}), giving sum*y*⊕ 2^{31}and carry*s**c*. - Overflow occurred iff
*c*equals the high-order bit of.*s*

The sum is the correct sum for the signed addition, because inverting the high-order bits of both operands does not change their sum.

For subtraction, the algorithm is the same except that in the first step a subtraction replaces the addition. We assume that the carry is that which is generated by computing ** x** −

**as**

*y***+ + 1. The subtraction is the correct difference for the signed subtraction.**

*x*These formulas are perhaps interesting, but on most machines they would not be quite as efficient as the formulas that do not even use the carry bit (e.g., overflow = (** x** ≡

**)& (**

*y***⊕**

*s***) for addition, and (**

*x***⊕**

*x***) &(**

*y***⊕**

*d***) for subtraction, where**

*x***and**

*s***are the sum and difference, respectively, of**

*d***and**

*x***).**

*y*### How the Computer Sets Overflow for Signed Add/Subtract

Machines often set “overflow” for signed addition by means of the logic “the carry into the sign position is not equal to the carry out of the sign position.” Curiously, this logic gives the correct overflow indication for both addition and subtraction, assuming the subtraction ** x** −

**is done by**

*y***+ + 1. Furthermore, it is correct whether or not there is a carry- or borrow-in. This does not seem to lead to any particularly good methods for computing the signed overflow predicate in software, however, even though it is easy to compute the carry into the sign position. For addition and subtraction, the carry/borrow into the sign position is given by the sign bit after evaluating the following expressions (where**

*x***is**

*c***0**or

**1**):

In fact, these expressions give, at each position *i*, the carry/borrow into position *i*.

### Unsigned Add/Subtract

The following branch-free code can be used to compute the overflow predicate for unsigned add/subtract, with the result being in the sign position. The expressions involving a right shift are probably useful only when it is known that ** c** =

**0**. The expressions in brackets compute the carry or borrow generated from the least significant position.

For unsigned *add*’s and *subtract*’s, there are much simpler formulas in terms of comparisons [MIPS]. For unsigned addition, overflow (carry) occurs if the sum is less (by unsigned comparison) than either of the operands. This and similar formulas are given below. Unfortunately, there is no way in these formulas to allow for a variable ** c** that represents the carry- or borrow-in. Instead, the program must test

**, and use a different type of comparison depending upon whether**

*c***is**

*c***0**or

**1**.

The first formula for each case above is evaluated before the add/subtract that may overflow, and it provides a way to do the test without causing overflow. The second formula for each case is evaluated after the add/subtract that may overflow.

There does not seem to be a similar simple device (using comparisons) for computing the signed overflow predicate.

### Multiplication

For multiplication, overflow means that the result cannot be expressed in 32 bits (it can always be expressed in 64 bits, whether signed or unsigned). Checking for overflow is simple if you have access to the high-order 32 bits of the product. Let us denote the two halves of the 64-bit product by hi(** x × y**) and lo(

**). Then the overflow predicates can be computed as follows [MIPS]:**

*x*×*y*One way to check for overflow of multiplication is to do the multiplication and then check the result by dividing. Care must be taken not to divide by 0, and there is a further complication for signed multiplication. Overflow occurs if the following expressions are **true**:

The complication arises when ** x** = −

**2**and

^{31}**= −**

*y***1**. In this case the multiplication overflows, but the machine may very well give a result of −

**2**. This causes the division to overflow, and thus any result is possible (for some machines). Therefore, this case has to be checked separately, which is done by the term

^{31}**<**

*y***0**&

**= −**

*x***2**. The above expressions use the “conditional

^{31}*and*” operator to prevent dividing by 0 (in C, use the

`&&`operator).

It is also possible to use division to check for overflow of multiplication without doing the multiplication (that is, without causing overflow). For unsigned integers, the product overflows iff *xy* > 2^{32} − 1, or *x* > ((2^{32} − 1)/*y*), or, since *x* is an integer, *x* > ⌊(2^{32} − 1)/*y*⌋. Expressed in computer arithmetic, this is

For signed integers, the determination of overflow of ** x** *

**is not so simple. If**

*y***and**

*x***have the same sign, then overflow occurs iff**

*y**xy*>2

^{31}− 1. If they have opposite signs, then overflow occurs iff

*xy*< −2

^{31}. These conditions can be tested as indicated in Table 2–2, which employs signed division. This test is awkward to implement, because of the four cases. It is difficult to unify the expressions very much because of problems with overflow and with not being able to represent the number +2

^{31}.

The test can be simplified if unsigned division is available. We can use the absolute values of ** x** and

**, which are correctly represented under unsigned integer interpretation. The complete test can then be computed as shown below. The variable**

*y***=**

*c***2**−

^{31}**1**if

**and**

*x***have the same sign, and**

*y***=**

*c***2**otherwise.

^{31}#### Table 2-2. Overflow Test For Signed Multiplication

The *number of leading zeros* instruction can be used to give an estimate of whether or not ** x** *

**will overflow, and the estimate can be refined to give an accurate determination. First, consider the multiplication of unsigned numbers. It is easy to show that if**

*y***and**

*x***, as 32-bit quantities, have**

*y**m*and

*n*leading 0’s, respectively, then the 64-bit product has either

*m*+

*n*or

*m*+

*n*+ 1 leading 0’s (or 64, if either

**=**

*x***0**or

**=**

*y***0**). Overflow occurs if the 64-bit product has fewer than 32 leading 0’s. Hence,

nlz() + nlz(x) ≥ 32: Multiplication definitely does not overflow. nlz(y) + nlz(x) ≤ 30: Multiplication definitely does overflow.y

For nlz(** x**) + nlz(

**) = 31, overflow may or may not occur. In this case, the overflow assessment can be made by evaluating**

*y**t*=

*x*⌊

*y*/2⌋. This will not overflow. Since

*xy*is 2

*t*or, if

*y*is odd, 2

*t*+

*x*, the product

*xy*overflows if

*t*≥ 2

^{31}. These considerations lead to a plan for computing

*xy*, but branching to “overflow” if the product overflows. This plan is shown in Figure 2–2.

For the multiplication of signed integers, we can make a partial determination of whether or not overflow occurs from the number of leading 0’s of nonnegative arguments, and the number of leading 1’s of negative arguments. Let

Figure 2-2. Determination of overflow of unsigned multiplication.

Then, we have

+m≥n34: Multiplication definitely does not overflow.+m≤n31: Multiplication definitely does overflow.

There are two ambiguous cases: 32 and 33. The case *m* + *n* = 33 overflows only when both arguments are negative and the true product is exactly 2^{31} (machine result is −2^{31}), so it can be recognized by a test that the product has the correct sign (that is, overflow occurred if ** m** ⊕

**⊕ (**

*n******

*m***) <**

*n***0**). When

*m*+

*n*= 32, the distinction is not so easily made.

We will not dwell on this further, except to note that an overflow estimate for signed multiplication can also be made based on nlz(abs(** x**)) + nlz(abs(

**)), but again there are two ambiguous cases (a sum of 31 or 32).**

*y*### Division

For the signed division ** x** ÷

**, overflow occurs if the following expression is**

*y***true**:

** y** =

**0**| (

**=**

*x***0x80000000**&

**= −**

*y***1**)

Most machines signal overflow (or trap) for the indeterminate form **0 ÷ 0**.

Straightforward code for evaluating this expression, including a final branch to the overflow handling code, consists of seven instructions, three of which are branches. There do not seem to be any particularly good tricks to improve on this, but here are a few possibilities:

[abs(j ⊕ **0x80000000**) | (abs(** x**) &abs(

**=**

*y***0x80000000**)) <

**0**

That is, evaluate the large expression in brackets, and branch if the result is less than 0. This executes in about nine instructions, counting the load of the constant and the final branch, on a machine that has the indicated instructions and that gets the “compare to 0” for free.

Some other possibilities are to first compute ** z** from

** z** ← (

**⊕**

*x***0x80000000**) | (

**+**

*y***1**)

(three instructions on many machines), and then do the test and branch on ** y** =

**0**|

**=**

*z***0**in one of the following ways:

These execute in nine, seven, and eight instructions, respectively, on a machine that has the indicated instructions. The last line represents a good method for PowerPC.

For the unsigned division , overflow occurs if and only if ** y** =

**0**.

Some machines have a “long division” instruction (see page 192), and you may want to predict, using elementary instructions, when it would overflow. We will discuss this in terms of an instruction that divides a doubleword by a fullword, producing a fullword quotient and possibly also a fullword remainder.

Such an instruction overflows if either the divisor is 0 or if the quotient cannot be represented in 32 bits. Typically, in these overflow cases both the quotient and remainder are incorrect. The remainder cannot overflow in the sense of being too large to represent in 32 bits (it is less than the divisor in magnitude), so the test that the remainder will be correct is the same as the test that the quotient will be correct.

We assume the machine either has 64-bit general registers or 32-bit registers and there is no problem doing elementary operations (shifts, adds, and so forth) on 64-bit quantities. For example, the compiler might implement a doubleword integer data type.

In the unsigned case the test is trivial: for ** x** ÷

**with**

*y***a doubleword and**

*x***a fullword, the division will not overflow if (and only if) either of the following equivalent expressions is true.**

*y*On a 32-bit machine, the shifts need not be done; simply compare ** y** to the register that contains the high-order half of

**. To ensure correct results on a 64-bit machine, it is also necessary to check that the divisor**

*x***is a 32-bit quantity (e.g., check that .**

*y*The signed case is more interesting. It is first necessary to check that ** y** ≠ 0 and, on a 64-bit machine, that

**is correctly represented in 32 bits (check that . Assuming these tests have been done, the table that follows shows how the tests might be done to determine precisely whether or not the quotient is representable in 32 bits by considering separately the four cases of the dividend and divisor each being positive or negative. The expressions in the table are in ordinary arithmetic, not computer arithmetic.**

*y*In each column, each relation follows from the one above it in an if-and-only-if way. To remove the floor and ceiling functions, some relations from Theorem D1 on page 183 are used.

As an example of interpreting this table, consider the leftmost column. It applies to the case in which *x* ≥ 0 and *y* > 0. In this case the quotient is ⌊*x*/*y*⌋, and this must be strictly less than 2^{31} to be representable as a 32-bit quantity. From this it follows that the real number *x*/*y* must be less than 2^{31}, or *x* must be less than 2^{31}*y*. This test can be implemented by shifting *y* left 31 positions and comparing the result to *x*.

When the signs of *x* and *y* differ, the quotient of conventional division is ⌈*x*/*y*⌉. Because the quotient is negative, it can be as small as −2^{31}.

In the bottom row of each column the comparisons are all of the same type (less than). Because of the possibility that *x* is the maximum negative number, in the third and fourth columns an unsigned comparison must be used. In the first two columns the quantities being compared begin with a leading 0-bit, so an unsigned comparison can be used there, too.

These tests can, of course, be implemented by using conditional branches to separate out the four cases, doing the indicated arithmetic, and then doing a final compare and branch to the code for the overflow or non-overflow case. However, branching can be reduced by taking advantage of the fact that when *y* is negative, −*y* is used, and similarly for *x*. Hence the tests can be made more uniform by using the absolute values of *x* and *y*. Also, using a standard device for optionally doing the additions in the second and third columns results in the following scheme:

Using the three-instruction method of computing the absolute value (see page 18), on a 64-bit version of the basic RISC this amounts to 12 instructions, plus a conditional branch.