I-Format

Recap that we have 5-bit shamt field. This can only represent the values between 0 and 31. We do not need the second register operand as well as shamt so we can merge them into a longer 16-bit field.

Unfortunately, a naive approach to this would probably remove the $rt field. But this field is in between $rt and $rd and that will make for an awkward immediate field. But if you remember the summary, we actually remove $rd! This is better because the merged field will now be continuous.

This is a compromise. We have just defined a new instruction format (i.e., I-format) that is partially consistent with R-format. The compromise follows from MIPS design principles.

Steps

The steps to assemble I-format instructions can be summarised as follows:

1. Find the value of opcode.
2. Find the register number for $rs.
3. Find the register number for $rt.
4. Compute the number for immediate (may need conversion from negative 2s complement number).
5. Convert the values to binary.
6. Combine the fields.

Opcode Values

The values for the opcode field is summarised below:

Immediate Field

The immediate field is how we put the constant value into the instruction. Since we only have 32 bits for the instruction, we cannot use all of them for the constant values. With the compromise above, we have come up with a 16 bits field.

Now, we can classify the immediate field into two kinds:

• Signed Integer
  • Range is between -2¹⁵ to 2¹⁵-1.
  • Signed extended (append the MSB to the front until 32 bits).
  • Used for arithmetic operations: addi, slti, lw, sw.
  • This is large enough to handle:
    • The offset in a typical memory operations: lw, sw.
    • Most of the values used in the addi, slti instructions.
• Unsigned Integer
  • Range is between 0 to 2¹⁶-1.
  • Bit extended (append the 0 to the front until 32 bits).
  • Used for logical operations: andi, ori, xori.

Examples

Arithmetic and Memory

The conversion simply follow the steps above. The value of the immediate is treated as signed integers.

1
2

addi $s5, $s6, -50
#op  $rt, $rs, immediate

1
2
3
4

   00100010110101011111111111001110
=> 0010 0010 1101 0101 1111 1111 1100 1110
=> 2    2    D    5    F    F    C    E
=> 22D5FFCE

1

lw $t1, 12($t0)

1
2
3
4

   10001101000010010000000000001100
=> 1000 1101 0000 1001 0000 0000 0000 1100
=> 8    D    0    9    0    0    0    C
=> 22D5FFCE

Logic

We are still following the steps, but now the value of the immediate is treated as unsigned integers. In fact, it is often written simply as hexadecimals.

1
2

ori  $t0, $t1, 0xFFF
#op  $rt, $rs, immediate

1
2
3
4

   00110101001010000000111111111111
=> 0011 0101 0010 1000 0000 1111 1111 1111
=> 3    5    2    8    0    F    F    F
=> 35280FFF

Branch

Branch operations (e.g., beq and bne) use PC-relative addressing. The main limitation faced by branch operation is that the immediate field is only 16 bits while the memory address is 32 bits.

Fortunately, if we look at the usage of branch operations, they are often used in selection statements (e.g., if) or repetition statements (e.g., while or for). These statements are typically small, usually only up to 50 instructions. Which means, the value of $PC will often change only by a small amount either positive (i.e., downwards) or negative (i.e., upwards).

So, we can actually specify the target address relative to the current instruction address. The current instruction address is stored in the special register $PC We usually represent the $PC as an arrow before the instruction currently being executed. Using PC-relative addressing technique, the branch can take values in the range of ±2¹⁵ bytes from the $PC.

If we use the value as it is, given that each instruction is word-aligned, the usable values are actually only ±2¹³ words from the $PC. Obviously that's a waste of useful values. But since the instructions are word-aligned, the number of bytes to add to the $PC will always be a multiple of 4. So, we can instead interpret the immediate value as the number of words by automatically multiply the value by 4. This way, we can branch ±2¹⁵ words (or ±2¹⁷ bytes) from the $PC. To put it simply, we can now branch 4 times farther!

Due to the PC-relative addressing, we cannot simply give you a single branch instruction and ask you to translate it into machine code. This is because one of the value to be deduced corresponds to the label which may be several instructions away.

1
2
3
4
5
6

Loop: beq  $t1, $zero, End    # rlt addr: 0
      #op  $rs, $rt  , label
      add  $t0, $t0  , $t2    # rlt addr: 4
      addi $t1, $t1  , -1     # rlt addr: 8
      j    Loop               # rlt addr: 12
End:                          # rlt addr: 16

1
2
3
4
5
6

   $PC' = ($PC + 4) + (immediate × 4)
=> 16   = (0   + 4) + (immediate × 4)
=> 16   = 4         + (immediate × 4)
=> 16-4 =             (immediate × 4)
=> 12   =             (immediate × 4)
=> 3    =              immediate

1
2
3
4

   00010001001000000000000000000011
=> 0001 0001 0010 0000 0000 0000 0000 0011
=> 1    1    2    0    0    0    0    3
=> 11200003

1
2
3
4
5
6

Loop: beq  $t1  , $zero, End   # rlt addr: 0
      add  $t0  , $t0  , $t2   # rlt addr: 4
      addi $t1  , $t1  , -1    # rlt addr: 8
      beq  $zero, $zero, Loop  # rlt addr: 12
      #op  $rs  , $rt  , label
End:                           # rlt addr: 16

1
2
3
4
5
6

   $PC' = ($PC + 4) + (immediate × 4)
=> 0    = (12  + 4) + (immediate × 4)
=> 0    = 16        + (immediate × 4)
=> 0-16 =             (immediate × 4)
=> -16  =             (immediate × 4)
=> -4   =              immediate