11/09/2016

MIPS Quick Tutorial

MIPSArchitectureandAssemblyLanguageOverview
Adaptedfrom:http://edge.mcs.dre.g.el.edu/GICL/people/sevy/architecture/MIPSRef(SPIM).html

[RegisterDescription][I/ODescription]

DataTypesandLiterals
Datatypes:
Instructionsareall32bits
byte(8bits),halfword(2bytes),word(4bytes)
acharacterrequires1byteofstorage
anintegerrequires1word(4bytes)ofstorage
Literals:
numbersenteredasis.e.g.4
charactersenclosedinsinglequotes.e.g.'b'
stringsenclosedindoublequotes.e.g."Astring"

Registers
32generalpurposeregisters
registerprecededby$inassemblylanguageinstruction
twoformatsforaddressing:
usingregisternumbere.g.$0through$31
usingequivalentnamese.g.$t1,$sp
specialregistersLoandHiusedtostoreresultofmultiplicationanddivision
notdirectlyaddressablecontentsaccessedwithspecialinstructionmfhi("movefromHi")andmflo("movefromLo")
stackgrowsfromhighmemorytolowmemory
ThisisfromFigure9.9intheGoodman&Millertext
Register
Number
0
1
23
47

Alternative
Name
zero
$at
$v0$v1
$a0$a3

http://logos.cs.uic.edu/366/notes/mips%20quick%20tutorial.htm

Description
thevalue0
(assemblertemporary)reservedbytheassembler
(values)fromexpressionevaluationandfunctionresults
(arguments)Firstfourparametersforsubroutine.
Notpreservedacrossprocedurecalls
1/8

11/09/2016

MIPS Quick Tutorial

815

$t0$t7

1623

$s0$s7

2425

$t8$t9

2627

$k0$k1

28

$gp

29

$sp

30

$s8/$fp

31

$ra

(temporaries)Callersavedifneeded.Subroutinescanusew/outsaving.

Notpreservedacrossprocedurecalls
(savedvalues)Calleesaved.
Asubroutineusingoneofthesemustsaveoriginalandrestoreitbeforeexiting.

Preservedacrossprocedurecalls
(temporaries)Callersavedifneeded.Subroutinescanusew/outsaving.
Theseareinadditionto$t0$t7above.

Notpreservedacrossprocedurecalls.
reservedforusebytheinterrupt/traphandler
globalpointer.
Pointstothemiddleofthe64Kblockofmemoryinthestaticdata
segment.
stackpointer
Pointstolastlocationonthestack.
savedvalue/framepointer
Preservedacrossprocedurecalls
returnaddress

SeealsoBrittonsection1.9,Sweetmansection2.21,LarusAppendixsectionA.6

ProgramStructure
justplaintextfilewithdatadeclarations,programcode(nameoffileshouldendinsuffix.stobeusedwithSPIMsimulator)
datadeclarationsectionfollowedbyprogramcodesection

DataDeclarations
placedinsectionofprogramidentifiedwithassemblerdirective.data
declaresvariablenamesusedinprogramstorageallocatedinmainmemory(RAM)

Code
placedinsectionoftextidentifiedwithassemblerdirective.text
containsprogramcode(instructions)
startingpointforcodee.g.ecutiongivenlabelmain:
endingpointofmaincodeshoulduseexitsystemcall(seebelowunderSystemCalls)

Comments
http://logos.cs.uic.edu/366/notes/mips%20quick%20tutorial.htm

2/8

11/09/2016

MIPS Quick Tutorial

anythingfollowing#onaline
#Thisstuffwouldbeconsideredacomment
TemplateforaMIPSassemblylanguageprogram:
# Comment giving name of program and description of function
# Template.s
# Bare-bones outline of MIPS assembly language program
.data

# variable declarations follow this line

# ...

.text

# instructions follow this line

main:

# indicates start of code (first instruction to execute)

# ...

# End of program, leave a blank line afterwards to make SPIM happy

DataDeclarations
formatfordeclarations:
name:

storage_type

value(s)

createstorageforvariableofspecifiedtypewithgivennameandspecifiedvalue
value(s)usuallygivesinitialvalue(s)forstoragetype.space,givesnumberofspacestobeallocated
Note:labelsalwaysfollowedbycolon(:)
example
var1:
array1:

.word
.byte

3
# create a single integer variable with initial value 3
'a','b' # create a 2-element character array with elements initialized
# to a and b
.space 40
# allocate 40 consecutive bytes, with storage uninitialized
# could be used as a 40-element character array, or a
# 10-element integer array; a comment should indicate which!

array2:

Load/StoreInstructions
RAMaccessonlyallowedwithloadandstoreinstructions
allotherinstructionsuseregisteroperands
load:
lw

register_destination, RAM_source

http://logos.cs.uic.edu/366/notes/mips%20quick%20tutorial.htm

3/8

11/09/2016

MIPS Quick Tutorial

#copyword(4bytes)atsourceRAMlocationtodestinationregister.
lb

register_destination, RAM_source

#copybyteatsourceRAMlocationtoloworderbyteofdestinationregister,
#andsigne.g.tendtohigherorderbytes
storeword:
sw

register_source, RAM_destination

#storewordinsourceregisterintoRAMdestination
sb

register_source, RAM_destination

#storebyte(loworder)insourceregisterintoRAMdestination
loadimmediate:
li

register_destination, value

#loadimmediatevalueintodestinationregister

example:
.data
var1: .word
.text
__start:
lw
li
sw
done

23

# declare storage for var1; initial value is 23

$t0, var1
$t1, 5
$t1, var1

# load contents of RAM location into register $t0: $t0 = var1

# $t1 = 5 ("load immediate")
# store contents of register $t1 into RAM: var1 = $t1

IndirectandBasedAddressing
Usedonlywithloadandstoreinstructions
loadaddress:
la

$t0, var1

copyRAMaddressofvar1(presumablyalabeldefinedintheprogram)intoregister$t0
http://logos.cs.uic.edu/366/notes/mips%20quick%20tutorial.htm

4/8

11/09/2016

MIPS Quick Tutorial

indirectaddressing:
lw

$t2, ($t0)

loadwordatRAMaddresscontainedin$t0into$t2
sw

$t2, ($t0)

storewordinregister$t2intoRAMataddresscontainedin$t0
basedorindexedaddressing:
lw

$t2, 4($t0)

loadwordatRAMaddress($t0+4)intoregister$t2
"4"givesoffsetfromaddressinregister$t0
sw

$t2, -12($t0)

storewordinregister$t2intoRAMataddress($t012)
negativeoffsetsarefine
Note:basedaddressingisespeciallyusefulfor:
arraysaccesselementsasoffsetfrombaseaddress
stackseasytoaccesselementsatoffsetfromstackpointerorframepointer

example
array1:
__start:

.data
.space 12
.text
la
$t0, array1
li
$t1, 5
sw $t1, ($t0)
li $t1, 13
sw $t1, 4($t0)
li $t1, -7
sw $t1, 8($t0)
done

# declare 12 bytes of storage to hold array of 3 integers

#
#
#
#
#
#

# load base address of array into register $t0

$t1 = 5 ("load immediate")
first array element set to 5; indirect addressing
$t1 = 13
second array element set to 13
$t1 = -7
third array element set to -7

ArithmeticInstructions
mostuse3operands
alloperandsareregistersnoRAMorindirectaddressing
operandsizeisword(4bytes)
http://logos.cs.uic.edu/366/notes/mips%20quick%20tutorial.htm

5/8

11/09/2016

MIPS Quick Tutorial

add
sub
addi
addu
subu

$t0,$t1,$t2
$t2,$t3,$t4
$t2,$t3, 5
$t1,$t6,$t7
$t1,$t6,$t7

#
#
#
#
#

$t0 = $t1 + $t2; add as signed (2's complement) integers

$t2 = $t3 $t4
$t2 = $t3 + 5; "add immediate" (no sub immediate)
$t1 = $t6 + $t7; add as unsigned integers
$t1 = $t6 + $t7; subtract as unsigned integers

mult

$t3,$t4

div

$t5,$t6

mfhi
mflo

$t0
$t1

#
#
#
#
#
#
#

multiply 32-bit quantities in $t3 and $t4, and store 64-bit

result in special registers Lo and Hi: (Hi,Lo) = $t3 * $t4
Lo = $t5 / $t6 (integer quotient)
Hi = $t5 mod $t6 (remainder)
move quantity in special register Hi to $t0: $t0 = Hi
move quantity in special register Lo to $t1: $t1 = Lo
used to get at result of product or quotient

move

$t2,$t3 # $t2 = $t3

ControlStructures
Branches
comparisonforconditionalbranchesisbuiltintoinstruction
b
beq
blt
ble
bgt
bge
bne

target
$t0,$t1,target
$t0,$t1,target
$t0,$t1,target
$t0,$t1,target
$t0,$t1,target
$t0,$t1,target

#
#
#
#
#
#
#

unconditional branch to program label target

branch to target if $t0 = $t1
branch to target if $t0 < $t1
branch to target if $t0 <= $t1
branch to target if $t0 > $t1
branch to target if $t0 >= $t1
branch to target if $t0 <> $t1

j
jr

target # unconditional jump to program label target

$t3
# jump to address contained in $t3 ("jump register")

Jumps

SubroutineCalls
subroutinecall:"jumpandlink"instruction
jal

sub_label

# "jump and link"

copyprogramcounter(returnaddress)toregister$ra(returnaddressregister)
jumptoprogramstatementatsub_label
subroutinereturn:"jumpregister"instruction
jr

$ra

# "jump register"

http://logos.cs.uic.edu/366/notes/mips%20quick%20tutorial.htm

6/8

11/09/2016

MIPS Quick Tutorial

jumptoreturnaddressin$ra(storedbyjalinstruction)
Note:returnaddressstoredinregister$raifsubroutinewillcallothersubroutines,orisrecursive,returnaddressshouldbecopiedfrom$raontostacktopreserveit,since
jalalwaysplacesreturnaddressinthisregisterandhencewilloverwritepreviousvalue

SystemCallsandI/O(SPIMSimulator)
usedtoreadorprintvaluesorstringsfrominput/outputwindow,andindicateprogramend
usesyscalloperatingsystemroutinecall
firstsupplyappropriatevaluesinregisters$v0and$a0$a1
resultvalue(ifany)returnedinregister$v0
Thefollowingtableliststhepossiblesyscallservices.
Service
print_int

Code
Arguments
in$v0
1
$a0=integertobeprinted

print_float
print_double
print_string
read_int
read_float
read_double

2
3
4
5
6
7

read_string

sbrk
exit

9
10

Results

$f12=floattobeprinted
$f12=doubletobeprinted
$a0=addressofstringinmemory
integerreturnedin$v0
floatreturnedin$v0
doublereturnedin$v0
$a0=memoryaddressofstringinput
buffer
$a1=lengthofstringbuffer(n)
$a0=amount

addressin$v0

Theprint_stringserviceexpectstheaddresstostartanullterminatedcharacterstring.Thedirective.asciizcreatesanullterminatedcharacterstring.
Theread_int,read_floatandread_doubleservicesreadanentirelineofinputuptoandincludingthenewlinecharacter.
Theread_stringservicehasthesamesemanticesastheUNIXlibraryroutinefgets.
Itreadsupton1charactersintoabufferandterminatesthestringwithanullcharacter.
Iffewerthann1charactersareinthecurrentline,itreadsuptoandincludingthenewlineandterminatesthestringwithanullcharacter.
Thesbrkservicereturnstheaddresstoablockofmemorycontainingnadditionalbytes.Thiswouldbeusedfordynamicmemoryallocation.
Theexitservicestopsaprogramfromrunning.
e.g.

Print out integer value contained in register $t2

li

$v0, 1

http://logos.cs.uic.edu/366/notes/mips%20quick%20tutorial.htm

# load appropriate system call code into register $v0;

# code for printing integer is 1
7/8

11/09/2016

MIPS Quick Tutorial

move
$a0, $t2
syscall
e.g.

# move integer to be printed into $a0: $a0 = $t2

# call operating system to perform operation

Read integer value, store in RAM location with label int_value (presumably declared in data section)
li

$v0, 5

# load appropriate system call code into register $v0;

# code for reading integer is 5
# call operating system to perform operation
# value read from keyboard returned in register $v0;
# store this in desired location

syscall
sw
$v0, int_value
e.g.

Print out string (useful for prompts)

string1

.data
.asciiz "Print this.\n"

main:

.text
li

# declaration for string variable,

# .asciiz directive makes string null terminated

$v0, 4

# load appropriate system call code into register $v0;

# code for printing string is 4
# load address of string to be printed into $a0
# call operating system to perform print operation

la
$a0, string1
syscall

e.g. To indicate end of program, use exit system call; thus last lines of program should be:
li
$v0, 10
syscall

# system call code for exit = 10

# call operating sys

http://logos.cs.uic.edu/366/notes/mips%20quick%20tutorial.htm

8/8