MIPS_primery_zadach / dandamudi05gtr guide risc processors programmers engineers

2:#

3:# Objective: Reverses a given string.

4:# Input: Requests a string from the user.

5:# Output: Outputs the reversed string.

6:#

7:# $a0 - string pointer

8:#

9:################## Data segment ######################

10:.data

11:prompt:

13:out_msg:

15:in_string:

16: .space 31 17:

18:################## Code segment ######################

19:.text

20:.globl main

21:main:

23:li $v0,4

24:syscall

28:li $v0,8

29:syscall

31:la $a0,in_string

32:jal string_reverse

35:li $v0,4

36:syscall

39:li $v0,4

40:syscall

45:#------------------------------------------------------

46:# STRING_REVERSE receives a pointer to a string in $a0

47:# and reverses the string

48:# $a0 - front pointer

49:# $t1 - back pointer

50:# $t2, $t3 - used as temporaries

51:#------------------------------------------------------

52:string_reverse:

54:loop1:

55:lbu $t2,($t1)

58:addu $t1,$t1,1

59: b loop1

60:done1:

63:reverse_loop:

72:done:

73: jr $ra

The string reverse procedure uses the $a0 and $t1 registers for front and back pointers, respectively. The first while loop is implemented on lines 54–59. The second while loop condition is implemented on line 64. The two characters, pointed to by front and back, are exchanged on lines 65–68. The two pointers are updated on lines 69 and 70. Because this is a leaf procedure, we can leave the return address in the $ra register.

Passing Variable Number of Parameters

Procedures in C can be defined to accept a variable number of parameters. The input and output functions, scanf and printf, are the two common procedures that take a variable number of parameters. In this case, the called procedure does not know the number of parameters passed onto it. Usually, the first parameter in the parameter list specifies the number of parameters passed.

In assembly language procedures, a variable number of parameters can be easily han-

dled by the stack method of parameter passing. Only the stack size imposes a limit on the number of parameters that can be passed. The next example illustrates the use of the stack to pass a variable number of parameters in the MIPS assembly language programs.

Example 11.4 Passing a variable number of parameters via the stack.

The objective of this example is to show how easy it is to pass a variable number of parameters using the stack. The program, shown in Program 11.6, reads a number of integers and outputs their sum.

The procedure sum receives a variable number of integers via the stack. The parameter count is passed via $a0.

Program 11.6 Passing a variable number of parameters to a procedure

1: # Sum of variable number of integers VAR_PARA.ASM

2:#

3:# Objective: Finds sum of variable number of integers.

5:# Input: Requests integers from the user; input can be

7:# Output: Outputs the sum of input numbers.

8:#

9:# $a0 - number of integers passed via the stack

10:# $v0 - sum is returned via this register

11:#

12:#################### Data segment ########################

13:.data

14:prompt:

17:sum_msg:

19:newline:

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

23:.text

24:.globl main

25:main:

27:li $v0,4

28:syscall

30:li $a0,0

31:read_more:

can pass this value to the procedure. Thus, a simple procedure call (line 40) is sufficient to pass the parameter count and the actual values.

The procedure sum reads the numbers from the stack. As it reads, it decreases the stack size (i.e., $sp increases). The loop in the sum procedure terminates when $a0 is zero (line 66). When the loop terminates, the stack is also cleared of all the arguments.

Summary

We have introduced procedures and discussed how procedures are implemented in the MIPS assembly language. We can divide procedures into leaf and nonleaf categories. A leaf procedure does not call another procedure whereas a nonleaf procedure invokes another procedure. In the MIPS architecture, leaf procedures can be written using internal registers. As part of procedure invocation, the return address is stored in the $ra register. This value is used to transfer control back to the caller after executing the procedure. Nonleaf procedures, however, need to use the stack.

The stack is a last-in-first-out data structure that plays an important role in nonleaf procedure invocation and execution. The stack supports two operations: push and pop. Only the element at the top-of-stack is directly accessible through these operations. The $sp register points to the top of the stack. It is important to note that the stack grows downward (i.e., towards lower memory addresses). Because the MIPS architecture does not explicitly support stack operations, we need to manipulate the stack pointer ($sp) register to implement the stack push and pop operations.

When writing procedures in assembly language, parameter passing has to be explicitly handled. Parameter passing can be done via registers or the stack. Although the register method is efficient, the stack-based method is more general and flexible. Also, when the stack is used for parameter passing, passing a variable number of parameters is straightforward. We have demonstrated this by means of an example.

In this chapter we discussed direct procedure calls in which the target instruction address is directly specified. The MIPS architecture also supports indirect procedure calls. In these calls, the target is specified indirectly through a register. Even though we haven’t used this mechanism to invoke a procedure, we have used it to return from a procedure. We discuss indirect procedure calls in Chapter 14.

array:

.word 15,16,17,18,19,20

We use the load instruction to illustrate the various memory addressing modes. We can also specify the address by using array as in the following example.

lw $t1,array

This instruction loads the first word (i.e., value 15) into the $t1 register. We can specify an immediate constant as in the following example.

lw $t1,4($t0)

If $t0 contains the address of array, this instruction loads the second element (i.e., value 16) into the $t1 register. Of course, we can do the same thing using the following instruction.

lw $t1,array+4

In our next example, we look at the last addressing mode given in Table 12.1. In this addressing mode, the address is computed from three components: symbol±imm(Rx). Here is an example that uses these three components:

lw $t2,array+4($t0) sw $t2,array+0($t0)

This two-instruction sequence copies the second element into the first element, assuming that $t0 contains 0. We use this instruction sequence in an example later (see Example 12.1 on page 219).

Note that most load and store instructions operate only on aligned data. The MIPS, however, provides some instructions for manipulating unaligned data.

Processing Arrays

Arrays are useful in organizing a collection of related data items, such as test marks of a class, salaries of employees, and so on. We have used arrays of characters to represent strings. Such arrays are one-dimensional: only a single subscript is necessary to access a character in the array. Next we discuss one-dimensional arrays. High-level languages support multidimensional arrays, which are discussed towards the end of this chapter.

One-Dimensional Arrays

A one-dimensional array of test marks can be declared in C as

In C, the subscript always starts at zero. Thus, the mark of the first student is given by test_marks[0] and that of the last student by test_marks[9].

Array declaration in high-level languages specifies the five attributes:

•Name of the array (test_marks),

•Number of the elements (10),

•Element size (4 bytes),

•Type of element (integer), and

•Index range (0 to 9).

From this information, the amount of storage space required for the array can be easily calculated. Storage space in bytes is given by

Storage space = number of elements * element size in bytes.

In our example, it is equal to 10 * 4 = 40 bytes. In assembly language, arrays are implemented by allocating the required amount of storage space. For example, we can declare the test_marks array as

test_marks: .space 40

An array name can be assigned to this storage space. But that is all the support you get in assembly language! It is up to you as a programmer to “properly” access the array taking into account the element size and the range of subscripts.

You need to know how the array is stored in memory in order to access its elements. For one-dimensional arrays, representation of the array in memory is rather direct: array elements are stored linearly in the same order, as shown in Figure 12.1. In the remainder of this section, we use the convention used for arrays in C (i.e., subscripts are assumed to begin with 0).

To access an element we need to know its displacement in bytes relative to the beginning of the array. Because we know the element size in bytes, it is rather straightforward to compute the displacement from the subscript: