MIPS_primery_zadach / dandamudi05gtr guide risc processors programmers engineers

Remember that $a0 maps to $4, $a1 to $5, and $at to $1. This example shows how the assembler uses the $at register to translate pseudoinstructions.

Division

As with the multiply instructions, we can use div and divu instructions to divide signed and unsigned numbers, respectively. The instruction

div Rsrc1,Rsrc2

divides the contents of Rsrc1 by the contents of Rsrc2 (i.e., Rsrc1/Rsrc2). The contents of both source registers are treated as signed numbers. The result of the division is placed in LO and HI registers. The LO register receives the quotient and the HI register receives the remainder. No integer overflow exception is generated.

The result of the operation is undefined if the divisor is zero. Thus, a check for a zero divisor should precede this instruction.

Assembler provides three-operand divide pseudoinstructions similar to the multiply instructions. The instruction

div† Rdest,Rsrc1,Src2

places the quotient of the division Rsrc1/Src2 in Rdest. The two numbers are treated as signed integers. As in the other instructions, Src2 can be a register or an immediate value. For unsigned numbers, use the divu† pseudoinstruction. The quotient is rounded towards zero. Overflow is signalled when dividing −2 31 by −1 as the quotient is greater than 2 31 − 1. To see how the assembler implements this pseudoinstruction, let’s look at the following.

div $t0,$t1,$t2

This pseudoinstruction is translated as

The first instruction compares the divisor in $t2 (mapped to register $10) with zero. If it is equal to zero, it causes exception 0 using the break instruction. If it is not equal to zero, the bne instruction transfers control to the div instruction using offset 8. Because the div instruction leaves the quotient in the LO register, the last instruction moves this to the destination register $t0, which is mapped to register $8.

Assembler generates the real div instruction if we use

div $0,Rsrc1,Src2.

To get the remainder instead of the quotient, use

rem† Rdest,Rsrc1,Src2

for signed numbers. This pseudoinstruction is implemented like the div pseudoinstruction except that it uses mfhi instead of the mflo instruction.

Our First Program

As our first example of the chapter, let us write a program to compute a factorial using iteration. The factorial of n (represented by n!) is defined as follows.

Fact(0) = 1

Fact(n) = n i for n > 0

i=1

For example, Fact(5) is

5! = 1 × 2 × 3 × 4 × 5 = 120.

This leads us to an iterative algorithm in which a single loop can compute the factorial. There is also a recursive version that we discuss in Chapter 16.

Program 13.1 shows the listing of the factorial program that receives a positive integer and outputs its factorial. The main program prompts the user for a positive integer on lines 26–28. The input number is read using the read_integer function on lines 31– 33. We use the bgez instruction to check if the input number is greater than or equal to zero (line 35).

Once the number is validated, it calls the factorial procedure fact1. This procedure returns the factorial value in $v0, which is saved in $t0 as $v0 is needed for syscalls. This value is output with an appropriate message.

Program 13.1 A program to compute factorial (iterative version)

2:#

3:# Objective: Computes factorial of an integer.

5:# Input: Requests an integer n.

6:# Output: Outputs n!

7:#

8:# $a0 - used to pass n

9:# $v0 - used to return result

10:#

11:#################### Data segment ########################

12:.data

13:prompt:

15:out_msg:

17:error_msg:

19:newline:

22:#################### Code segment ########################

23:.text

24:.globl main

25:main:

27:li $v0,4

28:syscall

30:try_again:

32:syscall

33:move $a0,$v0

35:bgez $a0,num_OK

37:li $v0,4

38:syscall

41:num_OK:

42:jal fact1

43:move $t0,$v0

46:li $v0,4

47:syscall

50:li $v0,1

51:syscall

54:li $v0,4

55:syscall

60:#----------------------------------------------------

61:# FACT1 receives n in $a0 and returns n! in $v0.

62:# It uses iteration to compute n!.

63:#----------------------------------------------------

64:fact1:

65:li $v0,1

66:ble $a0,1,fact_done

67:loop:

71:fact_done:

72: jr $ra

The fact1 procedure receives n in the $a0 register and returns n! in the $v0 register. The latter register is initialized to 1 on line 65. If n ≤ 1, the procedure is terminated as $v0 contains the result; otherwise, the loop on lines 67–70 computes n!. We use the mulou to multiply two unsigned numbers (line 68).

Illustrative Examples

In this section we present three examples to further illustrate the application of the arithmetic instructions discussed in this chapter.

Example 13.1 Add individual digits of a number.

This example shows how individual digits of an integer can be added. For example, if the input is 123456, it outputs 1 + 2 + 3 + 4 + 5 + 6 = 21. We have done another version of this example in Example 10.1 on page 174. In that example, we read the input as a string, not as a number. Here we read the input as a number. In this case, to perform this addition, we need to separate individual digits. This can be done by successively dividing the number by 10 as shown here:

As shown in this example, we divide the number by 10 to separate the least significant digit. The quotient is repeatedly divided until it is zero. Then we can add the remainders to get the sum we want. Our implementation essentially follows this algorithm.

2:#

3:# Objective: To add individual digits of an integer.

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

6:# Output: Outputs the sum.

7:#

8:# t0 - holds the quotient

9:# t1 - holds constant 10

10:# t2 - maintains the running sum

11:# t3 - holds the remainder

12:#

13:################### Data segment #####################

15:.data

16:number_prompt:

17:.asciiz "Please enter an integer: \n"

18:out_msg:

19:.asciiz "The sum of individual digits is: "

20:newline:

21: .asciiz "\n" 22:

23:################### Code segment #####################

24:.text

25:.globl main

26:main:

28:li $v0,4

29:syscall

38:li $v0,4

39:syscall

43:loop:

53:li $v0,1

54:syscall

The main program, shown in Program 13.2, prompts for the input number and reads it into the $t0 register. It then uses the abs instruction to convert this into a positive number (line 35).

The sum is computed using the loop on lines 43–50. Before entering the loop, we initialize $t1 to 10 (line 41) and $t2, which holds the sum, to 0 (line 42). The divide instruction on line 44 leaves the quotient in LO and remainder in HI registers. We use mflo and mfhi instructions to move the quotient and remainder to the $t0 and $t3 registers, respectively (lines 46 and 47). After adding the remainder to the sum (line 48), we check if the quotient is zero (line 49). We exit the loop if it is zero. After exiting the loop, the program prints the sum in the $t2 register.

Example 13.2 String-to-number conversion to read an integer.

In this example, we show how integers are read from the input. Note that the input value is given as a sequence of characters. For example, the number 158 is given as three characters “1”, “5”, and “8”. To convert this to an integer, we need to first convert each character to its numeric equivalent. Then we add this value to a running sum after multiplying it by 10. The conversion process is illustrated here for 158:

The pseudocode for the conversion process is given below:

convert_int(numString) index := 0

number := 0 while (TRUE)

char := numString[index]

if ((char =linefeed) AND (char =NULL)) then

number := number * 10 + (char AND 0xF)

else

goto convert_done end if

index := index + 1 end while

convert_done: return

end convert_int

The convert_int procedure implements this algorithm as shown in Program 13.3. The main program simply requests a number and reads it as a string using the read_string system call (lines 29–32). A pointer to this string is passed to the convert_int procedure via $a0.

2:#

3:# Objective: Converts a string of digits into integer.

4:# Input: Requests an integer. Reads it as a string.

5:# Output: Outputs the integer.

6:#

7:# $a0 - used to pass the string pointer

8:# $v0 - used to return the result

9:#

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

11:.data

12:prompt:

14:out_msg:

16:newline:

17: .asciiz "\n"

18:in_number: