ECE 30 Introduction to Computer Engineering

Size: px

Start display at page:

Download "ECE 30 Introduction to Computer Engineering"

Bertram Stanley
5 years ago
Views:

1 ECE 30 Introduction to Computer Engineering Study Problems, Set #3 Spring 2015 Use the MIPS assembly instructions listed below to solve the following problems. arithmetic add add sub subtract addi add immediate special lui load upper immediate slt set if less than data lw load word from memory transfer sw store word in memory branch beq branch if equal bne branch if not equal jump j jump jal jump and link jr jump register 1. Show the single MIPS instruction or minimal sequence of instructions for this C statement: x[10] = x[11] + c; Assume that c corresponds to register $t0 and the array x has a base address of 4, 000, 000 ten. The base address of x, in binary, is , which implies that we must use the special instruction lui to store this value in a register: lui $t1, # The immediate value is shifted left 16 bits & stored in $t1, the lower 16 bits are 0 s. ori $t1, $t1, # Or immediate for lower 16 bits lw $t2, 44($t1) # load x[11] to $t2 add $t2, $t2, $t0 # add c and $t2 sw $t2, 40($t1) # store the sum in x[10] 1

2 2. Write a procedure in MIPS R2000 assembly language that computes the sum of an array of integers (represented as 32-bit words) stored in memory. Assume that $a0 contains the memory address (pointer in C) of the first integer in the array, and $a1 contains the number of elements of the array. The total value should be returned in register $v0. The following is a C version of our routine: int sum_array (int *array_pointer, int array_length) { int i; int sum = 0; for (i = 0; i < array_length; i++) { sum += *(array_pointer + i); return sum; P: add $t0, $zero, $zero # init i add $v0, $zero, $zero # init sum Q: slt $t1, $t0, $a1 # set t1 = 1 if i < array length bne $t1, $zero, L # if not at end, loop jr $ra # done -> return L: lw $t1, 0($a0) # load current array element add $v0, $v0, $t1 # add current element to sum addi $t0, $t0, 1 # increment counter addi $a0, $a0, 4 # next word in array j Q # loop 3. Write a procedure in MIPS R2000 assembly language that copies an array of integers (represented as 32-bit words) stored in memory to another location in memory. Assume that $t2 contains the memory address (pointer in C) of the first integer to be copied and that $t3 contains the first destination memory address. The copying of integers should stop if the integer 0 is encountered. You may use one additional temporary register in addition to $t2 and $t3. The following is a C version of our routine: void int_array_cpy (int *s1, int *s2) { while (*s1!= 0) { *s2 = *s1; s1++; s2++; 2

3 P: lw $t0, 0($t2) # Load an integer beq $t0, $zero, Q # Return if zero loop: sw $t0, 0($t3) # Store it addi $t2, $t2, 4 # Increment integer pointer load location addi $t3, $t3, 4 # Increment integer pointer store location lw $t0, 0($t2) # Load next integer bne $t0, $zero, loop # Back to loop if not zero Q: jr $ra # If zero, return from the procedure 4. Write a procedure bfind, in MIPS assembly language. The procedure should take a single argument that is a pointer to a null-terminated string (a string that ends up with 0) in register $a0. The bfind procedure should locate the first b character in the string and return its address in register $v0. If there are no b s in the string, then bfind should return a pointer to the null character at the end of the string. For example, if the argument of bfind points to the string imbibe, then the return value will be a pointer to the third character of the string. Characters are represented by bytes. The ascii value of b is 98. bfind: addi $t0, $zero, 98 # $t0 = b lb $t1, 0($a0) # Load a char into $t1 beq $t1, $zero, done # If the loaded char is null, done beq $t0, $t1, done # If the loaded char is b, done loop: addi $a0, $a0, 1 # Increment string pointer lb $t1, 0($a0) # Load the next char beq $t1, $zero, done # If the loaded char is null, done bne $t0, $t1, loop # If the loaded char is not b, loop done: add $v0, $a0, $zero # Return the pointer jr $ra # Return to caller 3

4 5. The following is a sequence of MIPS instructions. J: jal P J+4:... P: sub $t3, $t3, $t3 P+4: lw $t5, 0($t4) Q: add $t3, $t3, $t5 Q+4: addi $t5, $t5, -1 Q+8: beq $t5, $zero, R Q+12: j Q R: sw $t3, 4($t4) R+4: jr $ra Complete the table. What does P return as a result (in $t3)? Explain what procedure P does exactly in English. Each row of the table contains the state of the registers immediately after the instruction at PC is completed. Stop when PC becomes J + 4. Assume that $t4 contains the memory location s1 initially. PC $t3 $t4 $t5 $ra J - s1 - P Memory Address Memory Content s1 3 4

5 PC $t3 $t4 $t5 $ra J - s1 - J + 4 P P Q Q Q Q Q Q Q Q R R J Memory Address Memory Content s1 3 s Procedure P reads a word from memory (which has value 3) into register $t5 and clears register $t3. It then loops for exactly three iterations, each time incrementing $t3 by the value in $t5, then decrementing $t5 by one. Once $t5 is equal to zero, it stores $t3 to memory and returns to the caller. P returns the value 6 as a result, which is stored in $t3. So what procedure P exactly does is the following: it computes the sum of all positive integers up to 3 (i.e., what is stored in s1 ) and stores the result in s1+4. 5

Branch Addressing. Jump Addressing. Target Addressing Example. The University of Adelaide, School of Computer Science 28 September 2015

Branch Addressing. Jump Addressing. Target Addressing Example. The University of Adelaide, School of Computer Science 28 September 2015 Branch Addressing Branch instructions specify Opcode, two registers, target address Most branch targets are near branch Forward or backward op rs rt constant or address 6 bits 5 bits 5 bits 16 bits PC-relative