Mips assembly Language Programming

addi $a0, $a0, 4 #

andi $t1, $t0, 1 #

beqz $t0, loop #

4.1 Introduction

from the textbook “Computer Organization and Design: The Hardware/Software Interface.” This is a more complete and up-to-date version of SPIM documentation than the one included with SPIM. This document provides a detailed explanation of the Unix version of SPIM. It is a suggested supplement to this textbook and is available at:

Save the file as “Text Only.” Launch PCSpim. In the “File” pull-down menu select “Open” or just click the first icon on the tool bar. Select “All Files” for the “Files of type.” Figure 4.1 below shows the bottom Messages window announcing the program has been successfully loaded. Three other windows are also displaying useful information. Specifically the Registers window, which is the top window, displays the contents of the MIPS registers. The next window down displays the contents of the Text Segment, and the window below that displays the Data Segment. To open the Console go to the Window pull down menu and select Console.

In examining the contents of the Registers window at the top, you will find that all the registers initially containing zero except for the Program Counter (PC) and the Stack Pointer ($sp). A short sequence of instructions in the kernel of the operating system is always executed to launch a user program. That sequence of instructions starts at address 0x00400000.

Figure 4.2

[0x00400020] 0x34020004 ori $2, $0, 4 ; 34: li $v0, 4

[0x00400024] 0x3c041001 lui $4, 4097 [prompt] ; 35: la $a0, prompt

[0x00400028] 0x0000000c syscall ; 36: syscall

[0x0040002c] 0x34020005 ori $2, $0, 5 ; 38: li $v0, 5

[0x00400030] 0x0000000c syscall ; 39: syscall

[0x00400034] 0x1840000d blez $2 52 [end-0x00400034] ; 41: blez $v0, end

[0x00400038] 0x34080000 ori $8, $0, 0 ; 42: li $t0, 0

[0x0040003c] 0x01024020 add $8, $8, $2 ; 44: add $t0, $t0, $v0

[0x00400040] 0x2042ffff addi $2, $2, -1 ; 45: addi $v0, $v0, -1

[0x00400044] 0x14403ffe bne $2, $0, -8 [loop-0x00400044] ; 46: bnez $v0, end

[0x00400048] 0x34020004 ori $2, $0, 4 ; 47: li $v0, 4

[0x0040004c] 0x3c011001 lui $1, 4097 [result] ; 48: la $a0, result

[0x00400050] 0x34240022 ori $4, $1, 34 [result]

[0x00400054] 0x0000000c syscall ; 49: syscall

[0x00400058] 0x34020001 ori $2, $0, 1 ; 51: li $v0, 1

[0x0040005c] 0x00082021 addu $4, $0, $8 ; 52: move $a0, $t0

[0x00400060] 0x0000000c syscall ; 53: syscall

[0x00400064] 0x04013fef bgez $0 -68 [main-0x00400064] ; 54: b main

[0x00400068] 0x34020004 ori $2, $0, 4 ; 56: li $v0, 4

[0x0040006c] 0x3c011001 lui $1, 4097 [bye] ; 57: la $a0, bye

[0x00400070] 0x3424004d ori $4, $1, 77 [bye]

[0x00400074] 0x0000000c syscall ; 58: syscall

[0x00400078] 0x3402000a ori $2, $0, 10 ; 60: li $v0, 10

[0x0040007c] 0x0000000c syscall ; 61: syscall
The assembler is the program that translates assembly language instructions to machine language instructions. To appreciate what this translation process entails, every student should translate a few assembly language instructions to machine language instructions. We will now demonstrate this translation process. We will be using the information in Appendix C to verify that 0x3402000a is the correct machine language encoding of the instruction “ori $2, $0, 10.”, which is the next to last instruction in the “Text Segment” above, located at memory location [0x00400078].

In Appendix C we are shown how this instruction is encoded in binary.

001101ssssstttttiiiiiiiiiiiiiiii

00110100000000100000000000001010

Use the information in Appendix C to verify that 0x2042ffff is the correct machine language encoding of the instruction “addi $v0, $v0, -1.” This instruction is located at memory location [0x00400040]. Notice that the instructions (li) and la) in the original code are macro instructions. Looking at the middle column we see how each macro instruction was replaced with one or more actual MIPS instructions.

prompt: .asciiz “\n Please Input a value for N = ”

result: .asciiz “ The sum of the integers from 1 to N is ”

bye: .asciiz “ **** Adios Amigo – Have a good day ****”

the C convention:

• 
  newline \n
  
• 
  tab \t
  
• 
  quote \"
  

To begin this analysis, let’s take the following characters, “Please”. Using Appendix B, look up the ASCII code for each of the characters:

The operating system has allocated space in memory for our Data Segment to begin at address 0x10010000. Locating this ASCII code sequence is an interesting exercise, complicated by the fact that Intel processors store characters within words in reverse order, and PCSpim is running on an Intel-based platform. Below we have highlighted the location of these characters within the data segment of memory. Can you find the null character that terminates the first string?

[0x10010000] 0x2020200a 0x61656c50 0x49206573 0x7475706e

[0x10010010] 0x76206120 0x65756c61 0x726f6620 0x3d204e20

[0x10010020] 0x20200020 0x65685420 0x6d757320 0x20666f20

[0x10010030] 0x20656874 0x65746e69 0x73726567 0x6f726620

[0x10010040] 0x2031206d 0x4e206f74 0x20736920 0x20200a00

Print Float 2

Print Double 3

Print String 4 $a0 = Address of String in Memory

Read an Integer in 5 Integer Returned in $v0

(from the keyboard)

Read Float 6

Read Double 7

Read a String in 8 $a0 = Address of Input Buffer in Memory

(from the keyboard) $a1 = Length of Buffer (n)

Sbrk 9 $a0 = amount Address in $v0

4.7 Deficiencies of the System I/O Services

• 
  The decimal output function prints left justified. In most situations we would rather see the numbers printed right justified.
  

• 
  The decimal input function always returns some value even if the series of keystrokes from the keyboard does not correctly represent a decimal number. You can verify this by running the following program and typing the following strings, each of which does not correctly represent a decimal integer value or the value exceeds the range that can be represented as a 32-bit binary value.
  

2.9999999

1 9

3A

4-2

ABCD

2147463648

-2,147,463,648

-2147463649

.data

prompt: .asciiz “\n Please Input a value”

.globl main

.text

main:

la $a0, prompt # load address of prompt into $a0

syscall # print the prompt message
li $v0, 5 # system call code for Read Integer

syscall # reads the value into $v0

beqz $v0, end # branch to end if $v0 = 0

move $a0, $v0

li $v0, 1 # system call code for Print Integer

syscall # print

b main # branch to main
end: li $v0, 4 # system call code for Print String

la $a0, bye # load address of msg. into $a0

syscall # print the string
li $v0, 10 # terminate program run and

syscall # return control to system

(Hint – Refer to Appendix C and Appendix D.)

loop: addu $a0, $0, $t0

ori $v0, $0, 4

syscall

addi $t0, $t0, -1

andi $s0, $s7, 0xffc0

or $a0, $t7, $s0

sb $a0, 4($s6)

srl $s7, $s7, 4
4.2 What is the character string corresponding to the following ASCII codes?

0x2a2a2a2a 0x69644120 0x4120736f 0x6f67696d 0x48202d20 0x20657661

(Hint – Remember that for simulations running on Intel–based platforms, the characters are stored in reverse order within each word.)

CHAPTER 5

a. The number of words of assembly language code. (space)

b. The number of clock cycles required to execute the code. (time)
5.2 Instructions that Perform Logical Operations
The logical operators implemented as MIPS instructions are: AND, NOR, OR, and EXCLUSIVE-OR (XOR). These instructions are extremely useful for manipulating, extracting and inserting specifically selected bits within a 32-bit word. Programmers who really understand these instructions have a significant advantage in developing code with superior performance indexes. For those unfamiliar with these bit-wise logical operators, the following truth table defines each of the operators. In the table, x and y represent two Boolean variables, and the results of each logical operator appear in the corresponding column. Understand that these logical operations are performed upon the corresponding bits in two source registers, with each containing 32 bits, and the resulting 32 bits are stored in a destination register. The truth table describes four possible combinations of two variables, and defines the corresponding results produced by the logical operators.

Looking at the truth table for the AND operation, we find the only case where we get a one (1) for a result is when x and y are both one (1). For the OR operation, we get a one for a result when either x or y is a one (1). The operator NOR stands for NOT-OR, and we notice the row in the truth table that defines the NOR operation is simply the complement of the row describing the OR operation. For the EXCLUSIVE-OR, we get a one in the result only when the x and y input variables are different. (Not the same)

Input x	0	0	1	1
Input y	0	1	0	1
x AND y	0	0	0	1
x OR y	0	1	1	1
x NOR y	1	0	0	0
x XOR y	0	1	1	0

We will refer to the Least Significant Bit (LSB) in a word as bit 0, and we will refer to the Most Significant Bit (MSB) as bit 31. Note that if a logical operator has a 16-bit immediate operand, the hardware automatically zero extends the immediate value to form a 32-bit operand. One of the operands for a logical operator is usually referred to as a “mask.” The bit pattern within a mask is used to select which fields within the other register we wish to manipulate, or extract information from. For these examples, assume the following masks are stored in registers $t8, and $t9:

$t8 = 0xffffffc0 = 111111111111111111111111111111111111111111000000

2

$t9 = 0x0000003f = 000000000000000000000000000000000000000000111111

To move a copy of $t0 into $t1 with the lower 6 bits cleared to zero, the instruction to accomplish this would be:

and $t1, $t0, $t8 # $t1 = $t0 & $t8

In this case, anywhere there is a zero in the mask, we get zero in $t0, and anywhere there is a one in the mask, we get a copy of $t0 in $t1.

or $t1, $t0, $t9 # $t1 = $t0 | $t9

In this case, anywhere there is a one in the mask, we get a one in $t1, and anywhere there is a zero in the mask, we get a copy of $t0 in $t1.
Suppose we want to complement the lower 6 bits of register $t0, but leave all the other bits unchanged. The instruction to accomplish this would be:

xor $t0, $t0, $t9 # $t1 = $t0 ^ $t9

Anywhere there is a one (1) in the mask, we get a complement of the original value in $t0. Anywhere there is a zero (0) in the mask, we get a copy of the corresponding bits in $t0.

Suppose we want to know if the values in two registers $s0 and $s1 have the same sign. The instructions to accomplish this would be:

xor $t0, $s0, $s1 # The Most Significant Bit (MSB) of $t0 will be

# set to a “1” if $s0 & $s1 have different signs

bgez $t0, same_sign # Branch if MSD of $t0 is a zero

xor $t0, $s0, $s1 # Determine which bits are different

move $s0, $s1 # Move a copy of s1 into s0

xor $s1, $s0, $t0 # Get a copy of s0 but complement those bits

# that were different
How would you use logical instructions to determine if the value in a register is an odd number?

5.3 Instructions that Perform Shift Operations
The MIPS architecture has instructions to shift the bits in a register either right or left. The logical shifts always shift in zeros. In the case of the shift right, there is a shift right logical (srl) instruction, and an shift right arithmetic (sra) instruction. In the case of the shift right arithmetic, a copy of the most significant bit is always maintained and shifted right to insure the sign of the number does not change. Logical shifts always shift in zeros.
Suppose $a0 contains the value –32 (11111111111111111111111111100000) and we want to divide $a0 by four (4). Shifting $a0 right arithmetic 2 bits will accomplish the task. The result is –8 (11111111111111111111111111111000). Note that 2² is equal to four (4). So in the case of dividing by a value that is some power of two (2), division can be accomplished in one clock cycle with the shift right arithmetic instruction. In the case of odd negative numbers, this is not a truncated division. Instead, it rounds down the next more negative integer number. For example, take the binary value equivalent to –9 and do an arithmetic shift right by one bit and the result will be –5. If truncated division of an odd negative number is required, it can still be accomplished with the following instructions.
sub $a0, $0, $a0 # Complement the number to make it positive

sra $a0, $a0, 1 # Shift Right by 1 is Equivalent to dividing by 2

sub $a0, $0, $a0 # Complement the number back to negative
Macro instructions are provided to rotate the bits in a register either right or left. (See Appendix D) With these instructions, any bits shifted out of one end of the register will be shifted into the other end of the register. These macro instructions require at least 3 clock cycles to execute.

5.4 Modular Program Design and Documentation