### 8-2 High-Order Half of 64-Bit Product

Here we consider the problem of computing the high-order 32 bits of the product of two 32-bit integers. This is the function of our basic RISC instructions multiply high signed (mulhs) and multiply high unsigned (mulhu).

For unsigned multiplication, the algorithm in the upper half of Figure 8-1 works well. Rewrite it for the special case m = n = 2, with loops unrolled, obvious simplifications made, and the parameters changed to 32-bit unsigned integers.

For signed multiplication, it is not necessary to code the "correction steps" in the lower half of Figure 8-1. These can be omitted if proper attention is paid to whether the intermediate results are signed or unsigned (declaring them to be signed causes the right shifts to be sign-propagating shifts). The resulting algorithm is shown in Figure 8-2. For an unsigned version, simply change all the int declarations to unsigned.

##### Figure 8-2 Multiply high signed.
`int mulhs(int u, int v) {`
`牋 unsigned u0, v0, w0; `
`牋爄nt u1, v1, w1, w2, t; `
` `
`牋 u0 = u & 0xFFFF;?u1 = u >> 16; `
`牋爒0 = v & 0xFFFF;?v1 = v >> 16; `
`牋爓0 = u0*v0; `
`牋爐?= u1*v0 + (w0 >> 16); `
`牋爓1 = t & 0xFFFF; `
`牋爓2 = t >> 16; `
`牋爓1 = u0*v1 + w1; `
`牋爎eturn u1*v1 + w2 + (w1 >> 16); `
`} `

The algorithm requires 16 basic RISC instructions in either the signed or unsigned version, four of which are multiplications.