Your first MIPS program, run by hand

The program, in words first

Below is the first program your MIPS core ever executed. It has 26 words. It prints Hi, then 42 twice, then a star, and stops. It uses only nine different instructions.

The names $t0 … $t6 are registers. They are registers 8 to 14. The name $t0 and the number $8 mean the same box. $zero is register 0, and it always holds 0. Chapter 2 covers the names.

Here is the program as the assembler sees it. The text after # is a comment.

_start:
  lui   $t0, 0x1000          # $t0 = 0x10000000
  ori   $t0, $t0, 0x0ff0     # $t0 = 0x10000ff0: the "putchar door"
  addiu $t1, $zero, 'H'      # $t1 = 72
  sw    $t1, 0($t0)          # write 72 to the door: prints H
  addiu $t1, $zero, 'i'
  sw    $t1, 0($t0)          # prints i
  addiu $t1, $zero, '\n'
  sw    $t1, 0($t0)          # prints a new line
  addiu $t2, $zero, 6
  addiu $t3, $zero, 7
  mult  $t2, $t3             # HI:LO = 6 * 7 = 42
  mflo  $t4                  # $t4 = 42
  sw    $t4, 4($t0)          # the "putint door": prints 42
  sw    $t4, -16($t0)        # store 42 in ordinary memory
  lw    $t6, -16($t0)        # load it back
  sw    $t6, 4($t0)          # prints 42 again
  beq   $zero, $zero, skip   # always taken
  nop                        # runs anyway (see below)
  sw    $t1, 4($t0)          # skipped
skip:
  beq   $t2, $t3, no_star    # 6 == 7? no: not taken
  nop
  sw    $t4, 0($t0)          # 42 is the code of '*': prints *
no_star:
  addiu $t5, $zero, 0
  sw    $t5, 8($t0)          # the "exit door": stop with code 0

Three small ideas you need before pressing play

The doors. This program prints without any operating system. The test machine watches three addresses. A store to 0x10000FF0 prints one character. A store to 0x10000FF4 prints a number. A store to 0x10000FF8 stops the machine. This is memory-mapped I/O. It is the test machine’s convention, not a MIPS rule. On MIPS, a door is just an address, and sw is the only way to reach it.

A 32-bit address in two steps. One instruction can carry only 16 bits of constant, called an immediate. So 0x10000FF0 needs two: lui sets the top half, ori fills the bottom half. §3.2 explains the sizes.

The nop after a branch. MIPS always runs the instruction after a branch, taken or not. That instruction is the delay slot. Here it holds a nop so that nothing surprising happens. §5.4 tells the whole story. For now, just watch it run.

Run it

Press play. One tick is one instruction. Blue registers were read this tick, green ones were written, cyan memory bytes were touched. The runner pauses once, before the branch, to ask you a question.

▮

Three things every instruction does

Look at any tick in the runner and you will find the same shape. The instruction reads a few registers, computes something small, and writes one place.

That is why the register pane has only two colors. Blue is what was read. Green is what was written. A store writes no register, so no box turns green.

Can you now explain it?

Now try to explain this one yourself: at tick 15, lw $t6,-16($t0) brings back the 42 stored at tick 14. Where was the number between those two ticks? And why does $t4 still hold 42 as well?

Next: §1.3 — the same words as bits: the three instruction formats.