- 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–12 Comparison Predicates

A “comparison predicate” is a function that compares two quantities, producing a single bit result of 1 if the comparison is **true**, and 0 if the comparison is **false**. Below we show branch-free expressions to evaluate the result into the sign position. To produce the 1/0 value used by some languages (e.g., C), follow the code with a *shift right* of 31. To produce the −1/0 result used by some other languages (e.g., Basic), follow the code with a *shift right signed* of 31.

These formulas are, of course, not of interest on machines such as MIPS and our model RISC, which have comparison instructions that compute many of these predicates directly, placing a 0/1-valued result in a general purpose register.

A machine instruction that computes the negative of the absolute value is handy here. We show this function as “nabs.” Unlike absolute value, it is well defined in that it never overflows. Machines that do not have nabs, but have the more usual abs, can use −abs(** x**) for nabs(

**). If**

*x***is the maximum negative number, this overflows twice, but the result is correct. (We assume that the absolute value and the negation of the maximum negative number is itself.) Because some machines have neither abs nor nabs, we give an alternative that does not use them.**

*x*The “nlz” function is the number of leading 0’s in its argument. The “doz” function (*difference or zero*) is described on page 41. For ** x** >

**, and so on, interchange**

*y, x*≥*y***and**

*x***in the formulas for**

*y***<**

*x***, and so on. The**

*y, x*≤*y**add*of

**0x8000 0000**can be replaced with any instruction that inverts the high-order bit (in

**, or**

*x, y***).**

*x*−*y*Another class of formulas can be derived from the observation that the predicate ** x** <

**is given by the sign of**

*y***/2 −**

*x***/2, and the subtraction in that expression cannot overflow. The result can be fixed up by subtracting 1 in the cases in which the shifts discard essential information, as follows:**

*y*These execute in seven instructions on most machines (six if it has *and not*), which is no better than what we have above (five to seven instructions, depending upon the fullness of the set of logic instructions).

The formulas above involving nlz are due to [Shep], and his formula for the ** x** =

**predicate is particularly useful, because a minor variation of it gets the predicate evaluated to a 1/0-valued result with only three instructions:**

*y*Signed comparisons to 0 are frequent enough to deserve special mention. There are some formulas for these, mostly derived directly from the above. Again, the result is in the sign position.

Signed comparisons can be obtained from their unsigned counterparts by biasing the signed operands upward by 2^{31} and interpreting the results as unsigned integers. The reverse transformation also works.^{2} Thus, we have

Similar relations hold for ≤, , and so on. In these relations, one can use addition, subtraction, or *exclusive or* with 2^{31}. They are all equivalent, as they simply invert the sign bit. An instruction like the basic RISC’s *add immediate shifted* is useful to avoid loading the constant 2^{31}.

Another way to get signed comparisons from unsigned is based on the fact that if ** x** and

**have the same sign, then , whereas if they have opposite signs, then [Lamp]. Again, the reverse transformation also works, so we have**

*y*where *x*_{31} and *y*_{31} are the sign bits of ** x** and

**, respectively. Similar relations hold for ≤, , and so on.**

*y*Using either of these devices enables computing all the usual comparison predicates other than = and ≠ in terms of any one of them, with at most three additional instructions on most machines. For example, let us take as primitive, because it is one of the simplest to implement (it is the carry bit from ** y** −

**). Then the other predicates can be obtained as follows:**

*x*### Comparison Predicates from the Carry Bit

If the machine can easily deliver the carry bit into a general purpose register, this may permit concise code for some of the comparison predicates. Below are several of these relations. The notation carry(*expression*) means the carry bit generated by the outermost operation in *expression*. We assume the carry bit for the subtraction ** x** –

**is what comes out of the adder for**

*y***+ + 1, which is the complement of “borrow.”**

*x*For ** x** >

**, use the complement of the expression for**

*y***≤**

*x***, and similarly for other relations involving “greater than.”**

*y*The GNU Superoptimizer has been applied to the problem of computing predicate expressions on the IBM RS/6000 computer and its close relative PowerPC [GK]. The RS/6000 has instructions for abs(** x**), nabs(

**), doz(**

*x***), and a number of forms of**

*x, y**add*and

*subtract*that use the carry bit. It was found that the RS/6000 can compute all the integer predicate expressions with three or fewer elementary (one-cycle) instructions, a result that surprised even the architects of the machine. “All” includes the six two-operand signed comparisons and the four two-operand unsigned comparisons, all of these with the second operand being 0, and all in forms that produce a 1/0 result or a –1/0 result. PowerPC, which lacks abs(

**), nabs(**

*x***), and doz(**

*x***), can compute all the predicate expressions in four or fewer elementary instructions.**

*x, y*### How the Computer Sets the Comparison Predicates

Most computers have a way of evaluating the integer comparison predicates to a 1-bit result. The result bit may be placed in a “condition register” or, for some machines (such as our RISC model), in a general purpose register. In either case, the facility is often implemented by subtracting the comparison operands and then performing a small amount of logic on the result bits to determine the 1-bit comparison result.

Below is the logic for these operations. It is assumed that the machine computes ** x** −

**as**

*y***+ + 1, and the following quantities are available in the result:**

*x**C*, the carry out of the high-order position_{o}*C*, the carry into the high-order position_{i}*N*, the sign bit of the result*Z*, which equals 1 if the result, exclusive of*C*, is all-0, and is otherwise 0_{o}

Then we have the following in Boolean algebra notation (juxtaposition denotes *and*, + denotes *or*):