MIPS_primery_zadach / dandamudi05gtr guide risc processors programmers engineers

Figure 12.2 Two-dimensional array storage representation.

column-major ordering, is shown in Figure 12.2b. Column-major ordering is used in FORTRAN. In the remainder of this section, we focus on the row-major ordering scheme.

Why do we need to know the underlying storage representation? When we use a highlevel language, we really do not have to bother about the storage representation. Access to arrays is provided by subscripts: one subscript for each dimension of the array. However, when using the assembly language, we need to know the storage representation in order to access individual elements of the array for reasons discussed next.

In assembly language, we can allocate storage space for the class_marks array as

class_marks: .space 60

This statement simply allocates the 60 bytes required to store the array. Now we need a formula to translate row and column subscripts to the corresponding displacement. In C, which uses the row-major ordering with subscripts starting from zero, we can express displacement of an element at row i and column j as

where COLUMNS is the number of columns in the array and ELEMENT_SIZE is the number of bytes required to store an element. For example, we can compute the displacement of class_marks[3,1] as (3 * 3 + 1) * 4 = 40. Later we give an example to illustrate how two-dimensional arrays are manipulated.

Our First Program

This example shows how one-dimensional arrays can be manipulated. Program 12.1 finds the sum of the test_marks array and displays the result. The array is declared on lines 20 and 21. Each integer takes four bytes, therefore we use the .space directive to allocate 160 bytes of space for the array. The .align statement on line 19 aligns the array on a word boundary.

The main program prompts the user and reads the input values into the array. The read loop consists of lines 34–41. The input can be terminated either by entering a zero or by entering 40 values. These two conditions are tested on lines 40 and 41. The $t1 register keeps track of the number of values entered. It is initialized to the array size (40 in our example) and decremented each time a value is entered. The read loop is terminated if this register is zero (line 41).

Notice the different addressing modes used in this loop. For example, the immediate addressing mode is on lines 38 and 39 to specify constants 4 and 1, respectively. The memory addressing mode is used on line 37. The register addressing mode is used in several instructions including lines 38, 39, and 46. The instructions on lines 38 and 39 use mixed-mode addressing: they use both register and immediate addressing mode. In contrast, the instruction on line 46 uses only the register-addressing mode.

Once the read loop is terminated, we compute the number of values entered by subtracting the value in $t1 from 39 (see lines 45 and 46). This array size value is passed to the array sum procedure in $a1. The array pointer is passed via the $a0 register (line 44). After returning from the procedure, the main program displays the sum with an appropriate message.

Program 12.1 A one-dimensional array sum example

2:#

3:# Objective: Finds the sum of an integer array.

4:# Input: Requests the array values.

5:# Output: Outputs the sum.

6:#

7:# $a0 - array pointer

8:# $a1 - array size

9:# $v0 - array sum is returned

10:#

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

12:.data

13:prompt:

15:sum_msg:

17:newline:

18: .asciiz "\n"

19:.align 2

20:test_marks:

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

24:.text

25:.globl main

26:main:

28:li $v0,4

29:syscall

34:read_loop:

36:syscall

37:sw $v0,0($t0)

38:addu $t0,$t0,4 # update array pointer

39:subu $t1,$t1,1 # decrement loop count

40:beqz $v0,exit_loop # if number = 0, exit loop

41:bnez $t1,read_loop # if loop count is not 0,

43:exit_loop:

45:li $a1,39

47:jal array_sum

48:move $s0,$v0

57:

58: la $a0,newline # write newline

59:li $v0,4

60:syscall

65:#------------------------------------------------

66:# ARRAY_SUM receives the array pointer in $a0

67:# and its size $a1 and returns their sum in $v0

68:# $t0 = used as a temporary

69:#------------------------------------------------

70:array_sum:

72:add_loop:

73:beqz $a1,exit_add_loop

74:lw $t0,($a0)

75:add $v0,$v0,$t0

76:addu $a0,$a0,4

77:subu $a1,$a1,1

78: b add_loop

79:exit_add_loop:

80: jr $ra

The array_sum procedure is very similar to the read loop in the main program. Because we return the sum in $v0, we initialized it to zero using the li instruction (line 71). The sum loop on lines 72 to 78 is very similar to the read loop of the main program. It uses $a1 as the loop count and $t2 to read the array elements from the memory.

Illustrative Examples

This section gives two more examples to illustrate the application of the addressing modes described here. Both examples deal with processing arrays. The first example uses a onedimensional array and the second one uses a two-dimensional array.

Example 12.1 Cyclic permutation of an array.

In this example, we permute a given sequence by one element. For example, if the given sequence is

1,2,3,4,5,6,7,8,9

its cyclic permutation is defined to be

2,3,4,5,6,7,8,9,1

The program listing is given in Program 12.2. As in the last program, we declare an array of words using the .space directive on lines 16 and 17. The main program prompts the user for the input sequence. This input sequence is read into the array using the read loop on lines 30–37. It is very similar to the read loop we used in Program 12.1. The array size is computed as in the last program.

Program 12.2 A program to perform cyclic permutation of a sequence

2:#

3:# Objective: Performs cyclic permutation of an array.

4:# Input: Requests array input (minimum 2 integers).

5:# Output: Outputs permuted array.

6:#

7:################### Data segment ###################

8:.data

9:prompt:

11:sum_msg:

13:newline:

14: .asciiz "\n"

15:.align 2

16:array:

19:################### Code segment ###################

20:.text

21:.globl main

22:main:

24:li $v0,4

25:syscall

30:read_loop:

32:syscall

33:beqz $v0,exit_loop # if number = 0, exit loop

34:sw $v0,0($t0)

35:addu $t0,$t0,4 # update array pointer

36:subu $t1,$t1,1 # decrement loop count

37:bnez $t1,read_loop # if loop count is not 0,

43:li $t0,0

45:permute:

46:lw $t2,array+4($t0)

47:sw $t2,array+0($t0)

48:addu $t0,$t0,4

49:subu $t3,$t3,1

50:bnez $t3,permute

55:li $v0,4

56:syscall

60:write_loop:

61:lw $a0,array($t0)

62:beqz $a0,write_done

64:syscall

65: la $a0,newline # write newline

66:li $v0,4

67:syscall

68:addu $t0,$t0,4 # update array byte index

69:bne $t0,160,write_loop

70:

71:write_done:

72: la $a0,newline # write newline

73:li $v0,4

74:syscall

77:syscall

The permutation is done using the loop on lines 45–50. We use $t0 to keep the offset in the array. It is initialized to zero on line 43. We copy the first element of the array into $t1 on line 44. After exiting the loop, we copy this value into the last element’s place. We use the load instruction on line 46 to read an element, which is written into its previous

position using the store instruction on line 47. Notice that we use an immediate value to specify the element we want to process. After copying, we update the offset in t0 by four to point to the next element (line 48). The loop index is decremented on line 49.

Once the permutation loop terminates, all the elements except the first element are permuted. All we have to do now is to store the first element we saved in $t1 at the end of the array. This is done on line 52. The permuted array is output by the write loop on lines 60–69.

Example 12.2 Finding the sum of a column in a two-dimensional array.

Consider the class_marks array representing the test scores of a class. For simplicity, assume that there are only 10 students in the class. Also, assume that the class is given 4 tests. As we discussed before, we can use a 10 × 4 array to store the marks. Each row represents the 4 test marks of a student in the class. The first column represents the marks of the first test; the second column represents the marks of the second test, and so on. The objective of this example is to find the sum of test marks specified by the user. The program listing is given in Program 12.3.

Program 12.3 A program to find the sum of a column in a two-dimensional array

2:#

3:# Objective: Finds the sum of a column in a 2-D array.

4:# Input: Requests the column number to be added.

5:# Output: Outputs the sum of the column.

6:#

7:################### Data segment ###################

8:.data

9:try_again:

11:prompt:

13:sum_msg:

15:newline:

28:

29:################### Code segment ###################

30:.text

31:.globl main

32:main:

34:li $v0,4

35:syscall

41:ble $v0,4,valid

42:invalid:

44:li $v0,4

45:syscall

48:valid:

49:subu $t2,$v0,1

53:add_loop:

54:lw $t1,class_marks($t2)

56:addu $t2,$t2,16 # add number of bytes in a row

57:subu $t3,$t3,1 # decrement loop index

58:bnez $t3,add_loop

61:li $v0,4

62:syscall

65:li $v0,1

66:syscall

68: la $a0,newline # write newline

69:li $v0,4

70:syscall

73:syscall

224 Guide to RISC Processors

The two-dimensional array (10 × 4) is declared and initialized on lines 17–27. The user is prompted to enter the test number (i.e., the column number) for which the sum is to be computed. This is done by using the read_int system call (see lines 37 and 38). The input column number is validated on lines 40 and 41. For a valid column number, it should be between 1 and 4. If an invalid test number is given, the user is prompted again after reporting the error (lines 43–46).

The column number is converted into column index by decrementing it on line 49. Thus the valid column index ranges from 0 to 3. The column index is converted to the byte displacement by multiplying the column number by 4. This done by shifting left by two bit positions rather than by multiplication on line 50. The test sum is maintained in $t0, which is initialized to zero on line 52.

The add loop is similar to the add loop we used in Program 12.1. The one major difference, due to the two-dimensional array, is the constant added to move the pointer to the next element. Because we are interested in adding the column, each successive element that we want to add is separated by 16 bytes, equivalent to the number of bytes in a row, as shown on line 56. The rest of the program is straightforward to follow.

Summary

We have described the addressing modes that we can use to write the assembly language programs. Some of these modes are provided by the assembler, not by the processor. We have also discussed how arrays are represented and manipulated in the assembly language. We looked at one-dimensional and two-dimensional arrays. However, our discussion can easily be extended to higher-dimensional arrays.

We have presented several examples to illustrate the use of these addressing modes. These examples have shown how the memory addressing modes are used in writing the assembly language programs. However, MIPS being a RISC processor supports only a limited number of memory addressing modes compared to CISC processors. The last example brings out the drawback of providing simple addressing modes. To access elements of an array, we have to work with byte displacement. In contrast, CISC processors such as Pentium provide support to access arrays using indices.