PPMIPS

MIPS Assembly Language Programming
Bob Britton, Instructor
Lesson #1
Required Background Preparation

Two semesters of programming experience
Benefits of Studying Assembly Language Programming

Obtain Insights into writing more efficient code
Will become familiar with what compilers do Acquire an understanding of how computers are built
Open new opportunities in the field of embedded processors
Course Description
Basic computer organization concepts such as registers, the ALU, data path, and random access memory (RAM). The use of pseudocode to develop and document algorithms at the register level. Number systems and the rules for arithmetic. Passing parameter to functions using the stack. Assemblers and linking editors. Modular program design and development.
Introduction
Basic Computer Organization Machine Language
Assembly Language
MIPS
MIPS
PowerPC
MIPS Computer Organization

Datapath Diagram Control Logic
DataPath Diagram
Prog ram Counter (PC) Cache Memo ry Instruction Register Out Rs ALU
Address
Co ntrol Lo gi c
Rd
Rt
Data In Registe r File
Number
Value
Name
$zero $at $v0 $v1 $a0 $a1 $a2 $a3 $t0 $t1 $t2 $t3 $t4
Register File
0 1 2 3 4 5 6 7 8 9 10 11 12
Return values from functions Pass parameters to functions
13
14 15 16 17 18 19 20 21 22 23 24
$t5
$t6 $t7 $s0 $s1 $s2 $s3 $s4 $s5 $s6 $s7 $t8
Caller Saved Registers Use these registers in functions
Callee-Saved Registers Use these registers for values that must be maintained across function calls.
An Example MIPS Assembly Language Program

Label
Op-Code Dest. S1, S2
Comments
move $a0, $0 li $t0, 99 loop:
# $a0 = 0 # $t0 = 99
add $a0, $a0, $t0 addi $t0, $t0, -1 bnez $t0, loop li $v0, 1 syscall li $v0, 10 syscall
# $a0 = $a0 + $t0 # $t0 = $t0 - 1 # if ($t0 != zero) branch to loop # Print the value in $a0
# Terminate Program Run
Three Instruction Word Formats

Register Format
Op-Code
6
Rs
5
Rt
5
Rd
5
Code
6
Immediate Format
Op-Code 6 Rs 5 Rt 5 16 - Bit Immediate Value 16
Jump Format
Op-Code 6 26 Bit Current Segment Address 26
Main Memory
Program Counter (PC) 4 Instruction Regis te r (IR)
Ad dre ss 0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 10 0 10 4 10 8 11 2 11 6 12 0 12 4 12 8 13 2 1,08 7,418 ,2 33 13 13 0 5 5 13 0 0 3 6 0 0 0 0 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 8 8 0 0 0 4 3 0 0 0 0 9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 8 8 0 0 2 0 0 5 7 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 0 0 0 0 0 4 1 0 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 9 32 -1 -3 1 12 0 0 2 0 0 0 0 0 45 6 23 45 89 0 -234 67 -111 66 12 45 63 0 -1 -223 45 67 -36 1 3 2 -36 23 -99 0 0
Op-Code 13
Rs 0 Addre ss 0 1 2 3
Rt 8
Rd 0 na me
Immediate 9
0 60 8 0 17 0 88 90 34 9 7 1 -1 0 77 7 -777 21 17 -349 66 78 98 34 12 56 12 345 6 89 999 -345 678
$zero $a t $v 0 $v 1 $a 0 $a 1 $a 2 $a 3 $t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 $s 0 $s 1 $s 2 $s 3 $s 4 $s 5 $s 6 $s 7 $t8 $t9 $k 0 $k 1 $gp Rt 7 4 Rs 0 ALU
Control Logic
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 26 28 29 30 31
40 000 0 48
$s p $fp $ra ALU-OUT 7
Re g. File
A Register Transfer Description of the Control Logic

IR = Mem[PC] PC = PC + 4
lw or sw
Decode Instruction Read from Reg. File
beqz
Address = Rs + Offset sw lw
R-Type
If (Rs == 0 ) then PC = PC + Offset
Memory[Address] = Rt
Reg. File[Rt] = Memory[Address]
Reg. File[Rd] = Rs operation Rt
MIPS Instruction Set

See Appendix C in the textbook for a detailed description of every instruction. Arithmetic, Logic, and Shifting Instructions Conditional Branch Instructions Load and Store Instructions Function Call Instructions
Pseudo Instructions
Load Address Load Immediate Move Multiply Divide Remainder Negate la $s0, table li $v0, 10 move $t8, $sp mul $t2, $a0, $a1 div $s1, $v1, $t7 rem $s2, $v1, $t7 neg $s0, $s0
MIPS Register File

Register Naming Convention
(See Figure 1.2 on Page 4)
$0 $v0 $a0 $t0 $s0 $sp $ra
: Constant Zero : Returned values from functions : Arguments passed to functions : Temporary registers (functions) : Saved registers (main program) : Stack Pointer : Return address

Lesson #2
Exercises Chapter 1
1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 Explain the difference between a register and the ALU. Explain the difference between Assembly Language and Machine Language. Explain the difference between Cache Memory and the Register File. Explain the difference between the Instruction Register and the Program Counter. Explain the difference between a Buss and a control line. Identify a kitchen appliance that contains a finite state machine. If a 500 MHz machine takes one-clock cycle to fetch and execute an instruction, then what is the instruction execution rate of the machine? How many instructions could the above machine execute in one minute? Lets suppose we have a 40-year-old computer that has an instruction execution rate of one thousand instructions per second. How long would it take in days, hours, and minutes, to execute the same number of instructions that you derived for the 500 MHz machine? What is an algorithm?
1.10

Lesson #3
Pseudocode
Using Pseudocode to Document a MIPS Assembly Language Program
When documenting an algorithm in a language such as Pascal or C, programmers use descriptive variable names such as: speed, volume, size, count, amount, etc. After the program is compiled, these variable names correspond to memory locations. To efficiently execute code, a compiler will attempt to keep the variables that are referenced most often in processor registers because access to a variable in a processor register is much faster than access to memory. MIPS has 32 processor registers. The names used to reference these registers are defined in Figure 2.1 on page 4 in the textbook.
As an assembly language programmer you must take maximum advantage of the processor registers. For example, you may have a value in register $s0 corresponding to speed, a value in register $s1 corresponding to volume, a value in register $s2 corresponding to size, and a value in register $t3 corresponding to count.
When using pseudocode to document an assembly language program, you will be expected to use the names of the registers you intend to use in the assembly language code. It is advisable to create a cross reference table between the processor register name and what it is being used for in the program .
We use register names in pseudocode because the purpose of the pseudocode is to document an assembly language program.
Unless you identify the registers being used, the pseudocode is quite limited in terms of having any correspondence to the assembly language code. You will also find that as soon as you are able to develop the pseudocode in this format it is a very simple process to translate pseudocode into assembly language code.
Pseudocode for assembly language programs will have the appearance of Pascal or C in terms of control structures and arithmetic expressions, but descriptive variable names will usually only appear in the LOAD ADDRESS (la) instruction where there is a reference to a symbolic memory address. In assembly language you define and allocate space for variables in the data segment of memory using assembler directives such as .word and .space. You will find that all of the MIPS instructions require the use of processor registers. When writing pseudocode you should specify the processor registers you are planning to use to accomplish the task.
Now for an example, let us suppose that we want to write an assembly language program to find the sum of the integers from 1 to N. In other words do the following: 1 + 2 + 3 + 4 + 5 + 6 + 7 + ....+ N, where N is an input value.
On the next slide you will see a pseudocode description of the algorithm and following that the corresponding assembly language program, where processor register $t0 is used to accumulate the sum, and processor register $v0 is used as a loop counter. Use a word processor to create the following program file. Be sure to save as text only. Next, load the program into SPIM. Run the program and experiment with the different features of the MIPS simulator. ( For example: Single Step) Read the help file for a description of how to use the simulator.
An Example MIPS Program

# Program #1 : (descriptive name) Programmer: YOUR NAME # Due Date : Sep. 13, 2001 Course: CSCI 51A # Last Modified: Sep. 12, 2001 Section: 2 ######################################################### # Functional Description: Find the sum of the integers from 1 to N where # N is a value input from the keyboard. ######################################################### # Algorithmic Description in Pseudocode: # main: v0 << value read from the keyboard (syscall 4) # if (v0 < = 0 ) stop # t0 = 0; # t0 is used to accumulate the sum # While (v0 >= 0) { t0 = t0 + v0; v0 = v0 - 1} # Output to monitor syscall(1) << t0; goto main ########################################################## # Register Usage: $t0 is used to accumulate the sum # $v0 the loop counter, counts down to zero ##########################################################
prompt: result: bye:
main:
loop:
.data .asciiz .asciiz .asciiz .globl .text li la syscall li syscall blez li add addi bnez
"\n\n Please Input a value for N = " " The sum of the integers from 1 to N is " "\n **** Adios Amigo - Have a good day **** " main
$v0, 4 $a0, prompt $v0, 5 $v0, done $t0, 0 $t0, $t0, $v0 $v0, $v0, -1 $v0, loop # system call code for print_str # load address of prompt into a0 # print the prompt message # system call code for read_int # reads a value of N into v0 # if ( v0 < = 0 ) go to done # clear $t0 to zero # sum of integers in register $t0 # summing in reverse order # branch to loop if $v0 is !=
zero
li la syscall li move syscall b
$v0, 4 $a0, result

$v0, 1 $a0, $t0 main
# system call code for print_str # load address of message into $a0 # print the string # system call code for print_int # a0 = $t0 # prints the value in register $a0
done:
li la syscall
li syscall
$v0, 4 $a0, bye
# system call code for print_str # load address of msg. into $a0 # print the string
# terminate program # return control to
$v0, 10
system MUST HAVE A BLANK LINE AT THE END OF THE TEXT FILE
Input/Output System Calls

See Appendix A
$v0 Service Call Code Print_integer 1 Print_ string 4 Read_integer 5 Read_string 8 Exit 10 Arguments $a0 = integer $a0 = &string Results
$v0= integer $a0 = &buffer $a1 = Length of buffer
Translation of if then -- else

if ($t8 < 0) then {$s0 = 0 - $t8; $t1 = $t1 +1} else {$s0 = $t8; $t2 = $t2 + 1} Translation of pseudocode to MIPS assembly language. In MIPS assembly language, anything on a line following the number sign (#) is a comment. Notice how the comments in the code below help to make the connection back to the original pseudocode.
bgez sub addi b else:

ori addi next:
$t8, else # if ($t8 is > or = zero) branch to else $s0, $zero, $t8 # $s0 gets the negative of $t8 $t1, $t1, 1 # increment $t1 by 1 next # branch around the else code
$s0, $t8, 0 $t2, $t2, 1 # $s0 gets a copy of $t8 # increment $t2 by 1
Translation of a While statement

$v0 = 1 While ($a1 < $a2) do {$t1 = mem[$a1]; $t2 = mem[$a2]; If ($t1 != $t2) go to break; $a1 = $a1 +1; $a2 = $a2 1;} return $v0 = 0 return
break:
Here is a translation of the above while pseudocode into MIPS assembly language code. li $v0, 1 # Load $v0 with the value 1 loop: bgeu $a1, $a2, done # If( $a1 >= $a2) Branch to done lb $t1, 0($a1) # Load a Byte: $t1 = mem[$a1 + 0] lb $t2, 0($a2) # Load a Byte: $t2 = mem[$a2 + 0] bne $t1, $t2, break # If ($t1 != $t2) Branch to break addi $a1, $a1, 1 # $a1 = $a1 + 1 addi $a2, $a2, -1 # $a2 = $a2 - 1 b loop # Branch to loop break: li $v0, 0 # Load $v0 with the value 0 done:
Translation of a for loop

$a0 = 0; For ( $t0 =10; $t0 > 0; $t0 = $t0 -1) do {$a0 = $a0 + $t0}
The following is a translation of the above for-loop pseudocode
to MIPS assembly language code.
li
$a0, 0
# $a0 = 0
li
loop: add addi bgtz
$t0, 10
$a0, $a0, $t0 $t0, $t0, -1 $t0, loop
# Initialize loop counter to 10
# Decrement loop counter # If ($t0 >0) Branch to loop

Lesson #4
Translation of a switch statement

Pseudocode Description: top: $s0 = 32; cout << Input a value from 1 to 3 cin >> $v0 switch($v0) { case(1): { $s0 = $s0 << 1; break} case(2): { $s0 = $s0 << 2; break} case(3): { $s0 = $s0 << 3; break} default: goto top ; } cout <<$s0
switch statement continued

jumptable: prompt: result: main: li top: li la syscall li syscall bltz beqz li bgt la sll add lw jr $v0, 4 $a0, prompt $v0, 5 $v0, exit $v0, top $t3, 3 $v0, $t3, top $a1, jumptable $t0, $v0, 2 $t1, $a1, $t0 $t2, 0($t1) $t2 # Code to print a string $s0, 32 .data .align 2 .word top, case1, case2, case3 .asciiz "\n\n Input a value N from 1 to 3: " .asciiz " The value 32 shifted left by N bits is now = " .text
# Code to read an integer
# Default for less than one # Default for greater than 3 # Create a word offset # Form a pointer into jumptable # Load an address from jumptable # Go to specific case
switch statement continued

case1: sll b $s0, $s0, 1 done $s0, $s0, 2 done $s0, $s0, 3
case2:
sll b case3: sll done:
li la syscall li move syscall bgez

exit: li syscall
$v0, 4 $a0, result

$v0, 1 $a0, $s0
# Code to print a string

# Code to print a value
$s1, main
$v0, 10
Exercises Chapter 2
2.1 (a) Using Appendix A, translate each of the following pseudocode expressions into MIPS assembly language: t3 = t4 + t5 t6;
(b)
(c) (d) (e) (f) (g) (h)
s3 = t2 / (s1 54321);
sp = sp 16; cout << t3; cin >> t0; a0 = &array; t8 = Mem(a0); Mem(a0+ 16) = 32768;
(i)
(j) (k) (l)
cout << Hello World;

If (t0 < 0) then t7 = 0 t0 else t7 = t0; while ( t0 != 0) { s1 = s1 + t0; t2 = t2 + 4; t0 = Mem(t2) }; for ( t1 = 99; t1 > 0; t1=t1 -1) v0 = v0 + t1;
Solutions to Chap 2 Exercises

label op-code Rd, Rs, Rt
E1a: E1b: E1c: E1d: E1e:
add $t3, $t4, $t5 sub $t3, $t3, $t6 addi $s3, $s1, 54321 div $t2, $s3 mflo $s3 addi $sp, $sp, -16 move $a0, $t3 li $v0, 1 syscall li $v0, 5 syscall move $t0, $v0
Solutions to Chap 2 Exercises

label op-code Rd, Rs, Rt
E1f: E1g: E1h: E1i: E1j:
la lw
$t0, array $a0, 0($t0)
Exercises Chapter 2
(m) (n) (o) (p) (q) (r) (s) t0 = 2147483647 - 2147483648; s0 = -1 * s0; s1 = s1 * a0; s2 = srt(s02 + 56) / a3; s3 = s1 - s2 / s3; s4 = s4 * 8; s5 = * s5;
2.2 Analyze the assembly language code that you developed for each of the above pseudocode expressions and calculate the number of clock cycles required to fetch and execute the code corresponding to each expression. (Assume it takes one clock cycle to fetch and execute every instruction except multiply and divide, which require 32 clock cycles and 38 clock cycles respectively.) 2.3 Show how the following expression can be evaluated in MIPS assembly language, without modifying the contents of the s registers: $t0 = ( $s1 - $s0 / $s2) * $s4 ;
Exercises Continued
2.2 Analyze the assembly language code that you developed for each of the above pseudocode expressions and calculate the number of clock cycles required to fetch and execute the code corresponding to each expression.
(Assume it takes one clock cycle to fetch and execute every instruction
except multiply and divide, which require 32 clock cycles and 38 clock cycles respectively.) 2.3 Show how the following expression can be evaluated in MIPS assembly language, without modifying the contents of the s registers: $t0 = ( $s1 - $s0 / $s2) * $s4 ;

Lesson #5
MIPS
MIPS
Three Instruction Word Formats

Register Format
Op-Code
6
Rs
5
Rt
5
Rd
5
Code
6
Immediate Format
Op-Code 6 Rs 5 Rt 5 16 - Bit Immediate Value 16
Jump Format
Op-Code 6 26 Bit Current Segment Address 26
A Register Transfer Description of the Control Logic

IR = Mem[PC] PC = PC + 4
lw or sw
Decode Instruction Read from Reg. File
beqz
Address = Rs + Offset sw lw
R-Type
If (Rs == 0 ) then PC = PC + Offset
Memory[Address] = Rt
Reg. File[Rt] = Memory[Address]
Reg. File[Rd] = Rs operation Rt
An Example MIPS Assembly Language Program

Label
Comments
move $a0, $0 li $t0, 99 loop:
# $a0 = 0 # $t0 = 99
add $a0, $a0, $t0 addi $t0, $t0, -1 bnez $t0, loop li $v0, 1 syscall li $v0, 10 syscall
# $a0 = $a0 + $t0 # $t0 = $t0 - 1 # if ($t0 != zero) branch to loop # Print the value in $a0
# Terminate Program Run
Number Systems
Introduction Polynomial Expansion Binary Numbers Hexadecimal Numbers Twos Complement Number System Arithmetic & Overflow Detection American Standard Code for Information Interchange (ASCII)
Polynomial Expansion of a Decimal Number (Base 10)
496 = 4 x 10 + 9 x 10 + 6 x 10
10
Polynomial Expansion of a Binary Number (Base 2)
00101101 = 1 x 2 + 0 x 2 + 1 x 2 + 1 x 2 + 0 x 2 + 1x 2
2
A Faster Method
------ Double and Add
00101101 = 45
(1, 2, 5, 11, 22, 45)
Conversion of Decimal Numbers to Binary

Divide by 2 and record the remainder
45 Remainder 22 1 11 0 5 1 2 1 1 0 0 1
101101
Practice - Convert 25 to Binary

Divide by 2 and record the remainder 25 Remainder 12
To represent binary values in the positive and negative domains we use the Twos Complement Number System
Here is the polynomial expansion of a twos complement number 8-bit binary number N:
N=
- d7x2 + d6x2 + d5x2 + d4x2 + d3x2 + d2x2 + d1x2 +d0x2

7 6 5 4 3 2 1
Notice the Minus sign

*** You need to memorize powers of 2 ***
The Twos Complement Operation

When we take the twos complement of a binary number, the result will be the negative of the value we started with. For example, the binary value 00011010 is 26 in decimal.
To find the value minus 26 in binary we perform the twos complement operation on 00011010.
Scan the binary number from right to left leaving all least significant zeros (0) and the first one (1) unchanged, and then complementing the remaining digits to the left: 11100110 The result is the value minus 26 in binary.
Binary Arithmetic & Overflow Detection

in the Twos Complement Number System
Here is an addition example where we assume we are limited to 8 binary digits. 01000100 = + 00111100 = 10000000 = 68 60 -128
Overflow Occurred
Overflow
0000 1111 0 1110 -2 1101 -3 -1 1 2 0011 3 0010 0001
1100
-4
0100
-5 1011 -6 5 0101
6 1010 -7
-8 0111
7
0110
1001
1000
Binary Arithmetic
in the Twos Complement Number System
Here is a subtraction example where we assume we are limited to 8 binary digits. To subtract in binary we always add the twos complement of the subtrahend. 01000100 = 01000100 -00111100 = +11000100 00001000 = 00001000 = 68 60 8
The Rule for Detection of Overflow

################################################# Adding numbers of opposite signs, overflow is impossible. When adding numbers of the same sign, if the result is not the same as the operands then overflow occurred. #################################################
Here is an example: You are given the following two numbers in twos complement representation. Perform the binary subtraction and indicate if there is signed overflow. ______ Explain Why:
11101000 -00010011
11101000 = -24 +11101101 = -19 11010101 Correct Result = -43
Sign Extension
The value 43 as an 8-bit binary number is: 11010101 The value 43 as an 32-bit binary number is: 11111111111111111111111111010101 In Hexadecimal 43 appears as: 0xFFFFFFD5
###############################################
The value 68 as an 8-bit binary number is: 01000100 The value 68 as an 32-bit binary number is: 00000000000000000000000001000100 In Hexadecimal 68 appears as: 0x00000044
The Hexadecimal Number System

Decimal 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Hex 0 1 2 3 4 5 6 7 8 9 A B C D E F Binary 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
Here is an example of how we compactly represent binary numbers in hexadecimal: | | | | | 001111001000111101111110
0x 3 C 8 F 7 E

Lesson #6
Chapter 2 Exercises Continued

2.3 Show how the following expression can be evaluated in MIPS assembly language, without modifying the contents of the s registers:
$t0 = ( $s1 - $s0 / $s2) * $s4 ;

2.4 The datapath diagram for the MIPS architecture shown in figure 1.1 with only one memory module is referred to as a von Neumann architecture. Most implementations of the MIPS architecture use a Harvard Architecture, where there are two separate memory modules, one for instructions and the the other for data. Draw such a datapath diagram. 2.5 Show how the following pseudocode expression can be efficiently evaluated in MIPS assembly language, without modifying the contents of the s registers: $t0 = ( $s0 / 8 - 2 * $s1 + $s2 ;
Solution to Exercises 2.3 & 2.5

E2.3 div mflo sub mult mflo sra sll sub add $s0, $s2 $t0 $t0, $s1, $t0 $t0, $s4 $t0 $t0, $s0, 3 $t1, $s1, 1 $t0, $t0, $t1 $t0, $t0, $s2 Clock Cycles 38 1 1 32 1 Total= 73 1 1 1 1 Total= 4
E2.5
3.1 3.2 3.3 3.4 3.5 3.6 3.7
Convert the decimal number 35 to an 8-bit binary number. Convert the decimal number 32 to an 8-bit binary number.
Exercises
00100011 00100000
Using the double and add method convert 00010101 to a decimal number. Using the double and add method convert 00011001 to a decimal number.
21
25
Explain why the Least Significant digit of a binary number indicates if the number is odd or even. LSD is a 1 Convert the binary number 00010101 to a hexadecimal number. Convert the binary number 00011001 to a hexadecimal number. 0x15 0x19 21 25
3.8
3.9 3.10
Convert the hexadecimal number 0x15 to a decimal number.

Convert the hexadecimal number 0x19 to a decimal number.
Convert the decimal number -35 to an 8-bit twos complement binary 11011101 number.
3.11 3.12
Convert the decimal number -32 to an 8-bit twos complement binary number. 11100000 Assuming the use of the twos complement number system find the equivalent decimal values for the following 8-bit binary numbers: -127 (a) 10000001 -1 (b) 11111111 80 (c) 01010000 -32 (d) 11100000 -125 (e) 10000011 Convert the base 8 number 204 to decimal 132 Convert the base 7 number 204 to decimal 102 Convert the base 6 number 204 to decimal 76 Convert the base 5 number 204 to decimal 54 Convert the base 10 number 81 to a base 9 number. 100
Exercises
3.13 3.14
3.15
3.16 3.17
3.18
For each row of the table below convert the given 16 bit number to eachExercises of the other two bases, assuming the twos complement number system is used. 16 Bit Binary Hexadecimal Decimal
1111111100111100
0xFF88
-128 1111111111111010
0x0011
-25 3.19 You are given the following two numbers in twos complement representation. Perform the binary addition and indicate if there is signed overflow. __ Explain Why: 01101110 00011010 10001000
Yes overflow occurred Sign of the result is different from the operands
Exercises
3.20 You are given the following two numbers in twos complement representation. Perform the binary subtraction and indicate if there is signed overflow. ______ Explain Why:
11101000 -00010011
11101000 + 11101101 11010101
No Overflow
3.21
FF88 Sign extend the 8 bit hex number 0x88 to a 16 bit number. 0x_________
3.22
The following subtract instruction is located at address 0x00012344. What are the two possible values for the contents of the PC after the 00012340 0001234C branch instruction executed? 0x_____________ 0x ____________ This branch instruction is described in Appendix C. loop: addi sub bne $t4, $t4, -8 $t2, $t2, $t0 $t4, $t2,loop
Exercises
3.23 You are given the following two 8-bit binary numbers in the twos complement number system. What values do they represent in decimal? -108 44 X = 10010100 = __________ Y = 00101100 = __________ 2 10 2 10 Perform the following arithmetic operations on X and Y. Show your answers as 8-bit binary numbers in the twos complement number system. To subtract Y from X, find the twos complement of Y and add it to X. Indicate if overflow occurs in performing any of these operations. X+Y 10010100 00101100 11000000 X-Y 10010100 +11010100 01101000 Y-X 00101100 +01101100 10011000
Exercise 3.24
The following code segment is stored in memory starting at memory location 0x00012344. What are the two possible values for the contents of the PC after the branch instruction has executed? 0x__________ 00012344 0x ____________ 00012354 Add in line pseudocode to describe each instruction.
loop: lw addi andi beqz
$t0, 0($a0) $a0, $a0, 4 $t1, $t0, 1 $t1, loop
# # # #
t0 = Mem[a0] a0 = a0 +4 t1 = t1 & 1 Extract LSD if t0 is an even # go to loop

Lesson #7
SPIM - The MIPS Simulator,

Register Window Text Window Data Window Message Window Console
Text Segment
[0x00400020] [0x00400024] [0x00400028] [0x0040002c] [0x00400030] [0x00400034] [0x00400038] [0x0040003c] [0x00400040] [0x00400044] [0x00400048] [0x0040004c] [0x00400050] [0x00400054] 0x34020004 ori $2, $0, 4 ; 34: li $v0, 4 0x3c041001 lui $4, 4097 [prompt] ; 35: la $a0, prompt 0x0000000c syscall ; 36: syscall 0x34020005 ori $2, $0, 5 ; 38: li $v0, 5 0x0000000c syscall ; 39: syscall 0x1840000d blez $2 52 [end-0x00400034] ; 41: blez $v0, end 0x34080000 ori $8, $0, 0 ; 42: li $t0, 0 0x01024020 add $8, $8, $2 ; 44: add $t0, $t0, $v0 0x2042ffff addi $2, $2, -1 ; 45: addi $v0, $v0, -1 0x14403ffe bne $2, $0, -8 [loop-0x00400044]; 46: bnez $v0, loop 0x34020004 ori $2, $0, 4 ; 47: li $v0, 4 0x3c011001 lui $1, 4097 [result] ; 48: la $a0, result 0x34240022 ori $4, $1, 34 [result] 0x0000000c syscall ; 49: syscall
Analyzing the Data Segment

.data prompt: .asciiz result: .asciiz bye: .asciiz
[0x10010000] [0x10010010] [0x10010020] [0x10010030] [0x10010040]
\n Please Input a value for N = The sum of the integers from 1 to N is **** Adios Amigo Have a good day ****
0x2020200a 0x76206120 0x20200020 0x20656874 0x2031206d a e l P e s 0x 61656c50 0x49206573 0x7475706e 0x65756c61 0x726f6620 0x3d204e20 0x65685420 0x6d757320 0x20666f20 0x65746e69 0x73726567 0x6f726620 0x4e206f74 0x20736920 0x20200a00
This is an example of an addressing structure called Little Indian where the right most byte in a word has the smaller address.
Translating Assembly Language to Machine language

Use the information in Appendix C to verify that 0x3402000A is the correct machine language encoding of the instruction ori $2, $0, 10 li $v0, 10 In Appendix C we are shown how this instruction is encoded in binary ori Rt, Rs, Imm # RF[Rt] = RF[Rs] OR Imm
Op-Code Rs Rt Imm
001101ssssstttttiiiiiiiiiiiiiiii
00110100000000100000000000001010
0x 3 4 0 2 0 0 0 A
Translating Assembly Language to Machine language R-Type Instruction

Use the information in Appendix C to verify that 0x01024020 is the correct machine language encoding of the instruction add $8, $8, $2 add $t0, $t0, $v0 In Appendix C we are shown how this instruction is encoded in binary add Rd, Rs, Rt # RF[Rd] = RF[Rs] + RF[Rt]
Op-Code Rs Rt Rd Function Code
000000ssssstttttddddd00000100000
00000001000000100100000000100000
0x 0 1 0 2 4 0 2 0

Lesson #8
Exercise 4.1
Translate the following assembly language instructions to their corresponding machine language codes as they would be represented in hexadecimal. (Hint Refer to Appendix C and Appendix D.) loop: addu $a0, $0, $t0 ori $v0, $0, 4 syscall addi $t0, $t0, -1 bnez $t0, loop andi $s0, $s7, 0xffc0 or $a0, $t7, $s0 sb $a0, 4($s6) srl $s7, $s7, 4 # # # # # # # # # 0x00082021 0x34020004 0x0000000C 0x2108FFFF 0x1500FFFB 0x32F0FFC0 0x01F02025 0xA2C40004 0x0017B902
Translating Assembly Language Store Byte to Machine Language
In Appendix C we are shown how Store Byte is encoded in binary sb Rt, offset(Rs) # Mem[RF[Rs] + Offset] = RF[Rt]
Op-Code Rs Rt Offset
101000ssssstttttiiiiiiiiiiiiiiii
sb $4, 4($22) sb $a0, 4($s6)
10100010110001000000000000000100
0xA 2
0 4
Translating Assembly Language Shift Instruction to Machine Language In Appendix C we are shown how Shift Right Logical is encoded in binary
srl
Op-Code
Rd, Rs, sa
# Rs = Rt << sa
Rt Rd
sa
00000000000tttttdddddvvvvv000010
srl $23, $23, 4 srl $s7, $s7, 4
00000000000101111011100100000010
0x0 0
0 2
PCSpim Translation
[0x00082021 [0x34020004 [0x0000000c [0x2108ffff [0x1500fffc [0x32f0ffc0 [0x01f02025 [0xa2c40004 [0x0017b902 addu $4, $0, $8 ; 3: addu $a0, $0, $t0 ori $2, $0, 4 ; 4: ori $v0, $0, 4 syscall ; 5: syscall addi $8, $8, -1 ; 6: addi $t0, $t0, -1 bne $8, $0, -16 [main-0x00400030]; 7: bnez $t0, main andi $16, $23, -64 ; 8: andi $s0, $s7, 0xffc0 or $4, $15, $16 ; 9: or $a0, $t7, $s0 sb $4, 4($22) ; 10: sb $a0, 4($s6) srl $23, $23, 4 ; 11: srl $S7, $s7, 4
Exercises 4.2
What is the character string corresponding to the following ASCII codes?
Remember that for simulations running on Intelbased platforms, the characters are stored in reverse order within each word.)
0x2a2a2a2a 0x69644120 0x4120736f 0x6f67696d 0x48202d20 0x20657661
****
i d A A s o ogim H -
eva
**** Adios Amigo Have
A Function to Print a Binary Value as a Hexadecimal Number
For example suppose the following value is in $a0: 00000100101010111111010101001101
In Hexadecimal it is printed out as: 0x04ABF54D Algorithm: t2 = &buffer + 11; mem(t2) = 0; t2 = t2 1; for (t0 = 8; t0 > 0; t0 = t0 -1) {t1 = a0 & 15; t1 = t1 + 0x30; a0 = a0 >> 4; if (t1> 57) t1 = t1+7; mem(t2) = t1; t2 = t2-1} mem(t2) = x; mem(t2-1) = 0; mem(t2-2) = 0x20; print the ASCII string in the buffer
Beginning of the PrintHex Function

######################################## # Algorithmic Description in Pseudo Code: # ######################################### .globl PrintHex .data buffer: .asciiz " 0x " .text PrintHex: la $a1, buffer addi $a1, $a1, 10 # Set pointer to end of buffer ... ... ... # Body of the Algorithm ... jr $ra

Lesson #9
An Example Exam Question

Write a program that will compute the sum of the even positive values, minus the odd negative values in an array of words. Stop when a value of zero is found in the array. For Example:
array: .word -29, -30, 75, 34, -2, 90, -11, 98, 1, 0, 76
Pseudo Code for the Algorithm: $a1 = &array; $a0 = 0; loop: $t0= Mem($a1); if ($t0 == 0) go to done $a1 = $a1 + 4; $t3 = $t0 & 1; if ($t0 >= 0 & $t3 == 0) else if ($t0 < 0 & $t3 != 0) go to loop done: syscall(1) << $a0; exit
$a0 = $a0 + $t0; $a0= $a0 - $t0;
Example Exam MIPS Code

Label
array: main: la li loop: lw beqz addi andi bnez bltz add b odd: bgtz sub b done: li syscall li syscall $v0, $v0, 1 10 # Print result syscall(1) # exit $t0, loop $a0, $a0, $t0 loop $t0,0($a1) $t0, done $a1, $a1, 4 $t3, $t0, 1 $t3, odd $t0, loop $a0, $a0, $t0 loop # $t0 = Mem($a1) # $a1 = $a1 + 4 # $t3 = LSB of $t0 # branch if odd # $t2 = $t2 + $t0 $a1,array $a0, 0 # $a1 = &array # $a0 = 0
Op-Code Dest. S1,S2 Comments .data .word -29, -30, 75, 34, -2, 90, -11, 98, 1, 0, 76 .text
# $a0 = $a0 - $t0
Example Exam Questions

2. You are given the following two numbers in twos complement representation. Perform the binary subtraction and indicate if there is signed overflow ? ______ Explain Why:
10101100 00001100
10101100 11110100 10100000
3.
You are given the following two numbers in twos complement representation. Perform the binary addition and indicate if there is signed overflow ? ______ Explain Why:
10100100 + 11101100
Example Exam Questions
Sign extend the 2-digit hex number 0x90 to a 4-digit hex number. 0x_______
Show how the following PSEUDOCODE expression can be efficiently implemented in MIPS assembly language :$t0 = $s0 / 8 - 2 * $s1 + $s2;
sra sll sub add
$t0, $s0, 3 $t1, $s1, 1 $t0, $t0, $t1 $t0, $t0, $s2
Performance Evaluation
Time and Space Tradeoff The Figure of Merit (FM) we will use is: Total clock cycles required to execute the code plus total number of memory locations required to store the code. Assume: Multiplication requires 32 clock cycles Division requires 38 clock cycles System Calls Read or Write an integer: assume 200 clock cycles Read or Write a string: assume 20 clock cycles
array: msg1: msg2:
.data .word .asciiz .asciiz .globl .text li la syscall la li jal move li syscall li la syscall li move syscall li syscall
-4, 5, 8, -1 "\n The sum of the positive values = " "\n The sum of the negative values = " main
A Complete Program Example
main: $v0, 4 # system call code for print_str $a0, msg1 # load address of msg1. into $a0 # print the string $a0, array # Initialize address Parameter $a1, 4 # Initialize length Parameter sum $a0, $v0 $v0, 1 # Call sum
# move value to be printed to $a0 # system call code for print_int # print sum of positive values $v0, 4 # system call code for print_str $a0, msg2 # load address of msg2. into $a0 # print the string $v0, 1 # system call code for print_int $a0, $v1 # move value to be printed to $a0 # print sum of negative values $v0, 10 # terminate program run and # return control to system
An Example Function
sum: loop: blez addi lw addi bltz add b negg: retzz: add b jr $v1, $v1, $t0 loop $ra # Add to the negative sum # Branch to loop # Return $a1, retzz $a1, $a1, -1 $t0, 0($a0) $a0, $a0, 4 $t0, negg $v0, $v0, $t0 loop # If (a1 <= 0) Branch to Return # Decrement loop count # Get a value from the array # Increment array pointer to next word # If value is negative Branch to negg # Add to the positive sum # Branch around the next two instructions li li $v0, 0 $v1, 0
# Initialize v0 and v1 to zero
Classroom Exercises to Strengthen Your Mental Muscle

The class is presented with a challenging assembly language programming exercise. Everyone individually develops a pseudocode solution to the exercise. (5 minutes) Groups compare their pseudo-code and refine their algorithms. (5 minutes) Everyone individually develops an assembly language solution to the problem, and calculates a Figure of Merit (FM) for their solution. Groups review and compare each others code, looking for the most efficient code in terms of the Figure of Merit (FM): FM = The number of words of assembly language code plus the number of clock ticks required to execute the algorithm.
Exercise 5.1
Write a MIPS assembly language program to find the Sum of the first 100 words of data in the memory data segment with the label chico. Store the resulting sum in the next memory location beyond the end of the array chico.
Exercise 5.1 (Pseudo Code)

$a0 = &chico; # & means Address of $t0 = 0; For ($t1= 100; $t1 > 0; $t1= $t1- 1) { $t0 = $t0 + Mem($a0); $a0 = $a0 + 4; } Mem($a0) = $t0;
Exercise 5.1 (MIPS Assembly Language)

Label Op-Code Dest. S1, S2 Comments
chico: result:
.data .space .word .globl .text la li li
400 main
main: $a0, chico $t0, 0 $t1, 100 $t2, 0($a0) $t0, $t0, $t2 $a0, $a0, 4 $t1, $t1, -1 $t1, loop $t0, 0($a0) $v0, 10 # Load address pointer # Clear sum # Initialize loop count # $t2 = Mem(a0) # $t0 = $t0 + $t2 # Inc. address pointer # Dec. loop count # if ($t1 > 0) branch # Store the result # End of program
loop:
lw add addi addi bgtz sw li syscall
Exam Question #4
The following code segment is stored in memory starting at memory location 0x00067890. What are the two possible values for the contents of the PC after the branch instruction has executed? 0x________ 0x
andi $t3, $t1, 1 bnez $t3, test add $t1, $s1, $s0 test:
# # #
Solution to Exam#1 - Pseudocode

###### Solution to Exam# 1 ######## # a0 = 0 # t0 = &M # t1 = Mem(t0) # t2 = Mem(t0 + 4) # t3 = t1 & 1 # if (t3 == 0) t1 = t1 +1 # do {a0 = a0 + t1 # t1 = t1 + 2 # } while ( t1 <= t2) # syscall(1) << a0 # exit ################################
MIPS Assembly Language Code

M: N: main: li la lw lw andi bnez addi b loop: add addi $a0, $a0, $t1 $t1, $t1, 2 $t1, $t2, loop $v0, 1 $v0, 10 $a0, 0 $t0, M $t1, 0($t0) $t2, 4($t0) $t3, $t1, 1 $t3, test $t1, $t1, 1 test
.data .word .word .text
4 10
test:
ble li syscall li syscall

Lesson #10
Exercise 5.2
Write an efficient segment of MIPS assembly language code to transfer a block of 100 words starting at memory location SRC to another area of memory beginning at memory location DEST.

$a1= &SRC; # & means Address of $a2= &DEST; for ($t0 = 100; $t0 > 0; $t0 =$t0 -1) {$t1 = Mem($a1); Mem($a2) = $t1; $a1= $a1 + 4; $a2= $a2 + 4; }

Label SRC: DEST: Op-Code Dest. S1, S2 .data .space 400 .space 400 .globl main .text la la li lw sw addi addi addi bgtz li syscall $a1, SRC $a2, DEST $t0, 100 $t1, 0($a1) $t1, 0($a2) $a1, $a1,4 $a2, $a2,4 $t0, $t0, -1 $t0, loop $v0, 10 Comments
main: # $a1 = &SRC #$a2 = &DEST #$t0 = 100 #$t1= Mem($a1) #Mem($a2) = $t1 #$a1 = $a1+4 #$a2 = $a2+4 # $t0 = $t0 - 1 #Branch if $t0 > 0
loop:
Exercise 5.3
Write a MIPS function which accepts an integer word in register $a0 and returns its absolute value in $a0.
Also show an example code segment that calls the ABS function twice, to test the function.

Function ABS($a0); if ($a0 < 0) $a0 = $0 - $a0; return;

.text ABS: bgez $a0, return # If ($a0 >= 0) done sub $a0, $0, $a0 # $a0 = 0 - $a0 return: jr $ra #Return ######################################## .globl main .text main: li $a0, -9876 jal ABS li $v0, 1 # Output result syscall li $a0, 9876 jal ABS li $v0, 1 # Output result syscall li $v0,10 # End of program syscall

Lesson #11
Exercise 5.4
Write a function PENO (&X, N, SP, SN) that will find the sum of the positive and negative values in an array X of length N. "X" the address of an array, passed through $a0. "N" is the length of the array, passed through $a1. The procedure should return two values: (1) The sum of all the positive elements in the array, passed back through $v0. (2) The sum of all the negative elements in the array, passed back through $v1.

$v0 = 0; $v1 = 0; for ( ; $a1 > 0; $a1 = $a1-1) {$t0 = Mem($a0); $t1 = $t0 & 1; $a0 = $a0 + 4; if ($t0 > 0 & $t1 = 0) $v0 = $v0 + $t0; if ($t0 < 0 & $t1 != 0) $v1= $v1+ $t0; } return;

Label Op-Code Dest. S1, S2 .globl SUM .text li li LOOP: lw andi addi bltz bnez add b NEG: beqz add CHK: addi bgtz jr $a1, $a1, -1 $a1, LOOP $ra $t2, CHK $v1, $v1, $t0 $t0, 0($a0) $t2, $t0, 1 $a0, $a0, 4 $t0, NEG $t2, CHK $v0, $v0, $t0 CHK $v0, 0 $v1, 0 Comments PENO:
A Function that takes a Binary Value and prints the equivalent Decimal Representation, Right Justified This function is similar to the PrintHex function Except you Divide by 10 instead of 16 Differences: Negative values must be preceded by a Minus. Need to place Leading space spaces (ASCII 20) into the print buffer.
Exercise 5.5
Write a function SUM(N) to find the sum of the integers from 1 to N, making use the multiplication and shifting operations. The value N will be passed to the procedure in $a0 and the result will be returned in the $v0 register.
Write a MIPS assembly language main program that will call the Sum function five times each time passing a different value to the function for N, and printing the results. The values for N are defined below: .data N: .word 9, 10, 32666, 32777, 654321

Function SUM (a0: input value, $v0: output value) $v0 = $a0 + 1; $v0 = $v0 * $a0; $v0 = $v0 >> 1 #$v0 / 2; return;

.text SUM:
addi mult mflo sra
$v0, $a0, 1 $v0, $a0 $v0 $v0, $v0, 1
# $v0 = $a0 + 1 # $v0 = $v0 * $a0 # Shift right arithmetic # is the quick way to # divide by 2
jr
$ra
The Main Program

N: main: loop: lw addiu jal move li syscall addi bnez li syscall $a0, 0($s1) $s1, $s1, 4 SUM $a0, $v0 $v0, 1 $s0, $s0, -1 $s0, loop $v0, 10 .data .word 9, 10, 32666, 32777, 654321 .text li $s0, 5 la $s1, N

Lesson #12
Exercise 5.6
Write a function FIB(N, &array) to store the First N elements of the Fibonacci sequence into an array in memory. The value N is passed in $a0, and the address of the array is passed in register $a1. The first few numbers of the Fibonacci sequence are: 1, 1, 2, 3, 5, 8, 13, ............

Mem($a1) = 1; Mem($a1 + 4) = 1; for ($a0 = $a0 - 2; $a0 > 0; $a0 = $a0-1) { Mem($a1+8) = Mem($a1) + Mem($a1+4); $a1 = $a1 + 4;} return;

fib:
li sw sw addi lw lw add sw addi addi bgtz jr
$t0, 1 $t0, 0($a1) $t0, 4($a1) $a0, $a0, -2 $t0, 0($a1) $t1, 4($a1) $t0, $t0, $t1 $t0, 8($a1) $a1, $a1, 4 $a0, $a0, -1 $a0, loop $ra
loop:
Exercise 5.7
Write a function that receives 3 integer words in registers $a0, $a1, & $a2, and returns them in ordered form with the minimum value in $a0 and the maximum value in $a2.

Function Order($a0,$a1,$a2); If ($a0 > $a1) exchange $a0 and $a1; if ($a1 > $a2) exchange $a1 and $a2 else return; If ($a0 > $a1) exchange $a0 and $a1; return;.

Label order: ble move move move next: ble move move move $a1, $a2, done $t0, $a2 $a2, $a1 $a1, $t0 $a0, $a1, next $t0, $a1 $a1, $a0 $a0, $t0 Op-Code Dest. S1, S2 .text Comments
done:
ble move move move jr
$a0, $a1, done $t0, $a1 $a1, $a0 $a0, $t0 $ra
Exercise 5.8
Write the complete assembly language program,including data declarations, that corresponds to the following C code fragment. Make use of the fact that multiplication and division by powers of 2 can be performed most efficiently by shifting.
int main() { int K, Y ; int Z[50] ; Y = 56 ; K = 20 ; Z[K] = Y - 16 * ( K / 4 + 210) ; }

Label K: Y: Z: main: Op-Code Dest. S1, S2 .globl main .data .space 4 .space 1 .space 50 .text la t3, K li $t0, 56 sw $t0, 4($t3) li $t1, 20 sw $t1, 0($t3) sra $t1, $t1, 2 addi $t1, $t1, 210 sll $t1, $t1, 4 sub $t2, $t0, $t1 lw $t1, 0($t3) sll $t1, $t1, 2 addu $t1, $t1, $t3 sw $t2, 8($t1) Comments
# Y= 56 # K= 20 # K/4 # K/4 + 210 # --- x 16 # t2= Y 16 * (K / 4 + 210) # t1=K # scale K # t1= & Z[k] - 8 # Z[K]= Y-16*(k/4+210)

Lesson #13
Functional Descriptions of Code Modules

A functional description will provide the information anyone needs to know if they are searching for a function that would be useful is solving some larger programming assignment. The functional description only describes what the function does, not how it is done. The functional description must explain how arguments are passed to the function and how results are returned. The following is an example functional description: Hexout($a0: value) A 32-bit binary value is passed to the function in register $a0 and the hexadecimal equivalent is printed out right justified.
Exercise 5.9
Write a function to search through an array X of N words to find the minimum and maximum values. The address of the array will be passed to the function using register $a0, and the number of words in the array will be passed in register $a1. The minimum and maximum values are returned in registers $v0, & $v1.

MaxMin ($a0: address, $a1: number of words) $v0 = Mem($a0); $v1 = $v0; $a1 = $a1 - 1; While ($a1 > 0) {$a0 = $a0 + 4; $t0 = Mem($a0); if ($t0 < $v0) $v0 = $t0; else if ($t0 > $v1) $v1 = $t0; $a1= $a1 - 1; } return;

MaxMin: lw move addi blez loop: addi lw bge move b next: ble move chk: addi bgtz ret: $a1, $a1, -1 $a1, loop $t0, $v1, chk $v1, $t0 $a0, $a0, 4 $t0, 0($a0) $t0, $v0, next $v0, $t0 chk $v0, 0($a0) $v1, $v0 $a1, $a1, -1 $a1, ret
jr
$ra
Exercise 5.10
Write a function to find the sum of the main diagonal elements in a two dimensional N by N array of 32 bit words. The address of the array and the size N are passed to the procedure in registers $a0 and $a1 respectively. The result is returned in $v0. The values in registers $a0 and $a1 should not be modified by this procedure. Calculate the number of clock cycles required to execute your algorithm, assuming N=4
Exercise 5.10 (Pseudocode)

$v0 = Mem($a0); $t1 = $a0; $t3=($a1+1) * 4; for ($t0 = $a1-1; $t0 > 0, $t0= $t0-1) {$t1= $t1+ $t3; $v0= $v0 + Mem($t1) } return

.text mdsum: lw move addi sll addi blez loop: add lw add addi bgtz return: jr
$v0, 0($a0) # v0 = first element $t1, $a0 $t3, $a1, 1 # compute offset $t3, $t3, 2 # multiply by 4 $t0, $a1, -1 # init. loop count $t0, return $t1, $t1, $t3 # calc. next address $t2, 0($t1) # t2=Mem(t1) $v0, $v0, $t2 # add to sum $t0, $t0, -1 # decrement loop count $t0, loop $ra
Exercise 5.11
Write a function to find the determinant of a two by two matrix (array). The address of the array is passed to the function in registers $a0 and the result is returned in $v0. The value in register $a0 should not be modified by this function.
Calculate the number of clock ticks required to execute your algorithm.

$v0 = Mem($a0) * Mem($a0+12) Mem($a0+4) * Mem($a0+8); Return

.globl .text determ2: lw lw mult mflo lw lw mult mflo sub return: jr
determ2
$t0, 0($a0) $t1, 12($a0) $t1, $t0 $v0 $t0, 4($a0) $t1, 8($a0) $t1, $t0 $t0 $v0, $v0, $t0 $ra

Lesson #14
Exercise 5.12
Write a MIPS assembly language function that accepts a binary number in register $a0 and returns a value corresponding to the number of ones in the binary number.
Exercise 5.12(Pseudocode)
$v0 = 0; while ($a0 = !0) { $t0 = $a0 & 1; $a0 = $a0 >> 1; $v0 = $v0 + $t0; } Return

.globl count .text count: li $v0, 0 while: andi $t0, $a0, 1 srl $a0, $a0, 1 add $v0, $v0, $t0 bnez $a0, while jr $ra
Exercise 5.13
Translate the following pseudocode expression to MIPS assembly language code. Include code to insure that there is no array bounds violation when the store word (sw) instruction is executed. Note that the array zap is an array containing 50 words, thus the value in register $a0 must be in the range from 0 to 196. Include code to insure that the value in register $a0 is a word address offset into the array zap. If an array bounds violation is detected or the value in register $a0 is not a word address offset then branch to the label Error.
zap:
.data .space 200 .text ... zap[$a0] = $s0

$t0 = $a0 & 3; If ($t0 != 0 ) go to Error; if ($a0 < 0) go to Error if ($a0 > 196) go to Error $t0 = &zap $a0 = $a0 + $t0 Mem($a0) = $s0;

Label Op-Code Dest. S1, S2 Comments .data zap: .space 200 .text andi $t0, $a0, 3 bnez $t0, Error bltz $a0, Error li $t0, 196 bgt $a0, $t0, Error la $t0, zap add $a0, $a0, $t0 sw $s0, 0($a0)

Lesson #15
Exercise 5.14
Write a function to search through an array X of N words to find how many of the values are evenly divisible by four. The address of the array will be passed to the function using register $a0, and the number of words in the array will be passed in register $a1. Return the results in register $v0.

$v0 = 0; $t3 = 3; For ( ; $a1 > 0; $a1= $a1- 1) { $t2 = Mem ($a0); $a0 = $a0 + 4; $t0 = $t2 & t3; If ($t0 == 0 ) $v0 = $v0 + 1; } return

Div4: li li b loop: lw addi and bnez addi skip: $t2, 0($a0) $a0, $a0, 4 $t0, $t2, $t3 $t0, skip $v0, $v0, 1 $v0, 0 $t3, 3 skip
addi bgez jr
$a1, $a1, -1 $a1, loop $ra
Chapter 6 Passing Arguments on the Stack

Prog ram Counter (PC) Cache Memo ry Instruction Register Out Rs ALU
Address
Co ntrol Lo gi c
Rd
Rt
Data In Registe r File
The Stack is in Memory and Register $sp Points to the Top of Stack
Chapter 6 Passing Arguments on the Stack

An Example of Jack calling Jill(A, B, C, D, E)
addiu sw sw sw sw jal lw lw lw addiu $sp, $sp, -24 $t1, 0($sp) $t2, 4($sp) $t3, 8($sp) $ra, 20($sp) JILL $ra, 20($sp) $t4, 12($sp) $t5, 16($sp) $sp, $sp, 24 # Allocate Space on the Stack # First In Parameter A at Mem[Sp] # Second In Parameter B at Mem[Sp+ 4] # Third In Parameter C at Mem[Sp+ 8] # Save Return address # Call the Function # Restore Return Address to Main Program # Get First Out Parameter D at Mem[Sp+12] # Get Second Out Parameter E at Mem[Sp+16] # De-allocate Space on the Stack
Example of Jill accessing the Stack

JILL: lw lw lw ... ... ... sw sw jr $a0, 0($sp) $a1, 4($sp) $a2, 8($sp) # Get First In Parameter A at Mem[Sp] # Get Second In Parameter B at Mem[Sp+4] # Get Third In Parameter C at Mem[Sp+8]
<Body of Function> $v0, 12($sp) $v1, 16($sp) $ra # First Out Parameter D at Mem[Sp+12] # Second Out Parameter E at Mem[Sp+16] # Return to JACK
Example of Jack Saving Important Temporary Registers

addiu sw sw sw sw sw sw jal lw lw lw lw lw addiu $sp, $sp, -32 $t1, 0($sp) $t2, 4($sp) $t3, 8($sp) $ra, 20($sp) $t8, 24($sp) $t9, 28($sp) JILL $t8, 24($sp) $t9, 28($sp) $ra, 20($sp) $t4, 12($sp) $t5, 16($sp) $sp, $sp, 32 # Allocate More Space on the Stack <#### # First In Parameter A at Mem[Sp] # Second In Parameter B at Mem[Sp+ 4] # Third In Parameter C at Mem[Sp+ 8] # Save Return address # Save $t8 on the stack <#### # Save $t9 on the stack <#### # call the Function # Restore $t8 from the stack <#### # Restore $t9 from the stack <#### # Restore Return Address to Main Program # Get First Out Parameter D at Mem[Sp+12] # Get Second Out Parameter E at Mem[Sp+16] # De-allocate Space on the Stack <####
What if Jill Needs Additional Local Variables?

addiu $sp, $sp, -16 # Allocate Space for a Temporary array move $a0, $sp # Initialize a pointer in $a0 to the array <Use the array on the stack> addiu $sp, $sp, 16 # Deallocate Temporary Space
$sp $a0

Lesson #16
Exercise 6.1
MinMax (&X, N, Min, Max)
Write a function to search through an array 'X' of 'N' words to find the minimum and maximum values. The parameters &X and N are passed to the function on the stack, and the minimum and maximum values are returned on the stack. (Show how MinMax is called)

MinMax(&X:$t1, N:$t2, min:$t8, max:$t9) $t1 = Mem($sp); $t2 = Mem($sp+4); $t8 = Mem($t1); $t9 = $t8; $t2 = $t2 - 1; While ($t2 > 0) {$t1 = $t1 + 4; $t0 = Mem($t1); if ($t0 < $t8) $t8 = $t0; else if ($t0 > $t9) $t9 = $t0; $t2= $t2 - 1; } Mem($sp+8) = $t8; Mem($sp+12) = $t9;

##### An Example of calling the function ##### .data array .space 400 .text addiu $sp, $sp, -16 la $t0, array sw $t0, 0($sp) li $t0, 100 sw $t0, 4($sp) jal MinMax lw $t0, 8($sp) lw $t1, 12($sp) addiu $sp, $sp, 16
Exercise 6.1 MinMax(&X:$t1, N:$t2, min:$t8, max:$t9)

Label
MinMax: lw lw lw move addi blez loop: addiu lw bge move b next: ble move chk: addi bgtz ret: sw sw jr $t8, 8($sp) $t9, 12($sp) $ra # put min # put max $t2, $t2, -1 $t2, loop $t0, $t9, chk $t9, $t0 $t1, $t1, 4 $t0, 0($t1) $t0, $t8, next $t8, $t0 chk $t1, 0($sp) $t2, 4($sp) $t8, 0($t1) $t9, $t8 $t2, $t2, -1 $t2, ret # get &X # get N # Init. min # Init. max

.text
Comments

Lesson #17
Memory Layout
0x00000000 0x00400000
Reserved
Text Segment
0x10000000
Data Segment Stack Segment

0x70000000
Operating System
0xFFFFFFFF
Exercise 6.2
Search(&X, N, V, L) Write a function to sequentially search an array X of N bytes for the relative location L of a value V. The parameters &X, N, and V are passed to the procedure on the stack, and the relative location L (a number ranging from 1 to N) is returned on the stack. If the value V is not found the value -1 is returned for L.

$t3= Mem(sp); # get &X $t1= Mem($sp + 4); # get N $t0= Mem($sp + 8); # get V $t2=$t1; for ($t2 = $t2 - 1; $t2 >= 0; $t2= $t2 - 1) { $t4 = mem($t3); $t3=$t3 + 1; if ( $t4 == $t0) go to found; } Mem(sp + 12) = -1; go to exit; found: Mem(sp + 12) = $t1- $t2; exit: return;

.text search: lw lw lw move addi loop: lbu addiu beq addi bgez li sw b found: sub sw jr $t1, $t1, $ra $t1, $t2 12($sp) $t4, $t3, $t4, $t2, $t2, $t4, $t4, exit 0($t3) # get a character $t3, 1 # increment pointer $t0, found $t2, -1 # decrement loop counter loop -1 12($sp) $t3, $t1, $t0, $t2, $t2, 0($sp) 4($sp) 8($sp) $t1 $t2, -1 # get &X # get N # get V # t2 = N - 1
exit:
Exercise 6.3
Scan(&X, N, U, L, D) Write a function to scan an array 'X' of 'N' bytes counting how many bytes are ASCII codes for: a. upper case letters - U b. lower case letters - L c. decimal digits - D
Return the counts on the stack. The address of the array and the number of bytes N will be passed to the function on the stack.
Write a short main program to test this function.
A Main Program to Test the Scan Function

.data string: .asciiz The Quick Fox 0123456789 .text main: --------addiu $sp, $sp, -20 # Allocate la $t0, string sw $t0, 0($sp) li $t0, 24 sw $t0, 4($sp) jal lw lw lw addi Scan $t0, $t1, $t2, $sp,
----
8($sp) 12($sp) 16($sp) $sp, 20
# Deallocate

Scan(&X:$t6, N:$t2, U:$t3, L:$t4, D:$t5) $t6 = Mem(sp) # &X $t2 = Mem(sp+4) # N $t3=$t4=$t5=0; For ( ; $t2> 0; $t2=$t2-1) { $t1 = mem($t6) # get a byte $t6 = $t6 + 1 if ( $t1 >= 65 && $t1 <= 90 ) $t3 = $t3+1; else if ( $t1 >= 97 && $t1 <= 122) $t4=$t4+1; else if ( $t1 >= 48 && $t1 <= 57 ) $t5=$t5+1; } Mem(sp + 8 ) = $t3; Mem(sp + 12 ) = $t4; Mem(sp + 16 ) = $t5; return;
Exercise 6.3 (Assembly Language Initialize)

Scan(&X:$t6, N:$t2, U:$t3, L:$t4, D:$t5)
Label scan: Op-Code Dest. S1, S2 lw lw li li li blez li li li li addiu sw sw li li $t6, 0($sp) $t2, 4($sp) $t3, 0 $t4, 0 $t5, 0 $t2, done $t0, 48 $t9, 57 $t7, 97 $t8, 122 $sp, $sp, -8 $s6, 0($sp) $s7, 4($sp) $s6, 65 $s7, 90 Comments # Get &X # Get Value N # Count of Upper Case # Count of Lower Case # Count of Decimal Digits # ASCII 0 # ASCII 9 # ASCII a # ASCII z # Allocate Temp Space # Save s6 # Save s7 # ASCII A # ASCII Z
Exercise 6.3 (Assembly Language Body)

Label loop: Op-Code Dest. S1, S2 lbu $t1, 0($t6) addi $t6, $t6, 1 blt $t1, $s6, num bgt $t1, $s7, lowc addi $t3, $t3, 1 b check blt bgt addi b num: blt bgt addi check: addi bgtz $t2, $t2, -1 $t2, loop $t1, $t0, check # 0 $t1, $t9, check # 9 $t5, $t5, 1 Comments # A # Z
lowc: $t1, $t7, check # a $t1, $t8, check # z $t4, $t4, 1 check
Exercise 6.3 (Assembly Language Continued)

lw lw addiu sw sw sw jr
$s6, 0($sp) $s7, 4($sp) $sp, $sp, -8 $t3, 8($sp) $t4, 12($sp) $t5, 16($sp) $ra
# Restore s6 # Restore s7 # Deallocate Temp Space

Lesson #18
Exercise 6.4
Hypotenuse(A, B, H) This is an exercise in calling nested functions and passing parameters on the stack. Write a function to find the length of the hypotenuse of a right triangle whose sides are of length A and B. Assume that a math library function sqr (V, R) is available, which will compute the square root of any positive value V, and return the square root result R. Write a main program to test this function.
A Main Program to test hypotenuse

main: addi li sw li sw $sp, $t0, $t0, $t0, $t0, $sp, -12 3 0($sp) 4 4($sp) # allocate
jal
lw addi li syscall li syscall
hypotenuse
$a0, $sp, $v0, $v0, 8($sp) $sp, 12 1 10
# get result # deallocate # print result

t0 = Mem(sp); t1 = Mem(sp+4); Mem(sp+8) = sqr ( t0*t0 + t1*t1 ) ; return
Exercise 6.4 (Assembly Language)

Label Op-Code Dest. S1, S2 hypotenuse: lw $t0, 0($sp) lw $t1, 4($sp) mult $t0, $t0 mflo $t0 mult $t1, $t1 mflo $t1 add $t0, $t0, $t1 addi $sp,$sp, -12 sw $t0, 0($sp) sw $ra, 8($sp) jal sqr lw $t0, 4($sp) lw $ra, 8($sp) addi $sp, $sp, 12 sw $t0, 8($sp) jr $ra Comments # Get A # Get B
# Allocate # Pass Value to sqr # Save ra # Call sqr # Get sqr Result # Restore ra # Deallocate # Return Hypotenuse

Lesson #19
Exercise 6.5
AVA (&X, &Y, &Z, N, status) Write a function to perform an absolute value vector addition. Use the stack to pass parameters. The parameters are: the starting address of three different word arrays (vectors) : X, Y, Z, and an integer value N specifying the size of the vectors. If overflow ever occurs when executing this function, an error status of 1 should be returned and the function aborts any further processing. Otherwise, return the value 0 for status. The function will perform the vector addition: Xi = | Yi | + | Zi | ; with i going from 0 to N - 1. Also write a main program to test this function.
Example code for testing the AVA function

Label
zig: zag: zonk: msg:

`.data .space .word .word .asciiz .text addi la sw la sw la sw li sw jal lw addi beqz li la syscall li syscall
Comments
20 345, 765, -234567, 2345, 999 -38645, 765987, 67, 3215, 444 Overflow Occurred
main:
$sp, $s0, $s0, $s0, $s0, $s0, $s0, $s0, $s0, AVA $s0, $sp, $s0, $v0, $a0,
$v0,
$sp, -20 zig 0($sp) zag 4($sp) zonk 8($sp) 5 12($sp)

16($sp) $sp, 20 done 4 msg 10
# Allocate
# Deallocate
done:

AVA(&X:$t6, &Y:$t7, &Z:$t8, N:$t0, status) $t6 = Mem($sp); $t7 = Mem($sp+4); $t8 = Mem($sp+8); $t0= Mem ($sp+12); for ( ; $t0 > 0 ; $t0 = $t0 - 1) { $t1= Mem($t7); $t7 = $t7 + 4; if ($t1 < 0) $t1 = 0 - $t1; $t2= Mem($t8); $t8 = $t8 + 4; if ($t2 < 0) $t2 = 0 - $t2; $t1 = $t1 + $t2; if ($t1< 0) go to ovf; Mem($t6) = $t1; $t6 = $t6 + 4; } Mem($sp+16) = 0; return ovf: Mem($sp+16) = 1; return
Label
AVA:

lw lw lw lw lw addiu bgez sub lw addiu bgez sub add bltz sw addiu addi bgtz sw jr li sw jr .text $t6, $t7, $t8, $t0, $t1, $t7, $t1, $t1, $t2, $t8, $t2, $t2, $t1, $t1, $t1, $t6, $t0, $t0, $0, $ra 0($sp) 4($sp) 8($sp) 12($sp) 0($t7) $t7, 4 next $0, $t1 0($t8) $t8, 4 sum $0, $t2 $t1, $t2 ovf 0($t6) $t6, 4 $t0, -1 loop 16($sp)
Comments
# Get &X # Get &Y # Get &Z # Get N
loop:
next:
sum:
ovf: $t0, 1 $t0, 16($sp) $ra

Lesson #20
Exercise 6.6
Fibonacci (N, E) Write an function to return the Nth element in the Fibonacci sequence. A value N is passed to the function on the stack, and the Nth Fibonacci number E is returned on the stack. If N is greater than 46 overflow will occur, so return a value of 0 if N is greater than 46. Also show an example of calling this function to return the 10th element in the sequence. The first few numbers in the Fibonacci sequence are: 0, 1, 1, 2, 3, 5 . . . .
Example Code to Test Fibonacci

Label Op-Code Dest. S1, S2 Comments .data msg: .asciiz Can not Compute Correct Result .text main: addi $sp, $sp, -8 # Allocate li $t0, 10 # Pass argument to Fib sw $t0, 0($sp) jal Fib # Call Fibonacci lw $a0, 4($sp) # Get result back addi $sp, $sp, 8 # Deallocate bgtz $a0, done li $v0, 4 la $a0, msg syscall done: li $v0, 1 # Print result syscall li $v0, 10 syscall

$t0 = Mem($sp); if ($t0 > 46) {Mem($sp+4) = 0; Return;} If ($t0 > 1) {$t1 = 0; $t2 = 1; For ($t0 = $t0 - 1; $t0 > 0; $t0 = $t0 - 1) { $t3 = $t2 + $t1; $t1= $t2; $t2 = $t3 } } else $t3= $t0; Mem($sp+4) = $t3; Return
Exercise 6.6 (Fibonacci Assembly Language)

Label Fib: Op-Code Dest. S1, S2 lw bltz addi bgtz li li move addi blez $t0, 0($sp) $t0, error $t1, $t0, -46 $t1, error $t1, 0 $t2, 1 $t3, $t0 $t0, $t0, -1 $t0, done $t3, $t1, $t2, $t0, $t0, $t2, $t1 $t2, $t3 $t0, -1 loop # Return Nth Fibonacci number Comments # Get N
loop:
add move move addi bgtz done: sw jr error: sw jr $0, 4($sp) $ra $t3, 4($sp) $ra
Fibonacci (A Very Efficient Method)

.data fibnum: .word .word .word .word .word .text fib: lw bltz addi bgtz sll la addu lw sw jr error: sw jr 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181, 6765,10946,17711,28657,46368,75025,121393,196418,317811,514229, 832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817, 39088169,63245986,102334155,165580141,267914296, 433494437,701408733,1134903170,1836311903 $t0, 0($sp) $t0, error $t1, $t0, -46 $t1, error $t0, $t0, 2 $t1, fibnum $t0, $t1, $t0 $t0, 0($t0) $t0, 4($sp) $ra $0, 4($sp) $ra
Exercise 6.7
BubSort (&X, N) Write a function to sort an array X of N words into ascending order using the bubble sort algorithm. The address of the array and the value N will be passed to the function on the stack. Show how the sort function is called. Example Assembly Language Code to Call Sort(&Z, 1000) addi $sp, $sp, -8 la $t0, z sw $t0, 0($sp) li $t0, 1000 sw $t0, 4($sp) jal sort addi $sp, $sp, 8

BubSort (&X:$t3, N:$t0) $t0 = Mem($sp+4); Again: $t0 = $t0 - 1; $t2=0; $t3= Mem($sp); For ($t1= $t0; $t1 > 0; $t1 = $t1-1) {If ( Mem($t3) > Mem($t3+4) ) then {exchange Mem($t3) & Mem($t3+4) $t2=1} $t3= $t3 +4; } If ($t2 == 1) go to Again else return

Label
BubSort: lw again: addi li lw move loop: lw lw ble sw sw li next: addi addi bgtz bnez jr $t3, $t3, 4 $t1, $t1, -1 $t1, loop $t2, again $ra # Inc. pointer # Dec. loop count $t8, $t9, $t8, $t8, $t9, $t2, 0($t3) 4($t3) $t9, next 4($t3) 0($t3) 1 $t0, $t2, $t3, $t1, $t0, -1 0 0($sp) $t0, $t0, 4($sp) # Get N
Comments
# Clear flag # Get pointer to array # Init. loop count
# Swap values # Set Flag
Exercise 6.8
RipSort (&X, N) Write a function to sort an array X of N words into ascending order using the ripple sort algorithm. The address of the array and the value N will be passed to the function on the stack.

Function Ripsort (&X:$t3, N:$t0); $t0= Mem($sp+4); $t3= Mem($sp); For ($t0 = $t0 - 1; $t0 > 0; $t0 = $t0 -1) {$t8 = Mem($t3); $t3 = $t3 + 4; $t4 = $t3; For ($t5 = $t0; $t5 > 0; $t5 = $t5 -1) {$t9 = Mem($t4); $t4 = $t4 + 4; if ($t8 > $t9) {Mem($t3 - 4) = $t9; Mem($t4 - 4) = $t8;} } } return

Label
Ripsort: lw lw addi loop1: $t0, 4($sp) $t3, 0($sp) $t0, $t0, -1 # Get N # Get &X
Comments
lw addi move
loop2: move lw addi ble sw sw check: addi bgtz next: addi bgtz jr
$t8, 0($t3) $t3, $t3, 4 $t4, $t3

$t5, $t9, $t4, $t8, $t9, $t8, $t0 0($t4) $t4, 4 $t9, check -4($t3) -4($t4)
$t5, $t5, -1 $t5 , loop2 $t0, $t0, -1 $t0, loop1 $ra
Exercise 6.9
Roots(a, b, c, Status, R1, R2) This is an exercise in nested function calls and passing parameters on the stack. Write a procedure to calculate the roots of any quadratic equation of the form y = a*x2 + b*x + c where the integer values a, b, and c are passed to the function on the stack. Status should indicate the nature of the results returned as indicated below: 0 : 2 real roots R1 & R2 1 : 1 real root in R1= -a/b 2 : 2 complex roots of the form (R1 + i R2) 3 : no roots computed (error) Assume that a math library function sqr is available, that will compute the square root of a positive argument.
Exercise 6.9 (Roots Pseudocode)

$t0 = Mem($sp); $t1 = Mem($sp+ 4); $t2 = Mem($sp+8); if ($t2 = 0) {Mem($sp+12)=1; Mem($sp+16)= -$t0/$t1} else {$t4 = $t1; $t4 = $t1*$t4; b2 $t3 = $t2*$t1; a*c shift $t3 left by 2; $t4 =$t4-$t3 b2 - 4ac if ($t4 > 0) {Mem($sp+16)=0; $t4 = sqr($t4); Mem($sp+16) = sra[(- $t1+ $t4)/ $t0] Mem($sp+20) = sra[(- $t1- $t4)/ $t0] } else {Mem($sp+12)= 2; Mem($sp+16) = Mem($sp+20) =

Lesson #21
Reentrant Functions
It is important that all shared operating system functions and library functions running on a multi-tasking computer system be reentrant. (Examples: text-editor or compiler)
Rules for Writing Reentrant Code:

All local variables are dynamically allocated on the stack. No read/write data in the global data segment.
Reentrant I/O Functions

System services to perform I/O should be reentrant. In Chapter Five we discussed the algorithms to perform I/O in decimal and hexadecimal representation. To make these functions reentrant, allocation of space for character buffers must be removed from the global data segment and code must be inserted into the functions to dynamically allocate space on the stack for character buffers. Lets suppose you want to allocate space on the stack for an input buffer of 32 characters, initialize a pointer in $a0 to point to the first character in this buffer, and then read in a string of characters from the keyboard. This can be accomplished with the following instructions. addiu $sp, $sp, -32 move $a0, $sp li $a1, 32 li $v0, 8 syscall # Allocate Space on top of stack # Initialize $a0 as a pointer to the buffer # Specify length of buffer # System call code for Read String
Exercise 7.1
Reverse
Write a reentrant function that will read in a string of characters (60 Characters Maximum) and will print out string in reverse.
For Example the input string July is Hot will be printed out as toH si yluJ.
See Appendix A
Read String has the same semantics as the Unix library routine fgets. It reads up to n 1 characters into a buffer and terminates the string with a null byte. If fewer than n 1 characters are on the current line, Read String reads up to and including the newline and again null-terminates the string
J u l y
Ho t

sp = sp 128; a0 = sp; a1 = 61; v0 = 8; syscall; a1= sp + 127; mem(a1) = 0;
loop: t1 = mem(a0); a0 = a0 +1; if (t1 == 10) go to print; a1 = a1 1; mem(a1) = t1; go to loop; print: a0 = a1; v0 = 4; syscall; sp = sp + 128; return
# Allocate space for 2 buffers 64 bytes each # Initialize pointer to input buffer
# Read a string # Initialize pointer to end out output buffer # null terminator
# Allocate space
rev:
addi move li li li syscall addi sb lb addi beq addi sb b
$sp, $sp, 128 $a0, $sp $a1 , 61 $v0, 8 $t4, 10 $a1, $sp, 127 $0, 0($a1) $t1, 0($a0) $a0, $a0, 1 $t1, $t4, print $a1, $a1, 1 $t1, 0($a1) loop $a0, $a1 $v0, 4 $sp, $sp, 128 $ra
# Allocate buffer space ###### # Initialize pointer
# Read a string # Initialize pointer to end # null terminator
loop:
print: li li syscall addi jr
# De-allocate buffer space ####

Lesson #22
Exercise 7.2
Palindrome (b) Write a reentrant function that will determine if a string is a palindrome. The function should read in a string (14 characters max) placing them in a buffer on the stack. This procedure should call a Search function to determine the exact number of actual alphabetic characters in the string. A Boolean value of true or false (1 or 0) will be returned on the stack to indicate if the string is a palindrome.
Exercise 7.2 (Palindrome Pseudocode)

sp = sp - 16 a0 = sp a1 = 16 syscall (8) sp = sp - 20 Mem(sp) = a0 Mem(sp+4) = 16 Mem(sp+8)=10 Mem(sp+16) = $ra call srch $ra = Mem(sp+16) t8 = Mem(sp+12) sp = sp + 20 # allocate buffer on stack ####### # address of buffer # length of buffer # read a string # allocate parameter space ******* # address of string # length N # new line char # save return address # restore return address # location of \n # deallocate parameters space *****
Exercise 7.2 Palindrome Continued

t 7 = sp t8 = t7 + t8 - 2 t2 = 1 loop: if (t7 >= t8) go to end t0 = mem(t7) t1 = mem(t8) t7 = t7 + 1 t8 = t8 -1 if (t0 == t1) go to loop t2=0 end: # address of buffer # address of string end # set Boolean value to true
sp = sp + 16 Mem(sp) = t2 return
# deallocate string buffer space ####
Exercise 7.2 (Palindrome Assembly Language)

pal:
addi move li li syscall addi sw li sw li sw sw jal lw lw addi $sp, $a0, $a1, $v0, $sp, -16 $sp 16 8 #@@@@@@@@@ # Init. buffer address
$sp, $sp, -20 $t7, 0($sp) $t0, 16 $t0, 4($sp) $t0, 10 $t0, 8($sp) $ra, 16($sp) srch $ra, 16($sp) $t8, 12($sp) $sp, $sp, 20
#<<<<<<<<<<<<<<<
# Call Search(&X, N, V, L)
#<<<<<<<<<<<<<<<<
Exercise 7.2 (Palindrome Assembly Language)

move add addi li loop: bge lbu lbu addi addi beq li end: addi sw jr $sp, $sp, 16 $t2, 0($sp) $ra #@@@@@@@@@@ $t7, $t8, end $t0, 0($t7) $t1, 0($t8) $t7, $t7, 1 $t8, $t8, -1 $t0, $t1, loop $t2, 0 $t 7, $sp $t8, $t8, $t7 $t8, $t8, -2 $t2, 1 # address of buffer # init right pointer

Lesson #23
Exercise 7.6
Write an efficient MIPS assembly language function Scan(&X, Num) that will scan through a string of characters with the objective of locating where all the lower case vowels appear in the string, as well as counting how many total lower case vowels appeared in a string. Vowels are the letters a, e, i, o, u. The address of the string "X" is passed to the function on the stack, and the number of vowels found NUM is returned on the stack. A null character terminates the string. Within this function, you must include code to call any students PrintDecimal function to print, right justified, the relative position within the string where each vowel was found. Notice this will be a nested function call. Here is an example string: The quick brown fox. For the above example string the output of your program would be A Vowel was Found at Relative Position : A Vowel was Found at Relative Position : A Vowel was Found at Relative Position : A Vowel was Found at Relative Position : A Vowel was Found at Relative Position : 3 6 7 13 18
Analyze your Scan function. Is it a reentrant function? ___(yes/no) Explain why.
Exercise 7.6 (Scan Assembly Language Code)

.text scan: lw li li again: li li li li li loops: lbu beqz addi addi beq beq beq beq beq b $t7,0($t5) $t7, ends $t5, $t5, 1 $t8, $t8, 1 $t7, $t0, print $t7, $t1, print $t7, $t2, print $t7, $t3, print $t7, $t4, print loops # Get a character # Inc. string pointer # Inc. relative position $t0, 0x61 $t1, 0x65 $t2, 0x69 $t3, 0x6f $t4, 0x75 # "a" # "e" # "i" # "o" # "u" $t5, 0($sp) $t6, 0 $t8, 0 # get &X # Num # Relative Position
Exercise 7.6 (Scan Assembly Language Code)

print:
li la syscall addi $v0, 4 $a0, msg $t6, $t6, 1 # <<<<<<<<<<<<<<<< # System call code for print_str # Load address of msg. into $a0 # Print the string
addi sw sw sw sw jal lw lw lw lw addi b

ends: sw jr .data .asciiz
$sp, $sp, -16 $t8, 0($sp) $t5, 4($sp) $t6, 8($sp) $ra, 12($sp) PrintDecimal $t8, 0($sp) $t5, 4($sp) $t6, 8($sp) $ra, 12($sp) $sp, $sp, 16 again
$t6, 4($sp) $ra
# Relative Position # String pointer # Num # Call PrintDecimal
# <<<<<<<<<<<<<<<<
msg:
"\n A Vowel was Found at Relative Position: "

Lesson #24
Exercise 7.3 Iterative N Factorial

Write an iterative function to to compute N Factorial N! Calculate the number of clock cycles to compute 10!
$v0 = Mem($sp); For (a0 = $v0 1; $a0 > 0 ; $a0 = $a0 1) Label Op-Code Dest. S1, S2 Comments $v0 = $v0 * $a0; Fac: Mem($sp+4) = $v0; lw $v0, 0($sp) Return
addi $a0, $v0, -1
$a0, return $v0, $a0 $v0 $a0, $a0. -1 loopf $v0, 4($sp) $ra loopf: blez mult mflo addi b return: sw jr
Exercise 7.3 Recursive N Factorial

Write a recursive function to to compute N Factorial N! Calculate the number of clock cycles to compute 10!
$a0 = Mem($sp); Mem($sp+4) = $a0 * Fac($a0 - 1); Return
Exercise 7.3 Recursive N Factorial

FacR: lw bltz addi bgtz addiu sw sw slti beqz li b Go: addi sw jal lw lw lw mult mflo $a0, $a0, -1 $a0, 0($sp) FacR # Recursive Call $v0, 4($sp) $ra, 12($sp) $a0, 8($sp) $v0, $a0 $v0 $a0, 0($sp) $a0, Prob $t1, $a0, -13 $t1, Prob $sp, $sp, -16 $ra, 12($sp) $a0, 8($sp) $t0, $a0, 2 $t0, Go $v0, 1 facret
#<<<<<
facret:
addiu sw jr Prob: sw jr $0, 4($sp) $ra $sp, $sp, 16 #<<<< $v0, 4($sp) $ra
Exercise 7.4 Recursive Fibonacci

Fib(N, E) If (N > 1) E = Fib(N - 1) + Fib( N - 2) else E = N #########################
Fibrec: addi sw sw sw lw li bgt sw addi jr $sp, $sp, -12 $a0, 0($sp) $t0, 4($sp) $ra, 8($sp) $a0, 12($sp) $t2, 1 $a0, $t2, deep $a0, 16($sp) $sp, $sp 12 $ra # Save Registers
# Get N
# Return N!
Exercise 7.4 Recursive Fibonacci

deep: addi addi sw jal lw addi sw jal lw addi add sw return: lw lw lw addi jr $a0, 0($sp) $t0, 4($sp) $ra, 8($sp) $sp, $sp 12 $ra # Restore Registers $a0, $a0, -1 $sp, $sp, -8 $a0, 0($sp) Fibrec $t0, 4($sp) $a0, $a0, -1 $a0, 0($sp) Fibrec $a0, 4($sp) $sp, $sp, 8 $a0, $a0, $t0 $a0, 16($sp) # <<<< Allocate Space # Recursive Call # $t0 = Fib (N-1)
# Recursive Call # $a0 = Fib (N-2) # <<<< De-allocate Space # Fib (N-1) + Fib (N-2)
Exercise 7.5
Write a recursive function to find the determinant of a N x N matrix (array). The address of the array M and the size N are passed to the function on the stack, and the result R is returned on the stack: det (&M, N, R)
5 1 4 2 6
8 6 7 1 8
0 1 8 1 4
2 9 1 2 1
3 5 2 0 1
Recursive Pseudo Code for the Determinant (&M , N , R )
$t9 = Mem(sp+4); # get size N if ( $t9 < 2) { Mem(sp+8) = 0; return} If ( $t9 == 2) Mem(sp+8) = Det2 else {t5 = t9 -1 # Size of cofac matrix t4 = (t5 * t5) *4 # Dynamic storage alloc. sp = sp - t4 - 12 # Allocate space for cofac matrix + arg Mem(sp + 4) = t5 # Pass size (N-1) Mem(sp) = sp + 16 # Pass addr. cofac matrix t3=0 # accumulator for (t6 = 0; t6 < t9; t6 = t6+1) { Put col t6 cofac matrix on stack push t3,t4,t5,t6,t9 registers on stack call det(&m, n, r) restore t3,t4,t5,t6,t9 registers from the stack t5=Mem(sp+ 8) #result If (t6 && 1== 0) t3= t3 + t5 else t3= t3 - t5 } sp = sp + t4 + 12 #clean up stack return

Lesson #25
Exercise 8.1
Write your most efficient MIPS assembly language code translation for the following function and main line calling program. Note, all communication with the function must use a stack frame. Make use of the fact that multiplication and division by powers of 2 can be performed most efficiently by shifting.
void chico (int *X, int Y, int Z ) {*X = Y/ 4 - Z * 10 + *X * 8 ;}
int main() {int J, K, L , M ; cin >> J, K, L; chico ( &J, K, L); M = J - ( K + L); cout << M; return 0
}
Exercise 8.1 (Assembly Language Function)

void chico (int *X, int Y, int Z ) {*X = Y/ 4 - Z * 10 + *X * 8 ;}
chico: lw lw lw asr sll sll add sub lw sll add sw jr
$t0, 0($sp) $t1, 4($sp) $t2, 8($sp) $t1, $t1, 2 $t3, $t2, 1 $t2, $t2, 3 $t2, $t2, $t3 $t1, $t1, $t2 $t3, 0($t0) $t3, $t3, 3 $t3, $t1, $t3 $t3, 0($t0) $ra
# Get &X # Get value of Y # Get value of Z #Y/ 4
# Z * 10 # $t1 gets partial result # $t3 gets value of X #X *8 # $t3 gets result # J is assigned the result
Exercise 8.1 Main Program

Label
main: addiu <<<<1 li syscall sw move li syscall sw move li syscall sw move addi addi sw sw sw jal addiu $v0, 5 $v0, 0($sp) $s0, $v0 $v0, 5 $v0, 4($sp) $s1, $v0 $v0, 5 $v0, 8($sp) $s2, $v0 $sp, $sp, -12 $s3, $sp, 12 $s3, 0(sp) $s1, 4($sp) $s2, 8($sp) chico $sp, $sp, 12 # Put value for J : $s0 $sp, $sp, -16 # Allocate for 4 Local Main Var J,K,L,M
Comments
# Put value for K : $s1
# Put value for L :$s2 # Allocate for 3 Par. <<<<<<<<<2 # Calc. address of J < # Put address of J on stack < # Put value of K on stack < # Put value of L on stack < < # Deallocate <<<<<<<<<<<<<<<2
Exercise 8.1 Main Program Continued

M = J - ( K + L);
lw add sub
$s0, 0($sp) $s1, $s1, $s2 $a0, $s0, $s1
# Get the latest value for J #K+L # M = J - (K+L)
li syscall
addiu <<<<<<<<<<1
$v0, 1
# Print M $sp, $sp, 16 # De-allocate 4 Local Main Var
li syscall
$v0,
10

Lesson #26
Exercise 8.2
MUL32 ( m, n, p, f) Write a function MUL32( m, n, p, f) that will find the 32-bit product p of two arguments m and n. If the twos complement representation of the product cannot be represented with 32 bits, then the error flag f should be set to 1 otherwise the error flag is set to 0. Pass all arguments on the stack.

Label Mul32: Op-Code Dest. S1, S2 lw lw mult xor mflo xor bltz mfhi bgez addui bnez sw sw jr li sw jr $t3, $t4, $t3, $t5, $t6 $t7, $t7, $t8 $t5, $t8, $t8, $t6, $0, $ra 0($sp) 4($sp) $t4 $t3, $t4 $t5, $t6 ovf Comments # Get m # Get n
# Get correct sign for prod # $t6 = 32 bit product # compare signs
# $t8 = Upper 32-bits of prod
pos:
pos $t8, 1 ovf 8($sp) 12($sp)
# Check if all upper bits are 1 # product # ok
ovf: $t8, 1 $t8, 12($sp) $ra # overflow # occurred
Exercise 8.3
Adduovf ( x, y, s) Write a function Adduovf( x, y, s) that will find the 32-bit sum s of two unsigned arguments x and y. An exception should be generated if the unsigned representation of the sum results in overflow. Perform all communication on the stack. Hint:
A carry out at the most Significant Digit (MSD) is Overflow for unsigned numbers.

Adduovf ( x, y, s)
Label Op-Code Dest. S1, S2 Adduovf: lw $t3, 0($sp) lw $t4, 4($sp) addu $t5, $t4, $t3 sw $t5, 8($sp) xor $t6, $t3, $t4 bltz $t6, diff bgez $t3, ok overflow: lui $t3, 0x7FFF ori $t3, $t3, 0xFFFF addi $t3, $t3, 1 ok: jr $ra diff: bgez jr $t5, overflow $ra Comments # Get x # Get y # Get sum # Put sum on stack # Checking MSD of x and y
# Checking MSD of sum
Exercise 8.4
Write a function Add64 that will perform a 64-bit addition: x = y + z, where the values for x, y, and z are stored as two 32-bit words each: Add64(x1: $t1, x0: $t0, y1: $t3, y0: $t2, z1: $t5, z0: $t4) All six parameters are passed on the stack. If the 64-bit sum results in overflow an exception should be generated. After writing your code, calculate the performance indexes: Space:_________________(Words of code) Time: _________________(Maximum number of clock cycles to execute)
$t3 $t5 $t1 x1 Sum x0
$t2 $t4 $t0

Label Op-Code Dest. S1, S2 Add64: lw $t3, 8($sp) lw $t2, 12($sp) lw $t5, 16($sp) lw $t4, 20($sp) addu $t0, $t2, $t4 add $t1, $t3, $t5 xor $t6, $t2, $t4 bltz $t6, diff same: bgez $t2, fini carry addi $t1, $t1, 1 fini: sw $t1, 0($sp) sw $t0, 4($sp) jr $ra diff: bgez $t0, carry b fini Comments # Get y upper # Get y lower # Get z upper # Get z lower # add lower half # add upper half # Checking for a carry to upper half
# Generate carry to upper # Return x upper # Return x lower
Exercise 8.5
When the MIPS mult instruction is executed, a 64-bit product is produced. Many programs doing numerical calculations are designed to process only 32-bit results. For applications written to perform 32-bit precision arithmetic, it is extremely important to detect when the product of two numbers can not be represented with 32 bits, so that some alternative procedures may be invoked.
Write a reentrant library function anyone could use, called MUL32(m, n, p). All function parameters will be passed on the stack. This function should provide the following features: 1. If the product of the two input arguments m and n cannot be represented with 32 bits (assuming the twos complement number system), then an exception should be generated. 2. This function should also provide the following optimization features: (a) Check if m or n is zero, and return zero without taking 32 clock cycles to execute the mult instruction. (b) Check if m or n is plus one (1) or minus one (-1), and return the correct result without taking 32 clock cycles to execute the mult instruction. (c) Check if m or n is plus two (2) or minus two (-2), and return the correct result without taking 32 clock cycles to execute the mult instruction. If the product cannot be represented with 32-bits, then an exception should be generated.
Exercise 8.5 Continued

Provide inline comments and write a paragraph in English to describe all of the conditions that your code tests for to detect overflow. (HINTThe XOR instruction can be useful when writing this function.) With this function you will demonstrate how to write MIPS assembly language code involving nested function calls. Write a function to perform a vector product. vectorprod (&X, &Y, &Z, N, status). Vectorprod will call the MUL32 function. Use the stack to pass arguments. The in parameters are the starting address of three different word arrays (vectors) : X, Y, Z, and an integer value N specifying the size of the vectors. Status is an out parameter to indicate if overflow ever occurred while executing this function. The procedure will perform the vector product: Xi = Yi * Zi ; with i going from 0 to N 1 Write a MIPS assembly language main program that could be used to test the vectorprod function.

Lesson #27
A Pipelined Implementation of the MIPS Architecture
PC Data Cache Rs IR ALU Result
Address =
Rd
Data In
Register File Instruction Cache
Rt
Write Back
The True Branch Instructions

Branch if Equal: beq Rs, Rt, Label Branch if Greater Than or Equal to Zero: bgez Rs, Label Branch if Greater Than or Equal to Zero and Link: bgezal Rs, Label Branch if Greater Than Zero: bgtz Rs, Label Branch if Less Than or Equal to Zero: blez Rs, Label Branch if Less Than Zero and Link: bltzal Rs, Label Branch if Less Than Zero: bltz Rs, Label Branch if Not Equal: bne Rs, Rt, Label
Exercise 9.1
Taking into consideration delayed branches and delayed loads, write a MIPS function to search through an array X of N words to find how many of the values are evenly divisible by four. The address of the array will be passed to the function using register $a0, and the number of words in the array will be passed in register $a1. Return the results in register $v0.
Original Code - Modified Code

Label Op-Code Dest. S1, S2 Label Op-Code Dest. S1, S2
Div4: li li b loop: lw addi and bnez addi skip: $t2, 0($a0) $a0, $a0, 4 $t0, $t2, $t3 $t0, skip $v0, $v0, 1 $v0, 0 $t3, 3 skip
Div4: li b li loop: nop and bnez addi addi skip: addi bgez lw jr nop $a1, $a1, -1 $a1, loop $t2, 0($a0) $ra $t0, $t2, $t3 $t0, skip $a0, $a0, 4 $v0, $v0, 1 $v0, 0 skip $t3, 3
addi bgez jr
$a1, $a1, -1 $a1, loop $ra
Exercise 9.2
Taking into consideration delayed branches and delayed loads,
Write a MIPS function to sort an array Z of N words into ascending order using the bubble sort algorithm. The address of the array and the value N will be passed to the function on the stack. Show how the sort function is called.
Original Code to Call Sort(&Z, 1000) Modified Code to Call Sort(&Z, 1000) addi $sp, $sp, -8 addi $sp, $sp, -8 la $t0, z la $t0, z sw $t0, 0($sp) sw $t0, 0($sp) li $t0, 1000 li $t0, 1000 sw $t0, 4($sp) jal sort jal sort sw $t0, 4($sp) addi $sp, $sp, 8 addi $sp, $sp, 8

BubSort: lw again: addi li lw move loop: lw lw ble sw sw li next: addi $t3, $t3, 4 next: $t8, $t9, $t8, $t8, $t9, $t2, 0($t3) 4($t3) $t9, next 4($t3) 0($t3) 1 $t0, $t2, $t3, $t1, $t0, -1 0 0($sp) $t0, $t0, 4($sp) again: addi lw move loop: lw lw addi ble nop sw sw li $t8, $t9, $t1, $t8, 0($t3) 4($t3) $t1, -1 $t9, next $t0, $t0, -1 $t3, 0($sp) $t1, $t0, BubSort: lw li $t0, 4($sp) $t2, 0 #N
&Z
$t8, 4($t3) $t9, 0($t3) $t2, 1
addi bgtz
bnez jr
$t1, $t1, -1 $t1, loop

$t2, again $ra
bgtz addi bnez li jr nop
$t1, $t3, $t2, $t2, $ra
loop $t3, 4 again 0

Lesson #28
Exercise 9.3
Taking into consideration delayed branches and delayed loads, Write a function Adduovf( x, y, s) that will find the 32-bit sum s of two unsigned arguments x and y. An exception should be generated if the unsigned representation of the sum results in overflow.

Label Op-Code Dest. S1, S2 adduovf: lw $t3, 0($sp) lw $t4, 4($sp) addu $t5, $t4, $t3 sw $t5, 8($sp) xor $t6, $t3, $t4 bltz $t6, diff bgez $t3, ok overflow: lui $t3, 0x7FFF ori $t3, $t3, 0xFFFF addi $t3, $t3, 1 ok: jr $ra Label Op-Code Dest. S1, S2 adduovf: lw $t3, 0($sp) lw $t4, 4($sp) nop addu $t5, $t4, $t3 xor $t6, $t3, $t4 bltz $t6, diff nop bgez $t3, ok #ok overflow: ori $t3, $t3, 0xFFFF addi $t3, $t3, 1 ok: jr $ra sw $t5, 8($sp) diff: bgez lui jr nop $t5, overflow $t3, 0x7FFF $ra
diff:
bgez jr
$t5, overflow $ra
Exercise 9.4
Taking into consideration delayed branches and delayed loads, write a MIPS, function to return the Nth element in the Fibonacci sequence. The value N is passed to the function on the stack, and the Nth Fibonacci number E is returned on the stack. If N is greater than 46 overflow will occur, so return a value of 0 if N is greater than 46. Also show an example of calling this function to return the 10th element in the sequence. The first few numbers in the Fibonacci sequence are: 0, 1, 1, 2, 3, 5 . . . .

Fib: lw bltz addi bgtz li li move addi blez loop: add move move addi bgtz done: sw jr error: sw jr $0, 4($sp) $ra $t3, 4($sp) $ra $t3, $t1, $t2, $t0, $t0, $t2, $t1 $t2 $t3 $t0, -1 loop $t0, 0($sp) $t0, error $t1, $t0, -46 $t1, error $t1, 0 $t2, 1 $t3, $t0 $t0, $t0, -1 $t0, done FibD: lw li bltz addi bgtz move addi blez li Hloop: add addi move bgtz move Hdone: jr sw Herror: jr sw $ra $0, 4($sp) $ra $t3, 4($sp) $t3, $t0, $t1, $t0, $t2, $t2, $t1 $t0, -1 $t2, Hloop $t3 $t0, 0($sp) $t2, 1 $t0, Herror $t1, $t0, -46 $t1, Herror $t3, $t0 $t0, $t0, -1 $t0, Hdone $t1, 0
Embedded Processors
Memory Mapped I/O
Exercise 10.1
Random(&X, N) Write a function that will generate and store N random numbers into an array X. Use the value in register $ra as the initial seed value. A possible algorithm for generating random numbers appears below: $a0 = Mem($sp) $a1 = Mem($sp+4) $t0 = $ra for ( ; a1> 0; a1 = a1 1) {$t0 = $t0 * 2743 + 5923 Mem($a0) = t0 $a0 = $a0 + 4 } return

random: $t0 = $ra $t1 = 2743 ranloop: t0 = $t0 * $t1 $t0 = $t0 + 5923 Mem($a0) = $t0 $a0 = $a0 + 4 $a1 = $a1, -1 if ($a1 > 0) go to ranloop return

.globl random .text random: move $t0, $ra li $t1, 2743 ranloop: mult $t0, $t1 mflo $t0 addiu $t0, $t0, 5923 sw $t0, 0($a0) addi $a0, $a0, 4 addi $a1, $a1, -1 bgtz $a1, ranloop jr $ra
Testing the Random function

x: nl: .data .space 512 .asciiz "\n" .text li la jal la li addi sw sw jal addi $a1, 128 $a0, x random $s7, x $s6, 128 $sp, $sp, -8 $s7, 4($sp) $s6, 8($sp) sort $sp, $sp, 8
main:
#call Sort(&x, N)
Printing results of test

loop: li inside: lw addi jal addi bgez li la syscall addi bgtz $a0, 0($s7) $s7, $s7, 4 hexout $s0, $s0, -1 $s0, inside $v0, 4 $a0, nl # new line $s6, $s6, -8 $s6, loop $s0, 7
li $v0, 10 syscall

PPMIPS

Uploaded by

Copyright:

Available Formats

PPMIPS

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

PPMIPS

Uploaded by

Copyright:

Available Formats

What are the benefits of studying assembly language programming?

What are the benefits of studying assembly language programming?

What does the course description cover?

What does the course description cover?

MIPS Assembly Language Programming

Bob Britton, Instructor

Required Background Preparation

Benefits of Studying Assembly Language Programming

Open new opportunities in the field of embedded processors

MIPS Computer Organization

Data In Registe r File

Return values from functions Pass parameters to functions

Caller Saved Registers Use these registers in functions

An Example MIPS Assembly Language Program

move $a0, $0 li $t0, 99 loop:

Three Instruction Word Formats

Program Counter (PC) 4 Instruction Regis te r (IR)

0 60 8 0 17 0 88 90 34 9 7 1 -1 0 77 7 -777 21 17 -349 66 78 98 34 12 56 12 345 6 89 999 -345 678

$s p $fp $ra ALU-OUT 7

A Register Transfer Description of the Control Logic

Decode Instruction Read from Reg. File

If (Rs == 0 ) then PC = PC + Offset

Reg. File[Rt] = Memory[Address]

Reg. File[Rd] = Rs operation Rt

MIPS Instruction Set

MIPS Register File

$0 $v0 $a0 $t0 $s0 $sp $ra

MIPS Assembly Language Programming

MIPS Assembly Language Programming

An Example MIPS Program

prompt: result: bye:

li la syscall li move syscall b

$v0, 4 $a0, result

$v0, 4 $a0, bye

Input/Output System Calls

$v0= integer $a0 = &buffer $a1 = Length of buffer

Translation of if then -- else

bgez sub addi b else:

Translation of a While statement

Translation of a for loop

# Initialize loop counter to 10

# Decrement loop counter # If ($t0 >0) Branch to loop

MIPS Assembly Language Programming

Translation of a switch statement

switch statement continued

# Code to read an integer

switch statement continued

li la syscall li move syscall bgez

$v0, 4 $a0, result

# Code to print a string

cout << Hello World;

Solutions to Chap 2 Exercises

E1a: E1b: E1c: E1d: E1e:

Solutions to Chap 2 Exercises

E1f: E1g: E1h: E1i: E1j:

$t0, array $a0, 0($t0)

MIPS Assembly Language Programming

Three Instruction Word Formats

A Register Transfer Description of the Control Logic