Before the laboratory:

• Write a MIPS assembly function to do the following:
  

  
      #include <stdio.h>
      int computeArray(int [], int );   
      int addUp(int , int , int );
      void writeArray(int [], int );
      /* global arrays, first initialized */
      int B[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
      int A[10];
  
      void main(void)
      {
         int n, r;
         scanf("%i", &n);
         writeArray(A, n);
         r = computeArray(A, n);
         printf("%i\n", r);
         writeArray(A, n);
      }
      int computeArray(int A[], int n)
      {
         int C[10];
         int i;
         for (i = 0; i < n; i++)   {        
            C[i] = addUp(A[i], B[i], i);
            A[i] = C[i] + 100;
         }
         writeArray(C, n);
         return C[0];
      }
      int addUp(int x, int y, int z)
      {
         return x+y+z;
      }
      void writeArray(int A[], int n)
      {
         int i;
         for (i = 0; i < n; i++)
            printf("%i ", A[i]);
         printf("\n");
      }
  

• Here is typical output from this program:
  

  
      pandora% lab5
      10        (input)
      0 0 0 0 0 0 0 0 0 0
      10 21 32 43 54 65 76 87 98 109
      10
      110 121 132 143 154 165 176 187 198 209
      pandora% lab5
      6         (input)
      0 0 0 0 0 0
      10 21 32 43 54 65
      10
      110 121 132 143 154 165
      pandora%
  

• You must transform this C code faithfully into MIPS assembler code, meaning that you do the following:
  • Make the arrays A and B ordinary MIPS arrays of size 10 (10 4-byte integers), using .space or .word as appropriate, with B initialized as shown.
  • Read in a value for n, using syscall.
  • Call the function computeArray using MIPS calling conventions, so that the address of A is in register $a0, and that the value of n is in $a1. The value of C[0] must be returned through register $v0.
  • As part of the code for the the function computerArray, allocate C as an array of size 10 on the stack, using the register $sp.
  • Call the function addUp in the same way, following MIPS conventions. The code for addUp is quite simple (just add up the values in $a0, $a1, and $a2, placing the result in $v0 and returning).
  • The function writeArray is called and coded in a way similar to and simpler than computeArray. You have been given sample writeArray code in a class handout.
  • Write a MIPS main program to call computeArray. The calling program must use writeArray to output A before and after the call to computeArray.

For checkoff:

• You must demonstrate your program in action.
• Hand the laboratory TA a copy of your source code when you start the check off procedure.

Additional comments:

• As already specified in the syllabus, each student must write their own program for this assignment. You may help one another, but it is not acceptable for two or more of you to work on the same program.
• It is important that you write the required functions as specified above, that you used parameters conforming to MIPS conventions, and that you use storage on the stack (through $sp) for the array C.