MIPS_primery_zadach / dandamudi05gtr guide risc processors programmers engineers

processor instructions. For some pseudoinstructions, there is a single processor instruction. However, other pseudoinstructions may get translated into more than one processor instruction.

Summary

We have introduced the MIPS simulator SPIM. SPIM is a convenient tool to experience RISC assembly language programming. SPIM is available for a variety of platforms. It includes a simple debugger to facilitate single-stepping and setting breakpoints. In the last section, we have given an overview of its debugging facilities. However, we have not presented all the details about SPIM. Some of the missing details are given in the next chapter. Specifically, the next chapter describes the SPIM system calls and SPIM assembler directives. These details complement our discussion in this chapter.

The remainder of the book gives details about the MIPS instruction set as implemented by the SPIM simulator. However, to write meaningful assembly language programs, we give an overview of the instructions set. In this chapter, we present complete details on the load and store instructions. We only give a brief overview of the remaining instructions and defer a detailed discussion of these instructions to later chapters.

Assembly Language Statements

Assembly language programs are created out of three different classes of statements. Statements in the first class tell the processor what to do. These statements are called executable instructions, or instructions for short. Each executable instruction consists of an operation code (opcode for short). Executable instructions cause the assembler to generate machine language instructions.

The second class of statements consists of pseudoinstructions. These are not directly supported by the processor. The assembler supports the pseudoinstructions and generates one or more processor instructions to implement them. We clearly identify the pseudoinstructions and, where appropriate, show how they are implemented using the processor instructions.

The last class of statements provides information to the assembler on various aspects of the assembly process. These instructions are called assembler directives. Assembler directives are nonexecutable and do not generate any machine language instructions.

Assembly language statements are entered one per line in the source file. All three classes of the assembly language statements use the same format:

[label:] mnemonic [operands] [#comment]

The fields in the square brackets are optional in some statements. As a result of this format, it is common practice to align the fields to aid readability of assembly language programs. The assembler does not care about spaces between the fields.

Label Labels are used to associate them with the address of a memory location. Labels typically appear in text and data segments. In both segments, a label is terminated by a colon. In the text segment, labels are used to identify an instruction as shown here:

In this example, the label repeat identifies the add instruction. In the data segment, labels are used for variable names as shown below:

This example declares the variable number and initializes it to 10. Labels, for obvious reasons, cannot be reserved words such as instruction mnemonics like add.

Mnemonic This is a required field and identifies the purpose of the statement. In most statements, it represents the opcode of the instruction such as add and sub. In certain

statements, this field is not required. Examples include lines consisting of a comment, or a label, or a label and a comment.

Operands Operands specify the data to be manipulated by the statement. The number of operands required depends on the specific statement. Most statements have three operands as shown here:

add $t0,$t1,$t2

However, some instructions and pseudoinstructions have only one or two operands. Here are some examples:

li $v0,5 move $a0,$t2

la $t3,number mflo $t2

Don’t worry about the semantics of these instructions. We give details about these instructions in the remainder of the book.

Comment This is an optional field and serves the same purpose as that in a high-level language. Comments play a more important role in assembly language, as it is a low-level language. Assembler ignores all comments. Comments begin with a sharp sign (#) and extend until the end of the line. Because the readability of assembly language programs is poor, comments should be generously used to improve readability.

SPIM System Calls

SPIM provides I/O support through the system call (syscall) instruction. Eight of these calls facilitate input and output of the four basic data types: string, integer, float, and double. A notable service missing from this list is the character input and output. For character I/O, we have to use the string system calls.

To invoke a service, the system call service code should be placed in the $v0 register. Any required arguments are placed in the $a0 and $a1 registers (use $f12 for floatingpoint values). Any value returned by a system call is placed in $v0 ($f0 for floating-point values).

All ten system calls are summarized in Table 10.1. The first three calls are selfexplanatory. The print_string system call takes a pointer to a NULL-terminated string and prints the string. The read_int, read_float and read_double system calls read input up to and including newline. Characters following the number are ignored. The read_string call takes the pointer to a buffer in $a0 and the buffer size n in $a1. The buffer size should be expressed in bytes. It reads at most n − 1 characters into the buffer and terminates the string by the NULL character. The read_string call has the same semantics as the fgets function in the C library.

The sbrk call returns a pointer to a block of memory containing n additional bytes. The final system call exit stops execution of a program.

SPIM Assembler Directives

SPIM supports a subset of the assembler directives provided by the MIPS assembler. This section presents some of the most common SPIM directives. The SPIM reference manual provides a complete list of directives supported by the simulator. All assembler directives begin with a period.

Segment declaration Two segments of an assembly program—code and data—can be declared by using .TEXT and .DATA directives. The statement

.TEXT <address>

directs the assembler to map the statements following it to the user text segment. The argument address is optional; if present, the statements are stored beginning at address. SPIM allows only instructions or words (using .WORD) in the text segment.

The data directive has a similar format as .TEXT except that the statements following it must refer to data items.

String directives SPIM provides two directives to allocate storage for strings: .ASCII and .ASCIIZ. The .ASCII directive can be used to allocate space for a string that is not terminated by the NULL character. The statement

.ASCII "string"

allocates a number of bytes equal to the number of characters in string. For example,

.ASCII "Toy Story"

allocates nine bytes of contiguous storage and initializes it to “Toy Story”.

Strings are normally NULL-terminated as in C. For example, to display a string using print_string service, the string must be NULL-terminated. Using .ASCIIZ instead of ASCII stores the specified string in the NULL-terminated format. The .ASCII directive is useful to break a long string into multiple string statements as shown in the following example.

An associated assembler directive

.SPACE n

can be used to allocate n bytes of uninitialized space in the current segment.

Data directives SPIM provides four directives to store both integers and floating-point numbers. The assembler directive

stores the n 16-bit numbers in successive memory halfwords. For 32-bit numbers, use the

.WORD directive. Although we refer to these 16and 32-bit values as numbers, they can be any 16and 32-bit quantities.

Floating-point values can be stored as single-precision or double-precision numbers. To store n single-precision floating point numbers, use

To store double precision numbers, use the .DOUBLE directive instead.

Miscellaneous directives We discuss two directives that deal with data alignment and global symbol declaration. The data directives .HALF, .WORD, .FLOAT, and .DOUBLE automatically align the data. We can explicitly control data alignment using the .ALIGN directive. The statement

#Input:

#Output:

#Register usage

################# Data segment #####################

.data

. . .

data go here

. . .

################# Code segment #####################

.text

.globl main main:

. . .

code goes here

. . .

li $v0,10 # exit syscall

Figure 10.1 MIPS assembly language program template

.ALIGN n

aligns the next datum on a 2 n byte boundary. Use

.ALIGN 0

to turn off the automatic alignment feature of the data directives until the next .DATA directive.

Before closing this section, we discuss one last directive: .GLOBL. It declares a symbol as global so that it can be referenced from other files. We normally use this directive to declare main as a global symbol so that it can be referenced by SPIM’s trap file (see page 153 for details on the trap file). The program template given next shows how the global directive is used.