Week 03 Tutorial Questions

Objectives

introducing MIPS data directives as a way to define and store globally-accessible data
introducing MIPS instructions that use and modify memory addresses
introducing the arithmetic needed to manipulate MIPS 1D arrays

Often when writing large MIPS programs, you will make accidental errors that cause your program to misbehave.
Discuss what tools are available to help debug broken MIPS code.
If the data segment of a particular MIPS program starts at the address 0x10010020, then what addresses are the following labels associated with, and what value is stored in each 4-byte memory cell?
```
    .data
a:  .word   42
b:  .space  4
c:  .asciiz "abcde"
    .align  2
d:  .byte   1, 2, 3, 4
e:  .word   1, 2, 3, 4
f:  .space  1
```
Give MIPS directives to represent the following variables:
1. int u;
2. int v = 42;
3. char w;
4. char x = 'a';
5. double y;
6. int z[20];
Assume that we are placing the variables in memory, at an appropriately-aligned address, and with a label which is the same as the C variable name.

Consider the following memory state:

Address       Data Definition
0x10010000    aa:  .word 42
0x10010004    bb:  .word 666
0x10010008    cc:  .word 1
0x1001000C         .word 3
0x10010010         .word 5
0x10010014         .word 7

What address will be calculated, and what value will be loaded into register $t0, after each of the following statements (or pairs of statements)?

```
la   $t0, aa
```
```
lw   $t0, bb
```
```
lb   $t0, bb
```
```
lw   $t0, aa+4
```
```
la   $t1, cc
lw   $t0, ($t1)
```
```
la   $t1, cc
lw   $t0, 8($t1)
```
```
li   $t1, 8
lw   $t0, cc($t1)
```
```
la   $t1, cc
lw   $t0, 2($t1)
```

Translate this C program to MIPS assembler

// A simple program that will read 10 numbers into an array

#define N_SIZE 10

#include <stdio.h>

int main(void) {
    int i;
    int numbers[N_SIZE] = {0};

    i = 0;
    while (i < N_SIZE) {
        scanf("%d", &numbers[i]);
        i++;
    }
}

Translate this C program to MIPS assembler

// A simple program that will print 10 numbers from an array

#define N_SIZE 10

#include <stdio.h>

int main(void) {
    int i;
    int numbers[N_SIZE] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

    i = 0;
    while (i < N_SIZE) {
        printf("%d\n", numbers[i]);
        i++;
    }
}

Translate this C program to MIPS assembler

// A simple program that adds 42 to each element of an array

#define N_SIZE 10

int main(void) {
    int i;
    int numbers[N_SIZE] = {0, 1, 2, -3, 4, -5, 6, -7, 8, 9};

    i = 0;
    while (i < N_SIZE) {
        if (numbers[i] < 0) {
            numbers[i] += 42;
        }
        i++;
    }
}

Translate this C program to MIPS assembler

// A short program that reverses an array by swapping elements.

#define N_SIZE 10
#define N_SIZE_M_1 N_SIZE - 1
#define N_SIZE_D_2 N_SIZE / 2

#include <stdio.h>

int main(void) {
    int i;
    int numbers[N_SIZE] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

    i = 0;
    while (i < N_SIZE_D_2) {
        int x = numbers[i];
        int y = numbers[N_SIZE_M_1 - i];

        numbers[i] = y;
        numbers[N_SIZE_M_1 - i] = x;

        i++;
    }
}

The following loop determines the length of a string, a '\0'-terminated character array:
```
char *string = "....";
char *s = &string[0];
int   length = 0;
while (*s != '\0') {
   length++;  // increment length
   s++;       // move to next char
}
```
Write MIPS assembly to implement this loop.
Assume that the variable string is implemented like:
```
   .data
string:
   .asciiz  "...."
```
Assume that the variable s is implemented as register $t0, and variable length is implemented as register $t1. And, assume that the character '\0' can be represented by a value of zero.

Revision questions

The following questions are primarily intended for revision, either this week or later in session.
Your tutor may still choose to cover some of these questions, time permitting.

Conceptually, the MIPS pseudo-instruction to load an address could be encoded as something like the following:

Since addresses in MIPS are 32-bits long, how can this instruction load an address that references the data area, such as 0x10010020?
Implement the following C code in MIPS assembly instructions, assuming that the variables x and y are defined as global variables (within the .data region of memory):
```
long x;     // assume 8 bytes
int  y;     // assume 4 bytes

scanf("%d", &y);

x = (y + 2000) * (y + 3000);
```
Assume that the product might require more than 32 bits to store.
Write MIPS assembly to evaluate the following C expression, leaving the result in register $v0.
```
((x*x + y*y) - x*y) * z
```
Write one version that minimises the number of instructions, and another version that minimises the number of registers used (without using temporary memory locations).
Assume that: all variables are in labelled locations in the .data segment; the labels are the same as the C variable names; all results fit in a 32-bit register (i.e., no need to explicitly use Hi and Lo).