Download presentation

Presentation is loading. Please wait.

Published byTobias Fallows Modified about 1 year ago

1

2
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #1

3
Required Background Preparation Two semesters of programming experience

4
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

5
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.

6
Introduction Basic Computer Organization Machine Language Assembly Language

7
MIPS

8
PowerPC

9
MIPS Computer Organization Datapath Diagram Control Logic

10
DataPath Diagram

11
0$zero 1$at 2$v0 3$v1 4$a0 5$a1 6$a2 7$a3 8$t0 9$t1 10$t2 11$t3 12$t4 13$t5 14$t6 15$t7 16$s0 17$s1 18$s2 19$s3 20$s4 21$s5 22$s6 23$s7 24$t8 NumberNameValue Register File Pass parameters to functions Return values from functions Callee-Saved Registers – Use these registers for values that must be maintained across function calls. Caller Saved Registers – Use these registers in functions

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

13
Three Instruction Word Formats Register Format Immediate Format Jump Format Op-Code Rs Rt Rd Code Op-Code Rs Rt 16 - Bit Immediate Value Op-Code 26 Bit Current Segment Address

14

15
Reg. File[Rd] = Rs operation Rt A Register Transfer Description of the Control Logic IR = Mem[PC] PC = PC + 4 Decode Instruction Read from Reg. File lw or sw Memory[Address] = Rt sw lw R-Type If (Rs == 0 ) then PC = PC + Offset beqz Address = Rs + Offset Reg. File[Rt] = Memory[Address]

16
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

17
Pseudo Instructions † Load Address la $s0, table Load Immediateli $v0, 10 Move move $t8, $sp Multiplymul $t2, $a0, $a1 Dividediv $s1, $v1, $t7 Remainderrem $s2, $v1, $t7 Negateneg $s0, $s0

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

19
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #2

20
Exercises – Chapter 1 1.1Explain the difference between a register and the ALU. 1.2Explain the difference between Assembly Language and Machine Language. 1.3Explain the difference between Cache Memory and the Register File. 1.4Explain the difference between the Instruction Register and the Program Counter. 1.5Explain the difference between a Buss and a control line. 1.6Identify a kitchen appliance that contains a finite state machine. 1.7If a 500 MHz machine takes one-clock cycle to fetch and execute an instruction, then what is the instruction execution rate of the machine? 1.8How many instructions could the above machine execute in one minute? 1.9Let’s 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? 1.10What is an algorithm?

21
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #3

22
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.

23
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.

24
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.

25
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.

26
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: 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.

27
An Example MIPS Program # Program #1 : (descriptive name) Programmer: YOUR NAME # Due Date : Sep. 13, 2001 Course: CSCI 51A # Last Modified: Sep. 12, 2001Section: 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 ##########################################################

28
.data prompt:.asciiz "\n\n Please Input a value for N = " result:.asciiz " The sum of the integers from 1 to N is " bye:.asciiz "\n **** Adios Amigo - Have a good day **** ".globlmain.text main:li$v0, 4# system call code for print_str la$a0, prompt# load address of prompt into a0 syscall# print the prompt message li$v0, 5# system call code for read_int syscall# reads a value of N into v0 blez$v0, done# if ( v0 < = 0 ) go to done li$t0, 0# clear $t0 to zero loop:add $t0, $t0, $v0# sum of integers in register $t0 addi$v0, $v0, -1# summing in reverse order bnez$v0, loop# branch to loop if $v0 is != zero li$v0, 4# system call code for print_str la$a0, result# load address of message into $a0 syscall# print the string li$v0, 1# system call code for print_int move$a0, $t0# a0 = $t0 syscall# prints the value in register $a0 b main

29
done:li$v0, 4# system call code for print_str la$a0, bye# load address of msg. into $a0 syscall# print the string li$v0, 10# terminate program syscall # return control to system MUST HAVE A BLANK LINE AT THE END OF THE TEXT FILE

30
Input/Output System Calls See Appendix A $v0 Service Call CodeArgumentsResults Print_integer1$a0 = integer Print_string4$a0 = &string Read_integer5 $v0= integer Read_string8$a0 = &buffer $a1 = Length of buffer Exit10

31
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$t8, else# if ($t8 is > or = zero) branch to else sub$s0, $zero, $t8 # $s0 gets the negative of $t8 addi$t1, $t1, 1 # increment $t1 by 1 bnext # branch around the else code else: ori$s0, $t8, 0 # $s0 gets a copy of $t8 addi$t2, $t2, 1 # increment $t2 by 1 next:

32
Translation of a “While” statement 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 bloop# Branch to loop break: li$v0, 0# Load $v0 with the value 0 done: $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 break:$v0 = 0 return

33
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$t0, 10# Initialize loop counter to 10 loop: add$a0, $a0, $t0 addi$t0, $t0, -1# Decrement loop counter bgtz$t0, loop# If ($t0 >0) Branch to loop

34
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #4

35
Translation of a “switch statement” Pseudocode Description: $s0 = 32; top: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

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

37
case1: sll$s0, $s0, 1 bdone case2: sll$s0, $s0, 2 bdone case3: sll$s0, $s0, 3 done: li$v0, 4# Code to print a string la$a0, result syscall li$v0, 1# Code to print a value move$a0, $s0 syscall bgez$s1, main exit: li$v0, 10 syscall “switch statement” continued

38
Exercises – Chapter Using Appendix A, translate each of the following pseudocode expressions into MIPS assembly language: (a)t3 = t4 + t5 – t6; (b)s3 = t2 / (s1 – 54321); (c) sp = sp – 16; (d)cout << t3; (e)cin >> t0; (f)a0 = &array; (g)t8 = Mem(a0); (h)Mem(a0+ 16) = 32768; (i)cout << “Hello World”; (j)If (t0 < 0) then t7 = 0 – t0 else t7 = t0; (k)while ( t0 != 0) { s1 = s1 + t0; t2 = t2 + 4; t0 = Mem(t2) }; (l)for ( t1 = 99; t1 > 0; t1=t1 -1) v0 = v0 + t1;

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

40
Solutions to Chap 2 Exercises label op-codeRd, Rs, Rt E1f:la $t0, array lw$a0, 0($t0) E1g: E1h: E1i: E1j:

41
Exercises – Chapter 2 (m)t0 = ; (n) s0 = -1 * s0; (o) s1 = s1 * a0; (p) s2 = srt(s ) / a3; (q) s3 = s1 - s2 / s3; (r) s4 = s4 * 8; (s)s5 = * s5; 2.2Analyze 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.3Show how the following expression can be evaluated in MIPS assembly language, without modifying the contents of the “s” registers: $t0 = ( $s1 - $s0 / $s2) * $s4 ;

42
Exercises Continued 2.2Analyze 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.3Show how the following expression can be evaluated in MIPS assembly language, without modifying the contents of the “s” registers: $t0 = ( $s1 - $s0 / $s2) * $s4 ;

43
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #5

44
MIPS

45
Three Instruction Word Formats Register Format Immediate Format Jump Format Op-Code Rs Rt Rd Code Op-Code Rs Rt 16 - Bit Immediate Value Op-Code 26 Bit Current Segment Address

46
Reg. File[Rd] = Rs operation Rt A Register Transfer Description of the Control Logic IR = Mem[PC] PC = PC + 4 Decode Instruction Read from Reg. File lw or sw Memory[Address] = Rt sw lw R-Type If (Rs == 0 ) then PC = PC + Offset beqz Address = Rs + Offset Reg. File[Rt] = Memory[Address]

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

48
Number Systems Introduction Polynomial Expansion Binary Numbers Hexadecimal Numbers Two’s Complement Number System Arithmetic & Overflow Detection American Standard Code for Information Interchange (ASCII)

49
Polynomial Expansion of a Decimal Number (Base 10) 496 = 4 x x x 10 Polynomial Expansion of a Binary Number (Base 2) = 1 x x x x x 2 + 1x A Faster Method Double and Add = 45 (1, 2, 5, 11, 22, 45)

50
Conversion of Decimal Numbers to Binary Divide by 2 and record the remainder 45 Remainder

51
Practice - Convert 25 to Binary Divide by 2 and record the remainder 25 Remainder 12

52
To represent binary values in the positive and negative domains we use the Two’s Complement Number System Here is the polynomial expansion of a two’s complement number 8-bit binary number N: N = - d 7 x2 + d 6 x2 + d 5 x2 + d 4 x2 + d 3 x2 + d 2 x2 + d 1 x2 +d 0 x2 Notice the Minus sign *** You need to memorize powers of 2 ***

53
The Two’s Complement Operation When we take the two’s complement of a binary number, the result will be the negative of the value we started with. For example, the binary value is 26 in decimal. To find the value minus 26 in binary we perform the two’s complement operation on 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: The result is the value minus 26 in binary.

54
Binary Arithmetic & Overflow Detection in the Two’s Complement Number System Here is an addition example where we assume we are limited to 8 binary digits = = = -128 Overflow Occurred

55
Overflow

56
Binary Arithmetic in the Two’s 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 two’s complement of the subtrahend = = = = 8

57
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 two’s complement representation. Perform the binary subtraction and indicate if there is signed overflow. ______ Explain Why: = = Correct Result = -43

58
Sign Extension The value –43 as an 8-bit binary number is: The value –43 as an 32-bit binary number is: In Hexadecimal –43 appears as: 0xFFFFFFD5 ############################################### The value 68 as an 8-bit binary number is: The value 68 as an 32-bit binary number is: In Hexadecimal 68 appears as: 0x

59
The Hexadecimal Number System DecimalHexBinary A B C D E F1111 Here is an example of how we compactly represent binary numbers in hexadecimal: | | | | | x 3 C 8 F 7 E

60
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #6

61
Chapter 2 Exercises Continued 2.3Show 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.4The 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.5Show how the following pseudocode expression can be efficiently evaluated in MIPS assembly language, without modifying the contents of the “s” registers: $t0 = ( $s0 / * $s1 + $s2 ;

62
Solution to Exercises 2.3 & 2.5 Clock Cycles E2.3div$s0, $s238 mflo$t0 1 sub$t0, $s1, $t0 1 mult$t0, $s432 mflo$t0 1 Total= 73 E2.5sra$t0, $s0, 3 1 sll$t1, $s1, 1 1 sub$t0, $t0, $t1 1 add$t0, $t0, $s2 1 Total= 4

63
Exercises 3.1Convert the decimal number 35 to an 8-bit binary number. 3.2Convert the decimal number 32 to an 8-bit binary number. 3.3Using the double and add method convert to a decimal number. 3.4Using the double and add method convert to a decimal number. 3.5Explain why the Least Significant digit of a binary number indicates if the number is odd or even. 3.6Convert the binary number to a hexadecimal number. 3.7Convert the binary number to a hexadecimal number. 3.8Convert the hexadecimal number 0x15 to a decimal number. 3.9Convert the hexadecimal number 0x19 to a decimal number. 3.10Convert the decimal number -35 to an 8-bit two’s complement binary number LSD is a 1 0x15 0x

64
Exercises 3.11Convert the decimal number -32 to an 8-bit two’s complement binary number. 3.12Assuming the use of the two’s complement number system find the equivalent decimal values for the following 8-bit binary numbers: (a) (b) (c) (d) (e) Convert the base 8 number 204 to decimal 3.14Convert the base 7 number 204 to decimal 3.15Convert the base 6 number 204 to decimal 3.16Convert the base 5 number 204 to decimal 3.17Convert the base 10 number 81 to a base 9 number

65
Exercises 3.18For each row of the table below convert the given 16 bit number to each of the other two bases, assuming the two’s complement number system is used. 16 Bit BinaryHexadecimalDecimal xFF x You are given the following two numbers in two’s complement representation. Perform the binary addition and indicate if there is signed overflow. __ Explain Why: Yes overflow occurred – Sign of the result is different from the operands

66
Exercises 3.20You are given the following two numbers in two’s complement representation. Perform the binary subtraction and indicate if there is signed overflow. ______ Explain Why: 3.21Sign extend the 8 bit hex number 0x88 to a 16 bit number. 0x_________ 3.22The following subtract instruction is located at address 0x What are the two possible values for the contents of the PC after the branch instructionexecuted? 0x_____________0x ____________ This branch instruction is described in Appendix C. loop:addi$t4, $t4, -8 sub$t2, $t2, $t0 bne$t4, $t2,loop No Overflow FF C

67
Exercises 3.23You are given the following two 8-bit binary numbers in the two’s complement number system. What values do they represent in decimal? X = = __________Y = = __________ Perform the following arithmetic operations on X and Y. Show your answers as 8-bit binary numbers in the two’s complement number system. To subtract Y from X, find the two’s complement of Y and add it to X. Indicate if overflow occurs in performing any of these operations. X+YX-YY-X

68
Exercise 3.24 The following code segment is stored in memory starting at memory location 0x What are the two possible values for the contents of the PC after the branch instruction has executed? 0x__________ 0x ____________ Add in line pseudocode to describe each instruction. loop:lw$t0, 0($a0)# addi$a0, $a0, 4# andi$t1, $t0, 1# beqz$t1, loop # t0 = Mem[a0] a0 = a0 +4 t1 = t1 & 1 “Extract LSD” if t0 is an even # go to loop

69
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #7

70
SPIM - The MIPS Simulator, Register Window Text Window Data Window Message Window Console

71
Text Segment [0x ] 0x ori $2, $0, 4 ; 34: li $v0, 4 [0x ] 0x3c lui $4, 4097 [prompt] ; 35: la $a0, prompt [0x ] 0x c syscall ; 36: syscall [0x c] 0x ori $2, $0, 5 ; 38: li $v0, 5 [0x ] 0x c syscall ; 39: syscall [0x ] 0x d blez $2 52 [end-0x ] ; 41: blez $v0, end [0x ] 0x ori $8, $0, 0 ; 42: li $t0, 0 [0x c] 0x add $8, $8, $2 ; 44: add $t0, $t0, $v0 [0x ] 0x2042ffff addi $2, $2, -1 ; 45: addi $v0, $v0, -1 [0x ] 0x14403ffe bne $2, $0, -8 [loop-0x ]; 46: bnez $v0, loop [0x ] 0x ori $2, $0, 4 ; 47: li $v0, 4 [0x c] 0x3c lui $1, 4097 [result] ; 48: la $a0, result [0x ] 0x ori $4, $1, 34 [result] [0x ] 0x c syscall ; 49: syscall

72
Analyzing the Data Segment a e l P e s [0x ] 0x a 0x61656c50 0x x e [0x ] 0x x65756c61 0x726f6620 0x3d204e20 [0x ] 0x x x6d x20666f20 [0x ] 0x x65746e69 0x x6f [0x ] 0x d 0x4e206f74 0x x20200a00.data 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 ****” This is an example of an addressing structure called Little Indian where the right most byte in a word has the smaller address.

73
Translating Assembly Language to Machine language Use the information in Appendix C to verify that 0x A 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 oriRt, Rs, Imm# RF[Rt] = RF[Rs] OR Imm Op-Code Rs RtImm ssssstttttiiiiiiiiiiiiiiii x A

74
Translating Assembly Language to Machine language R-Type Instruction Use the information in Appendix C to verify that 0x is the correct machine language encoding of the instruction add $8, $8, $2add $t0, $t0, $v0 In Appendix C we are shown how this instruction is encoded in binary addRd, Rs, Rt# RF[Rd] = RF[Rs] + RF[Rt] Op-Code Rs Rt Rd Function Code ssssstttttddddd x

75
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #8

76
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# 0x x x C 0x2108FFFF 0x1500FFFB 0x32F0FFC0 0x01F xA2C x0017B902

77
Translating Assembly Language Store Byte to Machine Language In Appendix C we are shown how Store Byte is encoded in binary sbRt, offset(Rs) # Mem[RF[Rs] + Offset] = RF[Rt] Op-Code Rs RtOffset ssssstttttiiiiiiiiiiiiiiii sb$4, 4($22) sb$a0, 4($s6) xA 2 C

78
Translating Assembly Language Shift Instruction to Machine Language In Appendix C we are shown how Shift Right Logical is encoded in binary srlRd, Rs, sa # Rs = Rt << sa Op-Code Rt Rd sa tttttdddddvvvvv srl$23, $23, 4srl$s7, $s7, x B 9 0 2

79
[0x addu $4, $0, $8 ; 3: addu $a0, $0, $t0 [0x ori $2, $0, 4 ; 4: ori $v0, $0, 4 [0x c syscall ; 5: syscall [0x2108ffff addi $8, $8, -1 ; 6: addi $t0, $t0, -1 [0x1500fffc bne $8, $0, -16 [main-0x ]; 7: bnez $t0, main [0x32f0ffc0 andi $16, $23, -64 ; 8: andi $s0, $s7, 0xffc0 [0x01f02025 or $4, $15, $16 ; 9: or $a0, $t7, $s0 [0xa2c40004 sb $4, 4($22) ; 10: sb $a0, 4($s6) [0x0017b902 srl $23, $23, 4 ; 11: srl $S7, $s7, 4 PCSpim Translation

80
Exercises 4.2 What is the character string corresponding to the following ASCII codes? Remember that for simulations running on Intel–based platforms, the characters are stored in reverse order within each word.) 0x2a2a2a2a 0x x f 0x6f67696d 0x48202d20 0x **** i d A A s o ogim H - eva **** Adios Amigo – Have

81
A Function to Print a Binary Value as a Hexadecimal Number For example suppose the following value is in $a0: 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

82
Beginning of the PrintHex Function ######################################## # Algorithmic Description in Pseudo Code: # #########################################.globlPrintHex.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

83
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #9

84
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) $a0 = $a0 + $t0; else if ($t0 < 0 & $t3 != 0) $a0= $a0 - $t0; go to loop done: syscall(1) << $a0; exit An Example Exam Question

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

86
2. You are given the following two numbers in two’s complement representation. Perform the binary subtraction and indicate if there is signed overflow ? ______ Explain Why: You are given the following two numbers in two’s complement representation. Perform the binary addition and indicate if there is signed overflow ? ______ Explain Why: Example Exam Questions

87
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 / * $s1 + $s2 ; sra $t0, $s0, 3 sll$t1, $s1, 1 sub$t0, $t0, $t1 add$t0, $t0, $s2

88
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

89
A Complete Program Example.data array:.word -4, 5, 8, -1 msg1:.asciiz "\n The sum of the positive values = " msg2:.asciiz "\n The sum of the negative values = ".globl main.text main: li$v0, 4# system call code for print_str la$a0, msg1# load address of msg1. into $a0 syscall# print the string la$a0, array# Initialize address Parameter li$a1, 4# Initialize length Parameter jalsum# Call sum move$a0, $v0# move value to be printed to $a0 li$v0, 1# system call code for print_int syscall# print sum of positive values li$v0, 4# system call code for print_str la$a0, msg2# load address of msg2. into $a0 syscall# print the string li$v0, 1# system call code for print_int move$a0, $v1# move value to be printed to $a0 syscall# print sum of negative values li$v0, 10# terminate program run and syscall# return control to system

90
An Example Function sum:li$v0, 0 li$v1, 0# Initialize v0 and v1 to zero loop: blez$a1, retzz# If (a1 <= 0) Branch to Return addi$a1, $a1, -1# Decrement loop count lw$t0, 0($a0)# Get a value from the array addi$a0, $a0, 4# Increment array pointer to next word bltz$t0, negg# If value is negative Branch to negg add$v0, $v0, $t0# Add to the positive sum bloop# Branch around the next two instructions negg: add$v1, $v1, $t0# Add to the negative sum bloop# Branch to loop retzz:jr$ra# Return

91
Classroom Exercises to Strengthen Your Mental Muscle The class is presented with a challenging assembly language programming exercise. Everyone individually develops a pseudo- code 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.

92
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.

93
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;

94
Exercise 5.1 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.data chico:.space400 result:.word.globlmain.text main: la $a0, chico# Load address pointer li$t0, 0 # Clear sum li$t1, 100# Initialize loop count loop: lw$t2, 0($a0)# $t2 = Mem(a0) add$t0, $t0, $t2 # $t0 = $t0 + $t2 addi$a0, $a0, 4# Inc. address pointer addi$t1, $t1, -1# Dec. loop count bgtz$t1, loop # if ($t1 > 0) branch sw$t0, 0($a0) # Store the result li$v0, 10 # End of program syscall

95
Exam Question #4 The following code segment is stored in memory starting at memory location 0x 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:

96
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 ################################

97
MIPS Assembly Language Code.data M:.word4 N:.word10.text main: li$a0, 0 la$t0, M lw$t1, 0($t0) lw$t2, 4($t0) andi$t3, $t1, 1 bnez$t3, test addi$t1, $t1, 1 btest loop: add $a0, $a0, $t1 addi $t1, $t1, 2 test: ble$t1, $t2, loop li $v0, 1 syscall li $v0, 10 syscall

98
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #10

99
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”.

100
Exercise 5.2 (Pseudo Code) $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; }

101
Exercise 5.2 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.data SRC:.space400 DEST:.space400.globlmain.text main: la $a1, SRC# $a1 = &SRC la$a2, DEST#$a2 = &DEST li$t0, 100#$t0 = 100 loop:lw$t1, 0($a1)#$t1= Mem($a1) sw$t1, 0($a2)#Mem($a2) = $t1 addi$a1, $a1,4#$a1 = $a1+4 addi$a2, $a2,4#$a2 = $a2+4 addi$t0, $t0,-1# $t0 = $t0 - 1 bgtz$t0, loop#Branch if $t0 > 0 li$v0, 10 syscall

102
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.

103
Exercise 5.3 (Pseudo Code) Function ABS($a0); if ($a0 < 0) $a0 = $0 - $a0; return;

104
Exercise 5.3 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.text ABS:bgez$a0, return# If ($a0 >= 0) done sub$a0, $0, $a0# $a0 = 0 - $a0 return:jr$ra#Return ########################################.globlmain.text main:li$a0, jalABS li$v0, 1# Output result syscall li$a0, 9876 jalABS li$v0, 1# Output result syscall li$v0,10# End of program syscall

105
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #11

106
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.

107
Exercise 5.4 (Pseudo Code) $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;

108
Exercise 5.4 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.globlSUM.text PENO: li$v0, 0 li$v1, 0 LOOP: lw$t0, 0($a0) andi$t2, $t0, 1 addi$a0, $a0, 4 bltz$t0, NEG bnez$t2, CHK add$v0, $v0, $t0 bCHK NEG: beqz$t2, CHK add$v1, $v1, $t0 CHK: addi$a1, $a1, -1 bgtz$a1, LOOP jr$ra

109
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.

110
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,

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

112
Exercise 5.5 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.text SUM: addi$v0,$a0, 1# $v0 = $a0 + 1 mult$v0, $a0# $v0 = $v0 * $a0 mflo$v0 sra$v0, $v0, 1 # Shift right arithmetic # is the quick way to # divide by 2 jr$ra

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

114
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #12

115
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,

116
Exercise 5.6 (Pseudo Code) 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;

117
Exercise 5.6 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments fib: li$t0, 1 sw$t0, 0($a1) sw$t0, 4($a1) addi$a0, $a0, -2 loop: lw$t0, 0($a1) lw$t1, 4($a1) add$t0, $t0, $t1 sw$t0, 8($a1) addi$a1, $a1, 4 addi$a0, $a0, -1 bgtz$a0, loop jr$ra

118
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.

119
Exercise 5.7 (Pseudo Code) 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;.

120
Exercise 5.7 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.text order: ble$a0, $a1, next move$t0, $a1 move$a1, $a0 move$a0, $t0 next: ble$a1, $a2, done move$t0, $a2 move$a2, $a1 move$a1, $t0 ble$a0, $a1, done move$t0, $a1 move$a1, $a0 move$a0, $t0 done:jr$ra

121
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 / ) ; }

122
Exercise 5.8 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.globlmain.data K:.space4 Y:.space1 Z:.space50.text main: lat3, K li$t0, 56 sw$t0, 4($t3)# Y= 56 li$t1, 20 sw$t1, 0($t3)# K= 20 sra$t1, $t1, 2# K/4 addi$t1, $t1, 210 # K/ sll$t1, $t1, 4# --- x 16 sub$t2, $t0, $t1# t2= Y – 16 * (K / ) lw$t1, 0($t3)# t1=K sll$t1, $t1, 2# scale K addu$t1, $t1, $t3# t1= & Z[k] - 8 sw$t2, 8($t1)# Z[K]= Y-16*(k/4+210)

123
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #13

124
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.

125
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.

126
Exercise 5.9 (Pseudo Code) 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;

127
Exercise 5.9 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments MaxMin: lw$v0, 0($a0) move$v1, $v0 addi$a1, $a1, -1 blez$a1, ret loop: addi$a0, $a0, 4 lw$t0, 0($a0) bge$t0, $v0, next move$v0, $t0 bchk next: ble$t0, $v1, chk move$v1, $t0 chk: addi$a1, $a1, -1 bgtz$a1, loop ret: jr$ra

128
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

129
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

130
Exercise 5.10 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.text mdsum: lw$v0, 0($a0)# v0 = first element move$t1, $a0 addi$t3, $a1, 1# compute offset sll$t3, $t3, 2# multiply by 4 addi$t0, $a1, -1# init. loop count blez$t0, return loop:add$t1, $t1, $t3# calc. next address lw$t2, 0($t1)# t2=Mem(t1) add$v0, $v0, $t2# add to sum addi$t0, $t0, -1# decrement loop count bgtz$t0, loop return:jr$ra

131
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.

132
Exercise 5.11 (Pseudocode) $v0 = Mem($a0) * Mem($a0+12) - Mem($a0+4) * Mem($a0+8); Return

133
Exercise 5.11 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.globldeterm2.text determ2: lw$t0, 0($a0) lw$t1, 12($a0) mult$t1, $t0 mflo$v0 lw$t0, 4($a0) lw$t1, 8($a0) mult$t1, $t0 mflo$t0 sub$v0, $v0, $t0 return: jr$ra

134
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #14

135
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 one’s in the binary number.

136
Exercise 5.12 (Pseudocode) $v0 = 0; while ($a0 = !0) { $t0 = $a0 & 1; $a0 = $a0 >> 1; $v0 = $v0 + $t0; } Return

137
Exercise 5.12 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.globlcount.text count: li$v0, 0 while: andi$t0, $a0, 1 srl$a0, $a0, 1 add$v0, $v0, $t0 bnez$a0, while jr$ra

138
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.”.data zap:.space200.text... zap[$a0] = $s0

139
Exercise 5.13 (Pseudocode) $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;

140
Exercise 5.13 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.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)

141
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #15

142
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.

143
Exercise 5.14 (Pseudocode) $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

144
Exercise 5.14 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2 Comments Div4: li$v0, 0 li$t3, 3 bskip loop: lw$t2, 0($a0) addi$a0, $a0, 4 and$t0, $t2, $t3 bnez$t0, skip addi$v0, $v0, 1 skip: addi$a1, $a1, -1 bgez$a1, loop jr$ra

145
Chapter 6 Passing Arguments on the Stack

146
The Stack is in Memory and Register $sp Points to the Top of Stack

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

148
Example of Jill accessing the Stack JILL: lw$a0, 0($sp)# Get First In Parameter “A” at Mem[Sp] lw$a1, 4($sp)# Get Second In Parameter “B” at Mem[Sp+4] lw$a2, 8($sp)# Get Third In Parameter “C” at Mem[Sp+8]... sw$v0, 12($sp)# First Out Parameter “D” at Mem[Sp+12] sw$v1, 16($sp)# Second Out Parameter “E” at Mem[Sp+16] jr$ra# Return to JACK

149
Example of Jack Saving Important Temporary Registers addiu$sp, $sp, -32# Allocate More Space on the Stack <#### sw$t1, 0($sp)# First In Parameter “A” at Mem[Sp] sw$t2, 4($sp)# Second In Parameter “B” at Mem[Sp+ 4] sw$t3, 8($sp)# Third In Parameter “C” at Mem[Sp+ 8] sw$ra, 20($sp)# Save Return address sw$t8, 24($sp)# Save $t8 on the stack <#### sw$t9, 28($sp)# Save $t9 on the stack <#### jalJILL# call the Function lw$t8, 24($sp)# Restore $t8 from the stack <#### lw$t9, 28($sp)# Restore $t9 from the stack <#### lw$ra, 20($sp)# Restore Return Address to Main Program lw$t4, 12($sp)# Get First Out Parameter “D” at Mem[Sp+12] lw$t5, 16($sp)# Get Second Out Parameter “E” at Mem[Sp+16] addiu$sp, $sp, 32# De-allocate Space on the Stack <####

150
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 addiu$sp, $sp, 16# Deallocate Temporary Space $sp $a0

151
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #16

152
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)

153
Exercise 6.1 (Pseudocode) 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;

154
Exercise 6.1 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments ##### An Example of calling the function #####.data array.space400.text addiu$sp,$sp, -16 la$t0,array sw$t0,0($sp) li$t0,100 sw$t0,4($sp) jalMinMax lw$t0,8($sp) lw$t1,12($sp) addiu$sp,$sp, 16

155
Exercise 6.1 MinMax(&X:$t1, N:$t2, min:$t8, max:$t9) LabelOp-Code Dest. S1, S2Comments.text MinMax: lw$t1, 0($sp)# get &X lw$t2, 4($sp)# get N lw$t8, 0($t1)# Init. min move$t9, $t8# Init. max addi$t2, $t2, -1 blez$t2, ret loop: addiu$t1, $t1, 4 lw$t0, 0($t1) bge$t0, $t8, next move$t8, $t0 bchk next: ble$t0, $t9, chk move$t9, $t0 chk: addi$t2, $t2, -1 bgtz$t2, loop ret: sw$t8, 8($sp)# put min sw$t9, 12($sp)# put max jr$ra

156
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #17

157
Memory Layout 0x x x x xFFFFFFFF Reserved Text Segment Data Segment Stack Segment Operating System

158
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.

159
Exercise 6.2 (Pseudocode) $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;

160
Exercise 6.2 (MIPS Assembly Language) LabelOp-Code Dest. S1, S2Comments.text search: lw$t3,0($sp)# get &X lw$t1,4($sp)# get N lw$t0,8($sp)# get V move$t2,$t1 addi$t2,$t2, -1 # t2 = N - 1 loop: lbu$t4,0($t3)# get a character addiu$t3,$t3, 1# increment pointer beq$t4,$t0, found addi$t2, $t2, -1# decrement loop counter bgez$t2, loop li$t4,-1 sw $t4,12($sp) bexit found: sub$t1,$t1, $t2 sw$t1,12($sp) exit:jr$ra

161
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.

162
A Main Program to Test the Scan Function.data string:.asciiz “The Quick Fox ”.text main: addiu$sp, $sp, -20# Allocate la$t0,string sw$t0,0($sp) li$t0,24 sw$t0,4($sp) jalScan lw$t0,8($sp) lw$t1,12($sp) lw$t2,16($sp) addi$sp,$sp, 20# Deallocate ----

163
Exercise 6.3 (Pseudocode) 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;

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

165
Exercise 6.3 (Assembly Language Body) LabelOp-Code Dest. S1, S2Comments loop:lbu$t1, 0($t6) addi$t6, $t6, 1 blt$t1, $s6, num# “A” bgt$t1, $s7, lowc# “Z” addi$t3, $t3, 1 bcheck lowc: blt$t1, $t7, check# “a” bgt$t1, $t8, check# “z” addi$t4, $t4, 1 bcheck num: blt$t1, $t0, check# “0” bgt$t1, $t9, check# “9” addi$t5, $t5, 1 check: addi$t2, $t2, -1 bgtz$t2, loop

166
Exercise 6.3 (Assembly Language Continued) LabelOp-Code Dest. S1, S2Comments lw$s6, 0($sp)# Restore s6 lw$s7, 4($sp)# Restore s7 addiu$sp, $sp, -8# Deallocate Temp Space sw$t3, 8($sp) sw$t4, 12($sp) sw$t5, 16($sp) jr$ra

167
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #18

168
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.

169
A Main Program to test hypotenuse main: addi$sp,$sp, -12# allocate li$t0,3 sw$t0,0($sp) li$t0,4 sw$t0,4($sp) jalhypotenuse lw$a0,8($sp)# get result addi$sp,$sp, 12# deallocate li$v0,1# print result syscall li$v0,10 syscall

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

171
Exercise 6.4 (Assembly Language) LabelOp-Code Dest. S1, S2Comments hypotenuse: lw$t0, 0($sp)# Get A lw$t1, 4($sp)# Get B mult$t0, $t0 mflo$t0 mult$t1, $t1 mflo$t1 add$t0, $t0, $t1 addi$sp,$sp, -12# Allocate sw$t0, 0($sp)# Pass Value to sqr sw$ra, 8($sp)# Save ra jalsqr# Call sqr lw$t0, 4($sp)# Get sqr Result lw$ra, 8($sp)# Restore ra addi$sp, $sp, 12# Deallocate sw$t0, 8($sp)# Return Hypotenuse jr$ra

172
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #19

173
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.

174
Example code for testing the AVA function LabelOp-Code Dest. S1, S2Comments `.data zig:.space20 zag:.word345, 765, , 2345, 999 zonk:.word-38645, , 67, 3215, 444 msg:.asciiz“Overflow Occurred”.text main:addi$sp, $sp, -20# Allocate la$s0, zig sw$s0, 0($sp) la$s0, zag sw$s0, 4($sp) la$s0, zonk sw$s0, 8($sp) li$s0, 5 sw$s0, 12($sp) jalAVA lw$s0, 16($sp) addi$sp, $sp, 20# Deallocate beqz$s0, done li$v0, 4 la$a0, msg syscall done:li$v0,10 syscall

175
Exercise 6.5 (Pseudocode) 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

176
Exercise 6.5 (Assembly Language) LabelOp-Code Dest. S1, S2Comments.text AVA:lw$t6, 0($sp)# Get &X lw$t7, 4($sp)# Get &Y lw$t8, 8($sp)# Get &Z lw$t0, 12($sp)# Get N loop:lw$t1, 0($t7) addiu$t7, $t7, 4 bgez$t1, next sub$t1, $0, $t1 next:lw$t2, 0($t8) addiu$t8, $t8, 4 bgez$t2, sum sub$t2, $0, $t2 sum:add$t1, $t1,$t2 bltz$t1, ovf sw$t1, 0($t6) addiu$t6, $t6, 4 addi$t0, $t0, -1 bgtz$t0, loop sw$0, 16($sp) jr$ra ovf: li$t0, 1 sw$t0, 16($sp) jr$ra

177
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #20

178
Exercise 6.6 Fibonacci (N, E) Write an function to return the N th element in the Fibonacci sequence. A value N is passed to the function on the stack, and the N th 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....

179
Example Code to Test Fibonacci LabelOp-Code Dest. S1, S2Comments.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) jalFib# 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

180
Exercise 6.6 (Pseudocode) $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

181
Exercise 6.6 (Fibonacci Assembly Language) LabelOp-Code Dest. S1, S2Comments Fib: lw$t0, 0($sp)# Get N bltz$t0, error addi$t1, $t0, -46 bgtz$t1, error li$t1, 0 li$t2, 1 move$t3, $t0 addi$t0, $t0, -1 blez$t0, done loop: add$t3, $t2, $t1 move$t1, $t2, move$t2, $t3 addi$t0, $t0, -1 bgtz$t0, loop done: sw$t3, 4($sp)# Return Nth Fibonacci number jr$ra error: sw$0, 4($sp) jr$ra

182
Fibonacci (A Very Efficient Method).data fibnum:.word0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,.word6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,.word832040, , , , , , , ,.word , , , , ,.word , , , text fib: lw$t0, 0($sp) bltz$t0, error addi$t1, $t0, -46 bgtz$t1, error sll$t0, $t0, 2 la$t1, fibnum addu$t0, $t1, $t0 lw$t0, 0($t0) sw$t0, 4($sp) jr$ra error: sw$0, 4($sp) jr$ra

183
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) jalsort addi$sp,$sp, 8

184
Exercise 6.7 (Pseudocode) 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

185
Exercise 6.7 (Assembly Language) LabelOp-Code Dest. S1, S2Comments BubSort: lw$t0, 4($sp)# Get N again: addi$t0, $t0, -1 li$t2, 0# Clear flag lw$t3, 0($sp)# Get pointer to array move$t1, $t0,# Init. loop count loop: lw$t8, 0($t3) lw$t9, 4($t3) ble$t8, $t9, next sw$t8, 4($t3)# Swap values sw$t9, 0($t3) li$t2, 1# Set Flag next: addi$t3, $t3, 4# Inc. pointer addi$t1, $t1, -1# Dec. loop count bgtz$t1, loop bnez$t2, again jr$ra

186
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.

187
Exercise 6.8 (Pseudocode) 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

188
Exercise 6.8 (Assembly Language) LabelOp-Code Dest. S1, S2Comments Ripsort: lw$t0, 4($sp)# Get N lw$t3, 0($sp)# Get &X addi$t0, $t0, -1 loop1: lw$t8, 0($t3) addi$t3, $t3, 4 move$t4, $t3 loop2: move$t5, $t0 lw$t9, 0($t4) addi$t4, $t4,4 ble$t8, $t9, check sw$t9, -4($t3) sw$t8, -4($t4) check: addi$t5, $t5, -1 bgtz$t5, loop2 next: addi$t0, $t0, -1 bgtz$t0, loop1 jr$ra

189
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*x 2 + 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.

190
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-$t3b2 - 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) =

191
Exercise 6.9 (Assembly Language)

192
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #21

193
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.

194
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# Allocate Space on top of stack move$a0, $sp# Initialize $a0 as a pointer to the buffer li$a1, 32# Specify length of buffer li$v0, 8# System call code for Read String syscall

195
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 i s H o t

196
Exercise 7.1 (Pseudocode) sp = sp – 128;# Allocate space for 2 buffers 64 bytes each a0 = sp;# Initialize pointer to input buffer a1 = 61; v0 = 8; syscall;# Read a string a1= sp + 127;# Initialize pointer to end out output buffer mem(a1) = 0;# null terminator 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;# Allocate space return

197
Exercise 7.1 (Assembly Language) rev:addi $sp, $sp, – 128# Allocate buffer space ###### move$a0, $sp# Initialize pointer li$a1, 61 li$v0, 8 li$t4, 10 syscall# Read a string addi$a1, $sp, 127# Initialize pointer to end sb$0, 0($a1)# null terminator loop: lb$t1, 0($a0) addi$a0, $a0, 1 beq$t1, $t4, print addi$a1, $a1, –1 sb$t1, 0($a1) bloop print: li$a0, $a1 li$v0, 4 syscall addi $sp, $sp, 128# De-allocate buffer space #### jr$ra

198
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #22

199
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.

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

201
Exercise 7.2 Palindrome Continued t 7 = sp# address of buffer t8 = t7 + t8 - 2# address of string end t2 = 1 # set Boolean value to true 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: sp = sp + 16# deallocate string buffer space #### Mem(sp) = t2 return

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

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

204
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #23

205
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 student’s “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 : 3 A Vowel was Found at Relative Position : 6 A Vowel was Found at Relative Position : 7 A Vowel was Found at Relative Position : 13 A Vowel was Found at Relative Position : 18 Analyze your Scan function. Is it a reentrant function? ___(yes/no) Explain why.

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

207
Exercise 7.6 (Scan Assembly Language Code) print: li$v0, 4# System call code for print_str la$a0, msg# Load address of msg. into $a0 syscall# Print the string addi$t6, $t6, 1 # <<<<<<<<<<<<<<<< addi$sp, $sp, -16 sw$t8, 0($sp)# Relative Position sw$t5, 4($sp)# String pointer sw$t6, 8($sp)# Num sw$ra, 12($sp) jalPrintDecimal# Call PrintDecimal lw$t8, 0($sp) lw$t5, 4($sp) lw$t6, 8($sp) lw$ra, 12($sp) addi$sp, $sp, 16 # <<<<<<<<<<<<<<<< bagain ends: sw$t6, 4($sp) jr$ra.data msg:.asciiz"\n A Vowel was Found at Relative Position: "

208
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #24

209
Exercise 7.3 Iterative N Factorial $v0 = Mem($sp); For (a0 = $v0 –1; $a0 > 0 ; $a0 = $a0 – 1) $v0 = $v0 * $a0; Mem($sp+4) = $v0; Return LabelOp-Code Dest. S1, S2Comments Fac: lw$v0, 0($sp) addi$a0, $v0, -1 loopf: blez$a0, return mult$v0, $a0 mflo$v0 addi$a0, $a0. -1 bloopf return: sw$v0, 4($sp) jr$ra Write an iterative function to to compute N Factorial “N!” Calculate the number of clock cycles to compute 10!

210
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

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

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

213
Exercise 7.4 Recursive Fibonacci deep: addi $a0, $a0, -1 addi$sp, $sp, -8# <<<< Allocate Space sw$a0, 0($sp) jalFibrec# Recursive Call lw$t0, 4($sp)# $t0 = Fib (N-1) addi$a0, $a0, -1 sw$a0, 0($sp) jalFibrec# Recursive Call lw$a0, 4($sp)# $a0 = Fib (N-2) addi$sp, $sp, 8# <<<< De-allocate Space add$a0, $a0, $t0# Fib (N-1) + Fib (N-2) sw$a0, 16($sp) return: lw$a0, 0($sp)# Restore Registers lw$t0, 4($sp) lw$ra, 8($sp) addi$sp, $sp 12 jr$ra

214
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)

215
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

216
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #25

217
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 }

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

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

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

221
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #26

222
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 two’s 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.

223
Exercise 8.2 (Assembly Language) LabelOp-Code Dest. S1, S2Comments Mul32: lw$t3, 0($sp)# Get m lw$t4, 4($sp)# Get n mult$t3, $t4 xor$t5, $t3, $t4# Get correct sign for prod mflo$t6# $t6 = 32 bit product xor$t7, $t5, $t6# compare signs bltz$t7, ovf mfhi$t8# $t8 = Upper 32-bits of prod bgez$t5, pos addui$t8, $t8, 1# Check if all upper bits are 1 pos:bnez$t8, ovf sw$t6, 8($sp)# product sw$0, 12($sp)# ok jr$ra ovf: li$t8, 1# overflow sw$t8, 12($sp)# occurred jr$ra

224
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.

225
Exercise 8.3 (Assembly Language) Adduovf ( x, y, s) LabelOp-Code Dest. S1, S2Comments Adduovf: lw$t3, 0($sp)# Get x lw$t4, 4($sp)# Get y addu$t5, $t4, $t3# Get sum sw$t5, 8($sp)# Put sum on stack xor$t6, $t3, $t4# Checking MSD of x and y bltz$t6, diff bgez$t3, ok overflow: lui$t3, 0x7FFF ori$t3, $t3, 0xFFFF addi$t3, $t3, 1 ok: jr$ra diff:bgez$t5, overflow# Checking MSD of sum jr$ra

226
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) $t2 $t4 $t0 $t3 $t5 $t1 x1Sumx0

227
Exercise 8.4 (Assembly Language) LabelOp-Code Dest. S1, S2Comments Add64: lw$t3, 8($sp)# Get y upper lw$t2, 12($sp)# Get y lower lw$t5, 16($sp)# Get z upper lw$t4, 20($sp)# Get z lower addu$t0, $t2, $t4# add lower half add$t1, $t3, $t5# add upper half xor$t6, $t2, $t4# Checking for a carry to upper half bltz$t6, diff same:bgez$t2, fini carryaddi$t1, $t1, 1# Generate carry to upper fini:sw$t1, 0($sp)# Return x upper sw$t0, 4($sp)# Return x lower jr$ra diff: bgez$t0, carry bfini

228
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 two’s 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.

229
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. (HINT—The 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.

230
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #27

231
A Pipelined Implementation of the MIPS Architecture

232
The True Branch Instructions Branch if Equal:beqRs, Rt, Label Branch if Greater Than or Equal to Zero:bgezRs, Label Branch if Greater Than or Equal to Zero and Link: bgezalRs, Label Branch if Greater Than Zero:bgtzRs, Label Branch if Less Than or Equal to Zero:blezRs, Label Branch if Less Than Zero and Link:bltzal Rs, Label Branch if Less Than Zero:bltzRs, Label Branch if Not Equal:bneRs, Rt, Label

233
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.

234
Original Code - Modified Code LabelOp-Code Dest. S1, S2 Div4: li$v0, 0 li$t3, 3 bskip loop: lw$t2, 0($a0) addi$a0, $a0, 4 and$t0, $t2, $t3 bnez$t0, skip addi$v0, $v0, 1 skip: addi$a1, $a1, -1 bgez$a1, loop jr$ra LabelOp-Code Dest. S1, S2 Div4: li$v0, 0 bskip li$t3, 3 loop: nop and$t0, $t2, $t3 bnez$t0, skip addi$a0, $a0, 4 addi$v0, $v0, 1 skip: addi$a1, $a1, -1 bgez$a1, loop lw$t2, 0($a0) jr$ra nop

235
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) addi$sp,$sp, -8 la$t0,z sw$t0,0($sp) li$t0,1000 sw$t0,4($sp) jalsort addi$sp,$sp, 8 Modified Code to Call Sort(&Z, 1000) addi$sp,$sp, -8 la$t0,z sw$t0,0($sp) li$t0,1000 jalsort sw$t0,4($sp) addi$sp,$sp, 8

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

237
MIPS Assembly Language Programming Bob Britton, Instructor Lesson #28

238
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.

239
Original Code - Modified Code LabelOp-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$t5, overflow jr$ra LabelOp-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$t5, overflow lui$t3, 0x7FFF jr$ra nop

240
Exercise 9.4 Taking into consideration delayed branches and delayed loads, write a MIPS, function to return the N th element in the Fibonacci sequence. The value N is passed to the function on the stack, and the N th 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....

241
Original Code - Modified Code Fib: lw$t0, 0($sp) bltz$t0, error addi$t1, $t0, -46 bgtz$t1, error li$t1, 0 li$t2, 1 move$t3, $t0 addi$t0, $t0, -1 blez$t0, done loop: add$t3, $t2, $t1 move$t1, $t2 move$t2, $t3 addi$t0, $t0, -1 bgtz$t0, loop done: sw$t3, 4($sp) jr$ra error: sw$0, 4($sp) jr$ra FibD: lw$t0, 0($sp) li$t2, 1 bltz$t0, Herror addi$t1, $t0, -46 bgtz$t1, Herror move$t3, $t0 addi$t0, $t0, -1 blez$t0, Hdone li$t1, 0 Hloop: add$t3, $t2, $t1 addi$t0, $t0, -1 move$t1, $t2, bgtz$t0, Hloop move$t2, $t3 Hdone: jr$ra sw$t3, 4($sp) Herror: jr$ra sw$0, 4($sp)

242
Embedded Processors Memory Mapped I/O

243
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 * Mem($a0) = t0 $a0 = $a0 + 4 } return

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

245
Exercise 10.1 (Assembly Language).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

246
Testing the Random function.data x:.space 512 nl:.asciiz"\n".text main: li$a1, 128 la$a0, x jalrandom la$s7, x li$s6, 128 addi$sp, $sp, -8 sw$s7, 4($sp) sw$s6, 8($sp) jalsort#call Sort(&x, N) addi$sp, $sp, 8

247
Printing results of test loop: li$s0, 7 inside: lw$a0, 0($s7) addi$s7, $s7, 4 jalhexout addi$s0, $s0, -1 bgez$s0, inside li$v0, 4 la$a0, nl syscall# new line addi$s6, $s6, -8 bgtz$s6, loop li$v0, 10 syscall

Similar presentations

© 2016 SlidePlayer.com Inc.

All rights reserved.

Ads by Google