MIPS_primery_zadach / dandamudi05gtr guide risc processors programmers engineers

Multiplication and Division Shift operations are very effective in performing doubling or halving of unsigned binary numbers. More generally, they can be used to multiply or divide binary numbers by a power of 2. Let us first look at unsigned numbers.

In the decimal number system, we can easily perform multiplication and division by a power of 10. For example, if we want to multiply 254 by 10, we simply append a 0 at the right (analogous to shifting left by a digit with the vacated digit receiving a 0). Similarly, division of 750 by 10 can be accomplished by throwing away the 0 on the right (analogous to right-shift by a digit).

Computers use the binary number system, therefore they can perform multiplication and division by a power of 2. This point is further clarified in Table 15.4. The first half of this table shows how shifting a binary number to the left by one bit position results in multiplying it by 2. Note that the vacated bits are replaced by 0s. This is exactly what the sll instruction does. Therefore, if we want to multiply a number by 8 (i.e., 2 3), we can do so by shifting the number left by three bit positions.

Similarly, as shown in the second half of the table, shifting right by one bit position is equivalent to dividing by 2. Thus, we can use the srl instruction to perform division by a power of 2. For example, to divide a number by 32 (i.e., 2 5), we right-shift the number by five bit positions. Remember that this division process corresponds to integer division, which discards any fractional part of the result.

Doubling Signed Numbers

Doubling a signed number by shifting it left by one bit position may appear to cause problems because the leftmost bit represents the sign. It turns out that this is not a problem at all. Take a look at the examples presented in Table 15.5 to develop your intuition.

The first group presents the doubling effect on positive numbers and the second group shows the doubling effect on negative numbers. In both cases, a 0 replaces the vacated bit. Why isn’t shifting out the sign bit causing problems? The reason is that signed numbers are sign-extended to fit a larger-than-required number of bits. For example, if we want to represent numbers in the range of +3 and −4, 3 bits are sufficient. If we use a byte to represent the same range, the number is sign-extended by copying the sign bit into the higher-order five bits, as shown below:

sign bit copied

+3 = 00000 011B

sign bit copied

−3 = 11111 101B

Clearly, doubling a signed number is no different than doubling an unsigned number. Thus, no special shift left instruction is needed for signed numbers.

Halving Signed Numbers

Can we also forget about treating the signed numbers differently in halving a number? Unfortunately, we cannot! When we are right-shifting a signed number, the vacated left bit should be replaced by a copy of the sign bit. This rules out the use of shr for signed numbers. See the examples presented in Table 15.6. The sra instruction precisely does this: the sign bit is copied into the vacated bit on the left.

Why use shifts for multiplication and division? The main reason is that shifts are more efficient to execute than the corresponding multiplication or division instructions.

Rotate Instructions

A problem with the shift instructions is that the shifted-out bits are lost. Rotate instructions allow us to capture these bits. The processor does not support rotate instructions. However, assembler provides two rotate pseudoinstructions: rotate left (rol) and rotate right (ror).

In rotate left, the bits shifted out at the left (i.e., the sign-bit side) are inserted on the right-hand side, as shown below:

The process is repeated for each bit of the ASCII value. The pseudocode of the program is as follows:

print_bin (char)

mask := 0x80 {mask is in $t1} count := 8 {we don’t really use count} repeat

if ((char AND mask) = 0) then

write 0

else

write 1 end if

mask := mask/2 {done by srl} count := count − 1

until (count = 0) end print_bin

The assembly language program, shown in Program 15.1, follows the pseudocode with one exception. We do not use a count variable to terminate the loop. Instead, we use the fact that, after eight shifts, the mask would have zero as the srl instruction replaces the shifted-out bits by zeros. This is the loop termination condition we use on line 70.

2:#

3:# Objective: To convert a character to its binary

5:# Input: Requests a character from the user.

6:# Output: Outputs its ASCII value in binary.

7:#

8:# $a0 - input character

9:#

10:################### Data segment #######################

11:.data

12:ch_prompt:

14:out_msg:

16:newline:

17: .asciiz "\n"

18:ch:

21:################### Code segment #######################

22:.text

23:.globl main

24:main:

26:li $v0,4

27:syscall

30:li $a1,2

31:li $v0,8

32:syscall

35:li $v0,4

36:syscall

42:li $v0,4

43:syscall

46: syscall 47:

48:#------------------------------------------------

49:# PRINT_BIN receives a character in $a0 and

50:# prints its binary value.

51:# $t0: holds the character

52:# $t1: holds the mask byte

53:# $t2: temporary

54:#------------------------------------------------

55:print_bin:

58:loop:

59:and $t2,$t0,$t1

60:beqz $t2,zero

63:zero:

65:skip:

66:li $v0,1

67:syscall

72:jr $ra

Illustrative Examples

To further illustrate the application of the logical, shift, and rotate instructions, we give two examples.

Example 15.7 Binary to octal conversion.

In this example, we convert a number from its binary representation to the octal system. For example, if the number is −1, it is stored as all 1s in the 2’s complement representation (i.e., all 32 bits are 1). Thus, when we express it in the octal number system, we get

37777777777.

The main program is straightforward. It requests a number and passes it on to the print_octal procedure via the $a0 register (lines 35 and 36). This procedure outputs the octal value. Let us look at the logic of this procedure next.

To convert to the octal equivalent, we start with the most significant octal digit. However, because the number of bits (i.e., 32) is not a multiple of 3, the most significant octal

digit should be derived using the leftmost two bits of the number. Thus, the most significant digit of the output can be at most 3 as in our example. Once we have converted these two bits, the remaining bits can be processed three bits at a time. The print_octal procedure follows the pseudocode shown below:

print_octal (number)

mask := 0xE0000000 {mask is in $t1} {Handle the leftmost octal digit—special case} temp := number

shift temp right by 1 bit position temp := temp AND mask

rotate temp left by 3 bit positions write temp

{Handle the remaining 10 octal digits} count := 10 {count is in $t3}

shift number left by 2 bit positions repeat

temp := number AND mask rotate temp left by 3 bit positions write temp

shift number left by 3 bit positions count := count − 1

until (count = 0) end print_octal

We set the mask such that the most significant three bits are 1 and the remaining bits are 0. To use the mask, we right-shift the number by one bit position so that the leftmost three bits can be isolated to output the most significant octal digit. However, to print the value of these three bits, we need to move them to the least significant three bit positions. This is done by rotating it three bit positions. To output the remaining 10 octal digits, we use a loop in which we left-shift the number by three bit positions so that we can isolate the next three bits. Once isolated, we rotate left by three bit positions to output the value as explained before.

Program 15.2 A program to convert binary numbers to octal

2:#

3:# Objective: To convert a number to its octal

5:# Input: Requests a number from the user.

6:# Output: Outputs its octal value.

7:#