Download presentation

Presentation is loading. Please wait.

1
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #1

2
**Required Background Preparation**

Two semesters of programming experience

3
**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

4
**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.

5
**Introduction Basic Computer Organization Machine Language**

Assembly Language

6
MIPS MIPS

7
PowerPC

8
**MIPS Computer Organization**

Datapath Diagram Control Logic

9
DataPath Diagram

10
**Register File Number Value Name Return values from functions**

Number Value Name Register File $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 Return values from functions Pass parameters to functions Caller Saved Registers – Use these registers in functions Callee-Saved Registers – Use these registers for values that must be maintained across function calls.

11
**An Example MIPS Assembly Language Program**

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

12
**Three Instruction Word Formats**

Register Format Immediate Format Jump Format Op-Code Rs Rt Rd Code Op-Code Rs Rt Bit Immediate Value Op-Code Bit Current Segment Address

14
**A Register Transfer Description of the Control Logic**

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

15
**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

16
**Pseudo Instructions † Load Address la $s0, table**

Load Immediate li $v0, 10 Move move $t8, $sp Multiply mul $t2, $a0, $a1 Divide div $s1, $v1, $t7 Remainder rem $s2, $v1, $t7 Negate neg $s0, $s0

17
**MIPS Register File Register Naming Convention $0 : Constant Zero**

(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

18
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #2

19
Exercises – Chapter 1 1.1 Explain the difference between a register and the ALU. 1.2 Explain the difference between Assembly Language and Machine Language. 1.3 Explain the difference between Cache Memory and the Register File. 1.4 Explain the difference between the Instruction Register and the Program Counter. 1.5 Explain the difference between a Buss and a control line. 1.6 Identify a kitchen appliance that contains a finite state machine. 1.7 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? 1.8 How many instructions could the above machine execute in one minute? 1.9 Let’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.10 What is an algorithm?

20
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #3

21
**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.

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

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

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

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

26
**An Example MIPS Program**

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

27
**data prompt:. asciiz. "\n\n Please Input a value for N = " result:**

.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 **** " .globl main .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

28
**done:. li. $v0, 4. # system call code for print_str. la. $a0, bye**

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

29
**Input/Output System Calls**

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

30
**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, # increment $t1 by 1 b next # branch around the else code else: ori $s0, $t8, # $s0 gets a copy of $t8 addi $t2, $t2, # increment $t2 by 1 next:

31
**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 break: $v0 = 0 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:

32
**Translation of a “for loop”**

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

33
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #4

34
**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

35
**“switch statement” continued**

.data .align 2 jumptable: .word top, 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 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

36
**“switch statement” continued**

case1: sll $s0, $s0, 1 b done case2: sll $s0, $s0, 2 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 bgez $s1, main exit: li $v0, 10

37
Exercises – Chapter 2 2.1 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;

38
**Solutions to Chap 2 Exercises**

label op-code Rd, 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 move $t0, $v0

39
**Solutions to Chap 2 Exercises**

label op-code Rd, Rs, Rt E1f: la $t0, array lw $a0, 0($t0) E1g: E1h: E1i: E1j:

40
**Exercises – Chapter 2 (m) t0 = 2147483647 - 2147483648;**

(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.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 = ( $s $s0 / $s2) * $s4 ;

41
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 = ( $s $s0 / $s2) * $s4 ;

42
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #5

43
MIPS MIPS

44
**Three Instruction Word Formats**

Register Format Immediate Format Jump Format Op-Code Rs Rt Rd Code Op-Code Rs Rt Bit Immediate Value Op-Code Bit Current Segment Address

45
**A Register Transfer Description of the Control Logic**

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

46
**An Example MIPS Assembly Language Program**

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

47
**Number Systems Introduction Polynomial Expansion Binary Numbers**

Hexadecimal Numbers Two’s Complement Number System Arithmetic & Overflow Detection American Standard Code for Information Interchange (ASCII)

48
**Polynomial Expansion of a Decimal Number (Base 10)**

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

49
**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

50
**Practice - Convert 25 to Binary**

Divide by 2 and record the remainder 25 Remainder 12

51
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 = - d7x2 + d6x2 + d5x2 + d4x2 + d3x2 + d2x2 + d1x2 +d0x2 Notice the Minus sign *** You need to memorize powers of 2 *** 7 6 5 4 3 2 1

52
**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.

53
**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. = 68 = 60 = Overflow Occurred

54
Overflow 0000 0010 0001 0011 0100 0101 0110 0111 1000 1001 1010 1011 1101 1110 1111 1 2 3 4 5 6 7 -8 -7 -6 -5 -4 -3 -2 -1 1100

55
**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

56
**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: = -24 = -19 Correct Result = -43

57
**Sign Extension The value –43 as an 8-bit binary number is: 11010101**

In Hexadecimal –43 appears as: xFFFFFFD5 ############################################### 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: x

58
**The Hexadecimal Number System**

Decimal Hex Binary 10 A 1010 11 B 1011 12 C 1100 13 D 1101 14 E 1110 15 F 1111 Here is an example of how we compactly represent binary numbers in hexadecimal: | | | | | 0x 3 C 8 F 7 E

59
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #6

60
**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 = ( $s $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 / * $s1 + $s2 ;

61
**Solution to Exercises 2.3 & 2.5**

Clock Cycles E2.3 div $s0, $s2 38 mflo $t sub $t0, $s1, $t mult $t0, $s4 32 Total= 73 E2.5 sra $t0, $s0, sll $t1, $s1, sub $t0, $t0, $t add $t0, $t0, $s Total= 4

62
**Exercises 3.1 Convert the decimal number 35 to an 8-bit binary number.**

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

63
**Exercises 3.11 Convert the decimal number -32 to an 8-bit**

two’s complement binary number. 3.12 Assuming 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) 3.13 Convert the base 8 number 204 to decimal 3.14 Convert the base 7 number 204 to decimal 3.15 Convert the base 6 number 204 to decimal 3.16 Convert the base 5 number 204 to decimal 3.17 Convert the base 10 number 81 to a base 9 number. -127 -1 80 -32 -125 132 102 76 54 100

64
**3.18 For 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 Binary Hexadecimal Decimal 0xFF88 -128 0x0011 -25 3.19 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: Exercises Yes overflow occurred – Sign of the result is different from the operands

65
Exercises 3.20 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: No Overflow FF88 C 3.21 Sign extend the 8 bit hex number 0x88 to a 16 bit number. 0x_________ 3.22 The following subtract instruction is located at address 0x What are the two possible values for the contents of the PC after the branch instruction executed? 0x_____________ 0x ____________ This branch instruction is described in Appendix C. loop: addi $t4, $t4, -8 sub $t2, $t2, $t0 bne $t4, $t2,loop

66
Exercises 3.23 You 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+Y X-Y Y-X

67
**Exercise 3.24 loop: lw $t0, 0($a0) # addi $a0, $a0, 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 ____________ 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

68
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #7

69
**SPIM - The MIPS Simulator,**

Register Window Text Window Data Window Message Window Console

70
**Text Segment [0x00400020] 0x34020004 ori $2, $0, 4 ; 34: li $v0, 4**

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

71
**Analyzing the Data Segment**

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

72
**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, 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 0x A

73
**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, $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 000000ssssstttttddddd 0x

74
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #8

75
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 0x 0x C 0x2108FFFF 0x1500FFFB 0x32F0FFC0 0x01F02025 0xA2C40004 0x0017B902

76
**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) 0xA C

77
**Translating Assembly Language Shift Instruction to Machine Language**

In Appendix C we are shown how Shift Right Logical is encoded in binary srl Rd, Rs, sa # Rs = Rt << sa Op-Code Rt Rd sa tttttdddddvvvvv000010 srl $23, $23, 4 srl $s7, $s7, 4 0x B

78
**PCSpim Translation [0x00082021 addu $4, $0, $8 ; 3: addu $a0, $0, $t0**

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

79
****** Adios Amigo – Have Exercises 4.2 **** i d A A s o ogim H - eva**

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

80
**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

81
**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

82
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #9

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

84
**Example Exam MIPS Code Label Op-Code Dest. S1,S2 Comments .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 b loop odd: bgtz $t0, loop sub $a0, $a0, $t0 # $a0 = $a0 - $t0 done: li $v0, 1 # Print result syscall(1) syscall li $v0, 10 # exit

85
**Example Exam Questions**

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 ? ______

86
**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

87
**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

88
**A Complete Program Example**

.data array: .word , 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 jal sum # 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 la $a0, msg2 # load address of msg2. into $a0 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 A Complete Program Example

89
**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 b loop # Branch around the next two instructions negg: add $v1, $v1, $t0 # Add to the negative sum b loop # Branch to loop retzz: jr $ra # Return

90
**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.

91
**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.

92
**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;

93
**Exercise 5.1 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments .data chico: .space 400 result: .word .globl main .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

94
**Exam Question #4 bnez $t3, test # add $t1, $s1, $s0 # test:**

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:

95
**Solution to Exam#1 - Pseudocode**

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

96
**MIPS Assembly Language Code**

.data M: .word 4 N: .word 10 .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 b test loop: add $a0, $a0, $t1 addi $t1, $t1, 2 test: ble $t1, $t2, loop li $v0, 1 syscall li $v0, 10

97
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #10

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

99
**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; }

100
**Exercise 5.2 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments .data SRC: .space 400 DEST: .space 400 .globl main .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

101
**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.

102
**Exercise 5.3 (Pseudo Code)**

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

103
**Exercise 5.3 (MIPS Assembly Language)**

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

104
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #11

105
**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.

106
**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;

107
**Exercise 5.4 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments .globl SUM .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 b CHK NEG: beqz $t2, CHK add $v1, $v1, $t0 CHK: addi $a1, $a1, -1 bgtz $a1, LOOP jr $ra

108
**Except you Divide by 10 instead of 16**

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.

109
**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,

110
**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;

111
**Exercise 5.5 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments .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

112
**The Main Program .data N: .word 9, 10, 32666, 32777, 654321 .text**

main: li $s0, 5 la $s1, N loop: lw $a0, 0($s1) addiu $s1, $s1, 4 jal SUM move $a0, $v0 li $v0, 1 syscall addi $s0, $s0, -1 bnez $s0, loop li $v0, 10

113
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #12

114
**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,

115
**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;

116
**Exercise 5.6 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments 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

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

118
**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; return;.

119
**Exercise 5.7 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments .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 done: jr $ra

120
**Exercise 5.8 int main() { int K, Y ; int Z[50] ; Y = 56 ; K = 20 ;**

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 * ( K / ) ; }

121
**Exercise 5.8 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments .globl main .data K: .space 4 Y: .space 1 Z: .space 50 .text main: la t3, 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)

122
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #13

123
**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.

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

125
**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;

126
**Exercise 5.9 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments 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 b chk next: ble $t0, $v1, chk move $v1, $t0 chk: bgtz $a1, loop ret: jr $ra

127
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

128
**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

129
**Exercise 5.10 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments .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

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

131
**Exercise 5.11 (Pseudocode)**

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

132
**Exercise 5.11 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments .globl determ2 .text determ2: lw $t0, 0($a0) lw $t1, 12($a0) mult $t1, $t0 mflo $v0 lw $t0, 4($a0) lw $t1, 8($a0) mflo $t0 sub $v0, $v0, $t0 return: jr $ra

133
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #14

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

135
**Exercise 5.12(Pseudocode)**

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

136
**Exercise 5.12 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments .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

137
**Exercise 5.13 .data zap: .space 200 .text . . . zap[$a0] = $s0**

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: .space 200 .text . . . zap[$a0] = $s0

138
**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;

139
**Exercise 5.13 (MIPS Assembly Language)**

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)

140
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #15

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

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

143
**Exercise 5.14 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments Div4: li $v0, 0 li $t3, 3 b skip 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

144
**Chapter 6 Passing Arguments on the Stack**

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

146
**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 jal JILL # 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

147
**Example of Jill accessing the Stack**

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] . . . . . . <Body of Function> 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

148
**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 <#### jal JILL # 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 <####

149
**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

150
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #16

151
**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)

152
**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;

153
**Exercise 6.1 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments ##### 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

154
**Exercise 6.1 MinMax(&X:$t1, N:$t2, min:$t8, max:$t9)**

Label Op-Code Dest. S1, S2 Comments .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 b chk next: ble $t0, $t9, chk move $t9, $t0 chk: bgtz $t2, loop ret: sw $t8, 8($sp) # put min sw $t9, 12($sp) # put max jr $ra

155
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #17

156
**Memory Layout Reserved Text Segment Data Segment Stack Segment**

0xFFFFFFFF Reserved Text Segment Data Segment Stack Segment Operating System

157
**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.

158
**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;

159
**Exercise 6.2 (MIPS Assembly Language)**

Label Op-Code Dest. S1, S2 Comments .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) b exit found: sub $t1, $t1, $t2 sw $t1, 12($sp) exit: jr $ra

160
**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.

161
**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) jal Scan lw $t0, 8($sp) lw $t1, 12($sp) lw $t2, 16($sp) addi $sp, $sp, 20 # Deallocate ----

162
**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;

163
**Exercise 6.3 (Assembly Language Initialize) Scan(&X:$t6, N:$t2, U:$t3, L:$t4, D:$t5)**

Label Op-Code Dest. S1, S2 Comments 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”

164
**Exercise 6.3 (Assembly Language Body)**

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

165
**Exercise 6.3 (Assembly Language Continued)**

Label Op-Code Dest. S1, S2 Comments 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

166
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #18

167
**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.

168
**A Main Program to test hypotenuse**

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

169
**Exercise 6.4 (Pseudocode)**

t0 = Mem(sp); t1 = Mem(sp+4); Mem(sp+8) = sqr ( t0*t0 + t1*t1 ) ; return

170
**Exercise 6.4 (Assembly Language)**

Label Op-Code Dest. S1, S2 Comments 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 jal sqr # 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

171
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #19

172
**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.

173
**Example code for testing the AVA function**

Label Op-Code Dest. S1, S2 Comments `.data zig: .space 20 zag: .word 345, 765, , 2345, 999 zonk: .word , , 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) jal AVA lw $s0, 16($sp) addi $sp, $sp, 20 # Deallocate beqz $s0, done li $v0, 4 la $a0, msg syscall done: li $v0, 10

174
**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

175
**Exercise 6.5 (Assembly Language)**

Label Op-Code Dest. S1, S2 Comments .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) Exercise 6.5 (Assembly Language)

176
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #20

177
**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,

178
**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 li $v0, 10

179
**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

180
**Exercise 6.6 (Fibonacci Assembly Language)**

Label Op-Code Dest. S1, S2 Comments 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)

181
**Fibonacci (A Very Efficient Method)**

.data fibnum: .word 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181, .word 6765,10946,17711,28657,46368,75025,121393,196418,317811,514229, .word , , , , , , , , .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)

182
**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

183
**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

184
**Exercise 6.7 (Assembly Language)**

Label Op-Code Dest. S1, S2 Comments 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

185
**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.

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

187
**Exercise 6.8 (Assembly Language)**

Label Op-Code Dest. S1, S2 Comments 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: bgtz $t0, loop1 jr $ra

188
**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.

189
**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) =

190
**Exercise 6.9 (Assembly Language)**

191
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #21

192
**Reentrant Functions Rules for Writing Reentrant Code:**

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.

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

194
**Exercise 7.1 Reverse See Appendix A J u l y i s H o t**

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

195
**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

196
**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) b loop print: li $a0, $a1 li $v0, 4 syscall addi $sp, $sp, # De-allocate buffer space #### jr $ra Exercise 7.1 (Assembly Language)

197
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #22

198
**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.

199
**Exercise 7.2 (Palindrome Pseudocode)**

sp = sp # allocate buffer on stack ####### a0 = sp # address of buffer a1 = 16 # length of buffer syscall (8) # read a string sp = sp # 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 # deallocate parameters space *****

200
**Exercise 7.2 Palindrome Continued**

t 7 = sp # address of buffer t8 = t7 + t8 - 2 # address of string end t2 = # 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

201
**Exercise 7.2 (Palindrome Assembly Language)**

addi $sp, $sp, -16 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) jal srch # Call Search(&X, N, V, L) lw $ra, 16($sp) lw $t8, 12($sp) addi $sp, $sp, 20 #<<<<<<<<<<<<<<<<

202
**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, 16 sw $t2, 0($sp) jr $ra

203
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #23

204
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 : 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 : Analyze your Scan function. Is it a reentrant function? ___(yes/no) Explain why.

205
**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 b loops

206
**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) jal PrintDecimal # Call PrintDecimal lw $t8, 0($sp) lw $t5, 4($sp) lw $t6, 8($sp) lw $ra, 12($sp) addi $sp, $sp, 16 b again ends: sw $t6, 4($sp) jr $ra .data msg: .asciiz "\n A Vowel was Found at Relative Position: "

207
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #24

208
**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) $v0 = $v0 * $a0; Mem($sp+4) = $v0; Return Label Op-Code Dest. S1, S2 Comments Fac: lw $v0, 0($sp) addi $a0, $v0, -1 loopf: blez $a0, return mult $v0, $a0 mflo $v0 addi $a0, $a0. -1 b loopf return: sw $v0, 4($sp) jr $ra

209
**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

210
**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 b facret Go: addi $a0, $a0, -1 sw $a0, 0($sp) jal FacR # 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)

211
**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

212
**Exercise 7.4 Recursive Fibonacci**

deep: addi $a0, $a0, -1 addi $sp, $sp, -8 # <<<< Allocate Space sw $a0, 0($sp) jal Fibrec # Recursive Call lw $t0, 4($sp) # $t0 = Fib (N-1) addi $a0, $a0, -1 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

213
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 8 2 3 1 6 9 4 7

214
**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 - t # Allocate space for cofac matrix + arg Mem(sp + 4) = t5 # Pass size (N-1) Mem(sp) = sp # 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 + t #clean up stack return

215
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #25

216
**Exercise 8.1 void chico (int *X, int Y, int Z )**

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

217
**Exercise 8. 1 (Assembly Language Function) void chico (int**

Exercise 8.1 (Assembly Language Function) void chico (int *X, int Y, int Z ) {*X = Y/ Z * 10 + *X * 8 ;} Label Op-Code Dest. S1, S2 Comments 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

218
**Exercise 8.1 Main Program Label Op-Code Dest. S1, S2 Comments 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 sw $v0, 4($sp) # Put value for K : $s1 move $s1, $v0 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 < jal chico < addiu $sp, $sp, 12 # Deallocate <<<<<<<<<<<<<<<2 Four Classes of Variables in C: external, automatic, static, register

219
**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

220
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #26

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

222
**Exercise 8.2 (Assembly Language)**

Label Op-Code Dest. S1, S2 Comments 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

223
**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.

224
**Exercise 8.3 (Assembly Language) Adduovf ( x, y, s)**

Label Op-Code Dest. S1, S2 Comments 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

225
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 $t2 $t4 $t0 x1 Sum x0

226
**Exercise 8.4 (Assembly Language)**

Label Op-Code Dest. S1, S2 Comments 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 carry addi $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 b fini

227
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 If the product cannot be represented with 32-bits, then an exception should be generated.

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

229
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #27 Should Re-visit Exercise

230
**A Pipelined Implementation of the MIPS Architecture**

Data Cache 4 PC Instruction Cache Rd Register File ALU Write Back Rs Rt = IR Result Address Data In

231
**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

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

233
**Original Code - Modified Code**

Label Op-Code Dest. S1, S2 Div4: li $v0, 0 b skip 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 Label Op-Code Dest. S1, S2 Div4: li $v0, 0 li $t3, 3 b skip 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

234
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) jal sort 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 jal sort sw $t0, 4($sp) addi $sp, $sp, 8

235
**Original Code - Modified Code**

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 jr $ra 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

236
**MIPS Assembly Language Programming**

Bob Britton, Instructor Lesson #28

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

238
**Original Code - Modified Code**

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 $t5, overflow 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 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

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

240
**Original Code - Modified Code**

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: sw $0, 4($sp) 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)

241
Embedded Processors Memory Mapped I/O

242
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

243
**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

244
**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

245
**Testing the Random function**

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

246
**Printing results of test**

loop: li $s0, 7 inside: lw $a0, 0($s7) addi $s7, $s7, 4 jal hexout 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

OK

Fall 2006 1 EE 333 Lillevik 333f06-l4 University of Portland School of Engineering Computer Organization Lecture 4 Assembly language programming ALU and.

Fall 2006 1 EE 333 Lillevik 333f06-l4 University of Portland School of Engineering Computer Organization Lecture 4 Assembly language programming ALU and.

© 2018 SlidePlayer.com Inc.

All rights reserved.

To ensure the functioning of the site, we use **cookies**. We share information about your activities on the site with our partners and Google partners: social networks and companies engaged in advertising and web analytics. For more information, see the Privacy Policy and Google Privacy & Terms.
Your consent to our cookies if you continue to use this website.

Ads by Google

Ppt on smart note taker Ppt on rainwater harvesting in rajasthan Ppt on renewable energy Animated ppt on magnetism worksheets Ppt on nature and human development Ppt on obesity prevention center Ppt on council of ministers government Ppt on peak load pricing strategy Ppt on anti poverty programs in india Ppt on law against child marriage laws