MIPS

Reference Guide

Free at PushingButtons.net
 2

Table of Contents

I. Data Registers 3

II. Instruction Register Formats 4

III. MIPS Instruction Set 5

IV. MIPS Instruction Set (Extended) 6

V. SPIM Programming 11

VI. Program Examples 12

 3

Data Registers

MIPS contains 32 registers for programmers to use:

# Register(s) Usage
0 $zero  Hard-wired to 0
1 $at  Reserved for assembler
2,3 $v0, $v1  Used to store returned values from function calls
4-7 $a0 - $a3  Used to store values passed as arguments to functions
8-15 $t0 - $t7  Temporary registers
16-23 $s0 - $s7  Saved temporary registers
24,25 $t8, $t9  Temporary registers
26, 27 $k0, $k1  Reserved for operating system kernel
28 $gp  Global pointer
29 $sp  Stack pointer
30 $fp  Frame pointer
31 $ra  Return address for function calls
 4

Instruction Register Formats

The MIPS IR register supports three different register formats. They

are R (register), I (immediate) and J (jump). All MIPS registers are 32-bit,
so each register format is 32 bits wide. They differ in the number and types
of fields they contain.

R Format

Op-Code Rs Rt Rd Rh Function
Code
000000 sssss ttttt ddddd hhhhh ffffff

I Format

Op-Code Rs Rt Immediate
ffffff sssss ttttt iiiiiiiiiiiiiiii

J Format

Op-Code Target
ffffff iiiiiiiiiiiiiiiiiiiiiiiiii

The R (register) format consists of five different fields. The 6-bit op-
code will always be 000000. Rs, Rt and Rd are 5-bit fields that specify the
locations of registers being used. Rs and Rt are sources for the operation.
Rd is the destination to store the result. If Rh (shift amount) is not used, it
becomes 00000. The last 5 bits are the function code. This tells the
computer which type of instruction should be executed.

The I (immediate) format consists of four different fields. The 6-bit

op-code determines what type of instruction should be executed. This is
similar to the function code in the R-format. The Rs field is the source for
the operation. The Rt is the register destination to store the result. The
last 16 bits hold the value being applied in the operation.

The J (jump) format consists of only two fields. The 6-bit op-code will
always be 00001f. The last 26 bits specify the location being jumped to.
These type of instructions are similar to high-level language “go to”
commands.
 5

MIPS Instruction Set

ADD Add MFLO Move from $LO

ADDI Add immediate MTHI Move to $HI
ADDIU Add immediate MTLO Move to $LO
unsigned MULT Multiply
ADDU Add unsigned
MULTU Multiply unsigned
AND And
NOOP No operation
ANDI And immediate
NOR Nor
BEQ Branch on equal
OR Or
BGEZ Branch on >= 0
ORI Or immediate
BGEZAL Branch on >= 0 and
link SB Store byte
BGTZ Branch on > 0 SH Store halfword
BLEZ Branch on <= 0 SLL Shift left logical
BLTZ Branch on < 0 SLLV Shift left logical
BLTZAL Branch on < 0 and variable
link SLT Set on less than
BNE Branch on != 0 SLTI Set on less than
DIV Divide immediate
SLTIU Set on less than
DIVU Divide unsigned immediate unsigned
J Jump SLTU Set on less than
JAL Jump and link unsigned
SRA Shift right arithmetic
JALR Jump and link register
SRAV Shift right arithmetic
JR Jump register variable
LB Load byte SRL Shift right logical
LBU Load byte unsigned SRLV Shift right logical
variable
LH Load halfword SUB Subtract
LHU Load halfword
SUBU Subtract unsigned
unsigned
LUI Load upper immediate SW Store word
LW Load word SWL Store word left
LWL Load word left SWR Store word right
LWR Load word right SYSCALL System call
MFHI Move from $HI XOR Xor
XORI Xor immediate
 6

MIPS Instruction Set (Extended)

ADD add $d, $s, $t add
Meaning  $d = $s + $t
additional info Function Code  100000

ADDI addi $t, $s, imm add immediate

Meaning  $t = $s + imm
additional info Op-Code  001000

ADDIU addiu $t, $s, imm add immediate unsigned

Meaning  $t = $s + imm(unsigned)
additional info Op-Code  001001

ADDU addu $d, $s, $t add unsigned

Meaning  $d = $s + $t
additional info Function Code  100001

AND and $d, $s, $t and

Meaning  $d = $s and $t
additional info Function Code 100100

ANDI andi $t, $s, imm and immediate

Meaning  $t = $s and imm
additional info Op-Code 001100

BEQ beq $s, $t, offset branch on equal

Meaning  if $s == $t branch to offset
additional info Op-Code 000100

BGEZ bgez $s, offset branch >= zero

Meaning  if $s >= 0 branch to offset
additional info Op-Code 000001
Rt  00001

BGEZAL bgezal $s, offset branch >= zero and link

Meaning  if $s >= 0 branch to offset
save return address in $ra
additional info Op-Code 000001
Rt  10001

BGTZ bgtz $s, offset branch > zero

Meaning  if $s > 0 branch to offset
additional info Op-Code 000111
Texte Rt  00000

BLEZ blez $s, offset branch <= zero

Meaning  if $s <= 0 branch to offset
additional info Op-Code 000110
Rt  00000
 7

BLTZ bltz $s, offset branch < zero

Meaning  if $s < 0 branch to offset
additional info Op-Code 000001
Rt  00000

BLTZAL bltzal $s, offset branch < zero and link

Meaning  if $s < 0 branch to offset
save return address in $ra
additional info Op-Code 000001
Rt  10000

BNE bne $s, $t, offset branch on not equal

Meaning  if $s != $t branch to offset
additional info Op-Code 000101

DIV div $s, $t divide

Meaning  $LO = $s / $t
$HI = $s % $t
additional info Function Code  011010

DIVU divu $s, $t divide unsigned

Meaning  $LO = $s / $t
$HI = $s % $t
additional info Function Code  011011

J j target jump
Meaning  Jump to target location
additional info Op-Code  000010

JAL jal target jump and link

Meaning  Jump to target location
save return address in $ra
additional info Op-Code  000011

JALR jal $d, $s jump and link register

Meaning  Jump to location specified
by $s
Save return address in $d
additional info Function Code  001001

JR jr $s jump register
Meaning  Jump to target location
contained in register $s
additional info Function Code 001000

LB lb $t, offset($s) load byte

Meaning  $t = [$s + offset]
additional info Op-Code  100000

LBU lbu $t, offset($s) load byte unsigned

Meaning  $t = [$s + offset]
additional info Op-Code  100100
 8

LH lh $t, offset($s) load halfword

Meaning  $t = halfword [$s + offset]
additional info Op-Code  100001

LHU lhu $t, offset($s) load halfword unsigned

Meaning  $t = halfword [$s + offset]
additional info Op-Code  100101

LUI lb $t, imm load upper immediate

Meaning  $t = imm after imm is
shifted left 16 bits
additional info Op-Code  001111

LW lw $t, offset($s) load word

Meaning  $t = [$s + offset]
additional info Op-Code  100011

LWL lwl $t, offset($s) load word left

Meaning  $t = [$s + offset]
additional info Op-Code  100010

LWR lwr $t, offset($s) load word right

Meaning  $t = [$s + offset]
additional info Op-Code  100110

MFHI mfhi $d move from HI

Meaning  $d = $HI
additional info Function Code  010000

MFLO mflo $d move from LO

Meaning  $d = $LO
additional info Function Code  010010

MTHI mfhi $s move to HI

Meaning  $HI = $s
additional info Function Code  010001

MTLO mtlo $s move to LO

Meaning  $LO = $s
additional info Function Code  010011

MULT mult $s, $t multiply

Meaning  $LO = $s * $t
additional info Function Code  011000

MULTU multu $s, $t multiply unsigned

Meaning  $LO = $s * $t
additional info Function Code  011001

NOOP noop no operation

Meaning  no operation
 9

NOR nor $d, $s, $t nor

Meaning  $d = $s nor $t
additional info Function Code  100111

OR or $d, $s, $t or
Meaning  $d = $s or $t
additional info Function Code  100101

ORI ori $t, $s, imm or immediate

Meaning  $t = $s or imm
additional info Op-Code  001101

SB sb $t, offset($s) store byte

Meaning  [$s + offset] = least
significant bit of $t
additional info Op-Code  101000

SH sh $t, offset($s) store halfword

Meaning  [$s + offset] = half word $t
additional info Op-Code  101001

SLL sll $d, $t, h shift left logical

Meaning  $d = $t shifted left h times
additional info Function Code  000000

SLLV sllv $d, $t, $s shift left logical variable

Meaning  $d = $t shifted left # times
in $s
additional info Function Code  000100

SLT slt $d, $s, $t set on less than

Meaning  if $s < $t then $d = 1
else $d = 0
additional info Function Code  101010

SLTI slti $t, $s, imm set on less than immediate

Meaning  if $s < imm then $t = 1
else $t = 0
additional info Op-Code  001010

SLTIU sltiu $t, $s, imm SLT immediate unsigned

Meaning  if $s < imm then $t = 1
else $t = 0
additional info Op-Code  001011

SLTU sltu $d, $s, $t set on less than unsigned

Meaning  if $s < $t then $d = 1
else $d = 0
additional info Function Code  101011
 10

SRA sra $d, $t, h shift right arithmetic

Meaning  $d = $t shifted right h
times
additional info Function Code  000011

SRAV srav $d, $t, $s shift right arith. variable

Meaning  $d = $t shifted right #
times in $s
additional info Function Code  000111

SRL srl $d, $t, h shift right logical

Meaning  $d = $t shifted right h
times
additional info Function Code  000010

SRLV srlv $d, $t, $s shift right logical variable

Meaning  $d = $t shifted right #
times in $s
additional info Function Code  000110

SUB sub $d, $s, $t subtract

Meaning  $d = $s - $t
additional info Function Code  100010

SUBU subu $d, $s, $t subtract unsigned

Meaning  $d = $s - $t
additional info Function Code  100011

SW sw $t, offset($s) store word

Meaning  [$s + offset] = $t
additional info Op-Code  101011

SWL swl $t, offset($s) store word left

Meaning  [$s + offset] = $t
additional info Op-Code  101010

SWR swr $t, offset($s) store word right

Meaning  [$s + offset] = $t
additional info Op-Code  101110

SYSCALL syscall system call

Meaning  Sends an interrupt

additional info Function Code  001100

XOR xor $d, $s, $t exclusive or

Meaning  $d = $s xor $t
additional info Function Code  100110

XORI xori $t, $s, imm exclusive or immediate

Meaning  $t = $s xor imm
additional info Op-Code  001110
 11

SPIM Programming

Every program written in SPIM needs a data and text segment.

#.data signifies the beginning of the data segment

.data

#.text starts the “text” portion of the program

.text

Within the data segment you can initialize your variables. All variables are
initialized in the form:

Name: .Type Content

The name is user defined. It can be any name the programmer wishes to
call the variable by. The variable types are the following:
.ascii  ASCII string
.asciiz  ASCII string followed by a null
terminator
.byte  Byte
.doubl  Double
e
.float  Float
.word  Word

SPIM can be downloaded for free at

http://www.cs.wisc.edu/~larus/spim.html
 12

Program Examples
#This program prints to screen the string “Hello World!”

#.data signifies the beginning of the data segment

.data

#If hello is called within the main program it will lead to the string.
#.asciiz means that the string is in ASCII format followed by
#a NULL terminator
hello: .asciiz "Hello World!"

.globl main

#.text starts the “text” portion of the program

.text

#Start main program

main:

#Setting register $v0 equal to 4 tells the processor that

#a string in register $a0 is going to be printed to screen
li $v0, 4
#Setting content of $a0 to string hello
la $a0, hello
#Calling system to perform output
syscall
 13

#This program inputs a number and then displays the number

#Data portion of program

.data

.globl main

#Text portion of program

.text

#Start main program

main:

#Setting register $v0 to 5 tells the processor that

#an integer is going to be entered from the keyboard
li $v0, 5
#calling system to perform input
syscall

#The integer that was entered will now be in

#register $v0.
#Moving this value into register $t0.
move $t0, $v0

#Setting register $v0 to 1 tells the processor that the

#contents of register $a0 are going to be printed to the monitor
li $v0, 1
#Moving content of register $t0 into register $a0
move $a0, $t0
#calling system to perform output
syscall
 14

#This program asks the user for two integers and then displays the sum

#Data portion of the program

.data

#Creating ASCII strings for input prompt and output

Msg: .asciiz "Enter in an integer: "
Msg2: .asciiz "The sum is: "
#Creating ASCII string for a carriage return
return: .asciiz "\n"

.globl main

#Text portion of the program

.text
#Starting main program
main:

#Print to screen string “Enter in an integer: “

li $v0, 4
la $a0, Msg
syscall

#Input an integer from keyboard into register $v0

li $v0, 5
syscall
#Move content of register $v0 into register $t0
move $t0, $v0

#Print to screen string “Enter in an integer: “

li $v0, 4
la $a0, Msg
syscall

#Input an integer from keyboard into register $v0

li $v0, 5
syscall
#move content of register $v0 into register $t1
move $t1, $v0

#Print to screen string “\n” car carriage return.

li $v0, 4
la $a0, return
syscall

#Print to screen string “The sum is: “

li $v0, 4
la $a0, Msg2
syscall

#Adding registers $t0 and $t1 and store sum in $t2

add $t2,$t0,$t1
#Move content of register $t2 (the sum) into register $a0
move $a0, $t2
#Print to screen content of $a0
li $v0, 1
syscall
 15

#This program asks the user for two numbers and displays their product

#Data portion of the program

.data

#Creating ASCII string for input prompt

msg1: .asciiz "Please enter a number: "
#Creating ASCII string for output
msg2: .asciiz "The product is: "

.globl main

#Text portion of the program

.text

#Starting main program

main:

#Printing to screen string “Please enter a number: “

li $v0, 4
la $a0, msg1
syscall

#Input an integer from keyboard into register $v0

li $v0, 5
syscall
#Move content of register $v0 into register $t0
move $t0, $v0

#Printing to screen string “Please enter a number: “

li $v0, 4
la $a0, msg1
syscall

#Input an integer from keyboard into register $v0

li $v0, 5
syscall
#Move content of register $v0 into register $t1
move $t1, $v0

#Multiplying $t0 by $t1. Product will be stored in register $LO

mult $t0, $t1

#Moving content of $LO (the product) into register $t2

mflo $t2

#Printing to screen string “The product is: “

li $v0, 4
la $a0, msg2
syscall

#Moving content of $t2 (the product) into register $a0

move $a0, $t2

#Printing to screen content of $a0

li $v0, 1
syscall
 16

#This program asks the user for an integer and then determines if it
#is even or odd

#Data portion of the program

.data

#Creating ASCII string for input prompt

question: .asciiz "Please enter an integer: "
#Creating ASCII string for output if the number is even
even: .asciiz "That number is even"
#Creating ASCII string for output if the number is odd
odd: .asciiz "That number is odd"

.globl main

#Text portion of the program

.text

#Starting main program

main:

#Print to screen the string “Please enter an integer: “

li $v0, 4
la $a0, question
syscall

#Input an integer from keyboard and store it in register $v0

li $v0, 5
syscall
#Move content of $v0 into register $t0
move $t0, $v0

#Load register $t1 with immediate value of 2

li $t1, 2
#Divide $t0 by $t1.
#$t0 % $t1 will be stored in $HI. $t0 * $t1 will be stored in $LO
div $t0, $t1

#Move content of $HI into register $t2

mfhi $t2
#If register $t2 is 0 (NUM % 2 = 0) then branch to AAA
beq $t2, $zero, AAA

#Print to screen string “That number is odd” if haven’t branched

li $v0, 4
la $a0, odd
syscall
#Jump to BBB (to skip message for even number)
j BBB
#AAA start
AAA:
#Print to screen string “That number is even”
li $v0, 4
la $a0, even
syscall
#BBB start
BBB: