Question

Q14) By using the hardware described in the textbook (Figure 3.8) and a table similar to that shown in the textbook (Figure 3.10). Assume that the variable x = 62 and y = 23. a) Calculate x divided by y; you should show the contents of each register on each step. Assume both inputs are unsigned 6-bit b) Given the following C statements: w = x/y; R = w+2, translate these statements into approciated MIPS instructions. Assume x, y and R are in $s0, $sland $s2 respectivily.

Answer 1

Step-by-step explanation:

To calculate the division of `x` by `y` using the hardware described in the textbook (Figure 3.8), and assuming both inputs are unsigned 6-bit numbers, we can use the following steps:

1. Initialize the registers:

- `PC` (Program Counter) = 0

- `IR` (Instruction Register) = Instruction at address 0

- `MAR` (Memory Address Register) = 0

- `MDR` (Memory Data Register) = Value at address 0 in memory

- `AC` (Accumulator) = 0

- `X` = 62

- `Y` = 23

2. Fetch the first instruction from memory:

- `IR` = Instruction at address 0

3. Decode the instruction:

- Determine the opcode and operands based on the instruction format.

4. Execute the instruction:

- Perform the required operation based on the opcode and operands.

5. Update the registers and memory as necessary.

Here's a step-by-step breakdown of the division calculation:

1. Initialize registers and set the values of `X` and `Y`:

- `PC` = 0

- `IR` = Instruction at address 0

- `MAR` = 0

- `MDR` = Value at address 0 in memory

- `AC` = 0

- `X` = 62 (unsigned 6-bit binary: 111110)

- `Y` = 23 (unsigned 6-bit binary: 010111)

2. Perform the division calculation:

- Step 1: Set `AC` to the value of `X` (62): `AC = X = 111110`

- Step 2: Right-shift `AC` (dividing by 2): `AC = 011111`

- Step 3: Subtract `Y` (23) from `AC` (011111 - 010111 = 001000), and store the result in `AC`.

- Step 4: If the result of the subtraction is negative (MSB = 1), set `AC[0]` to 0 and left-shift `AC` (multiply by 2). Otherwise, set `AC[0]` to 1.

- Repeat Steps 2-4 until `AC` is smaller than `Y`.

The final result of the division is stored in `AC`, which represents the quotient of `X` divided by `Y`.

Assuming `X` and `Y` are stored in registers `$50` and `$51` respectively, and the result (`w`) will be stored in register `$52`, the MIPS instructions to translate the C statements `w = x/y; R = w+2;` would be as follows:

```assembly

div $50, $51 # Divide $50 (X) by $51 (Y)

mflo $52 # Move quotient to $52 (w)

addi $52, $52, 2 # Add 2 to $52 (w)

move $s2, $52 # Move $52 (w) to $s2 (R)

```

In the above code, `div` performs the division operation, `mflo` moves the quotient from the special register `lo` to `$52` (w), `addi` adds 2 to `$52` (w), and `move` moves the value of `$52` (w) to `$s2` (R).