MIPS Instructions

1
MIPS Instructions
2
J-type Instruction Encoding

• We have jump and jump-and-link instructions
• Note that we have 26 bits for the target fields,
  which represents the number of instructions
  (words) instead of bytes
• In terms of bytes, it represents 28 bits in terms
  of bytes
• But PC requires 32 bits
• Where do we get the other 4 bits?

3
J-type Instruction Encoding

• Pseudo-direct addressing
• In J-type instructions, the jump address is
  formed by upper 4 bits of the current PC, 26 bits
  of the target address field in the instruction,
  and two bits of 0s
• What is the largest program a J-type instruction
  works properly?

4
Peek into the Future
5
Jump Register Instruction

• Jump register (jr)
• Unconditionally jump to the address given by
  register rs

6
Big Immediates

• We know that we can use 16-bit immediate numbers
  in MIPS instructions such as addi
• What about large numbers?
• We also need to load 32 bit addresses in order to
  use jr
• Load address (la)
• Load the address of a label into the register
  (note not the content of the address)

7
MIPS Addressing for 32-bit Immediates

• In MIPS, the immediate field has 16 bits
• In order to handle 32-bit immediate operands, the
  MIPS includes load upper immediate (lui)
• Which sets the upper 16 bits of a constant in a
  register and fills the lower 16 bits with 0s
• Then one can set the lower 16 bits using ori

8
Example

• To load the following 32-bit constant in s0,
• We first need to do
• lui s0, 61
• Why?
• Then we need to do
• ori s0, s0, 35072
• Why?

9
Branching Far Away

• Note that for conditional branch instructions the
  offset is 16 bits
• What can we do if the branch is further away than
  the 16-bit offset can represent?

10
Branching Far Away

• Note that for conditional branch instructions the
  offset is 16 bits
• What can we do if the branch is further away than
  the 16-bit offset can represent?
• We can replace it using a pair of instructions
• bne s0, s1, L2
• j L1
• L2

11
MIPS Assembly Instructions
12
Procedures and Functions

• We programmers use procedures and functions to
  structure and organize programs
• To make them easier to understand
• To allow code to be reused

13
A Simple Example
Note that there are steps involved in the calling
function as well as in the one being called
14
MIPS Calling Conventions

• MIPS assembly follows the following convention in
  using registers
• a0 - a3 four argument registers in which to
  pass parameters
• v0 - v1 two value registers in which to return
  values
• ra one return address register to return to the
  point of origin

15
Registers

• Remember that the same registers are used by both
  the caller and callee
• What do we need to do in order to guarantee the
  correctness of the program?
• For the following code for example, what do we
  need to do?

16
Register Spilling

• The callee has to save all the registers it uses
  and restore the values before it returns
• By storing them on the stack
• At the beginning
• Then restoring them
• At the end

17
Simple Example
18
The Stack Pointer
19
MIPS Calling Conventions - more

• MIPS software divides 18 of the registers into
  two groups
• t0 - t9 10 temporary registers that are not
  preserved by the callee on a procedure call
• These are caller-saved registers since the caller
  must save the ones it is using
• s0 - s7 8 saved registers that must be
  preserved on a procedure call
• These are callee-saved registers since the callee
  must save the ones it uses

20
Caller Must Do

• Before it calls a procedure/function, it must
• Pass parameters
• Up to four parameters are passed by a0 - a3
• Save caller-saved registers on the stack
• It includes a0 - a3 (since the callee may
  change these values), s0 - s9, and ra
• Why ra?
• Execute a jal instruction, which jumps to the
  callees first instruction and save the next
  instruction in ra

21
Caller Must Do cont.

• After the procedure/function call, it needs to
• Read the returned values from v0 and v1
• Restore caller-saved registers

22
Callee Must Do

• Before it does its calculations, the callee must
  do the following
• Allocate memory for its frame by subtracting its
  frame size from the stack pointer
• Save callee-saved registers in the frame
• It must save s0 - s7, fp, ra before changing
  them
• ra needs to be saved if the callee itself makes
  a call
• When needed, establish the frame pointer fp by
  loading sp to it
• In this case, fp must be saved

23
Allocating Space for Local Data on Stack

• In MIPS, local variables are also stored on the
  stack
• The segment of the stack containing a procedures
  saved registers and local variables is called a
  procedure frame (or activation record)

24
Callee Must Do

• After its calculations and before it returns to
  the caller, the callee must
• Place the return values in v0 and v1 (if
  needed)
• Restore all the callee-saved registers that were
  saved at the procedure entry
• Pop the stack frame by adding the frame size to
  sp
• Return by jumping to the address in register ra
  using jr

25
Earlier Example
26
Revised Version