MARS

REGISTERS
INSTRUCTION SET
DIRECTIVES
SYSCALLS

134: /

Registers
MIPS has 32 integer registers.
The hardware architecture specifies that:

General purpose register $0 always returns a value of 0.

General purpose register $31 is used as the link register for jump and link instructions.
HI and LO are used to access the multiplier/divider results, accessed by the mfhi (move from high) and mflo
commands.

These are the only hardware restrictions on the usage of the general purpose registers.
The various MIPS tool-chains implement specific calling conventions that further restrict how the registers are
used. These calling conventions are totally maintained by the tool-chain software and are not required by the
hardware.
Register

Number

Usage

zero

Constant 0

at

Reserved for assembler

v0
v1

2
3

Used for return values from function calls.

a0
a1
a2
a3

4
5
6
7

Used to pass arguments to procedures and functions.

t0
t1
t2
t3
t4
t5
t6
t7

8
9
10
11
12
13
14
15

Temporary (Caller-saved, need not be saved by called procedure)

s0
s1
s2
s3
s4
s5
s6
s7

16
17
18
19
20
21
22
23

Saved temporary (Callee-saved, called procedure must save and restore)

t8
t9

24
25

Temporary (Caller-saved, need not be saved by called procedure)

[1]

k0
k1

26
27

Reserved for OS kernel

gp

28

Pointer to global area

sp

29

Stack pointer

fp

30

Frame pointer

ra

31

Return address for function calls.

MIPS has 32 floating-point registers ($f0 $f31). Two registers are paired for double precision numbers.
Odd numbered registers cannot be used for arithmetic or branching, just as part of a double precision
register pair.

[2]

Instruction Set
The following list provides a description of basic MIPS instructions. For more information on pseudoinstructions available in MARS, refer to MARS help section.
Operand Key for Example Instructions
label, target
any textual label
$t1, $t2, $t3
any integer register
$f2, $f4, $f6
even-numbered floating point register
$f0, $f1, $f2
any floating point register
$8
any Coprocessor 0 register
1
condition flag (0 to 7)
10
unsigned 5-bit integer (0 to 31)
-100
signed 16-bit integer (-32768 to 32767)
100000
signed 32-bit integer (-2147483648 to 2147483647)
Load & Store addressing mode
-100($t2)
sign-extended 16-bit integer added to contents of $t2

Basic Instructions
abs.d $f2,$f4
abs.s $f0,$f1

Floating point absolute value double precision : Set $f2 to absolute value of $f4,
double precision
Floating point absolute value single precision : Set $f0 to absolute value of $f1,
single precision

add $t1,$t2,$t3
add.d $f2,$f4,$f6

Addition with overflow : set $t1 to ($t2 plus $t3)

Floating point addition double precision : Set $f2 to double-precision floating point
value of $f4 plus $f6

add.s $f0,$f1,$f3

Floating point addition single precision : Set $f0 to single-precision floating point
value of $f1 plus $f3

addi $t1,$t2,-100

Addition immediate with overflow : set $t1 to ($t2 plus signed 16-bit immediate)

addiu $t1,$t2,-100

Addition immediate unsigned without overflow : set $t1 to ($t2 plus signed 16-bit
immediate), no overflow

addu $t1,$t2,$t3

Addition unsigned without overflow : set $t1 to ($t2 plus $t3), no overflow

and $t1,$t2,$t3
andi $t1,$t2,100

Bitwise AND : Set $t1 to bitwise AND of $t2 and $t3

Bitwise AND immediate : Set $t1 to bitwise AND of $t2 and zero-extended 16-bit
immediate

bc1f 1,label

Branch if specified FP condition flag false (BC1F, not BCLF) : If Coprocessor 1

condition flag specified by immediate is false (zero) then branch to statement at
label's address

bc1f label

Branch if FP condition flag 0 false (BC1F, not BCLF) : If Coprocessor 1 condition flag
0 is false (zero) then branch to statement at label's address

[3]

bc1t 1,label

Branch if specified FP condition flag true (BC1T, not BCLT) : If Coprocessor 1

condition flag specified by immediate is true (one) then branch to statement at
label's address

bc1t label

Branch if FP condition flag 0 true (BC1T, not BCLT) : If Coprocessor 1 condition flag
0 is true (one) then branch to statement at label's address

beq $t1,$t2,label

Branch if equal : Branch to statement at label's address if $t1 and $t2 are equal

bgez $t1,label

Branch if greater than or equal to zero : Branch to statement at label's address if

$t1 is greater than or equal to zero

bgezal $t1,label

Branch if greater than or equal to zero and link : If $t1 is greater than or equal to
zero, then set $ra to the Program Counter and branch to statement at label's
address

bgtz $t1,label

Branch if greater than zero : Branch to statement at label's address if $t1 is greater
than zero
Branch if less than or equal to zero : Branch to statement at label's address if $t1 is
less than or equal to zero
Branch if less than zero : Branch to statement at label's address if $t1 is less than
zero

blez $t1,label
bltz $t1,label
bltzal $t1,label

Branch if less than zero and link : If $t1 is less than or equal to zero, then set $ra to
the Program Counter and branch to statement at label's address

bne $t1,$t2,label

Branch if not equal : Branch to statement at label's address if $t1 and $t2 are not
equal

break

Break execution : Terminate program execution with exception

break 100

Break execution with code : Terminate program execution with specified exception
code
Compare equal double precision : If $f2 is equal to $f4 (double-precision), set
Coprocessor 1 condition flag 0 true else set it false

c.eq.d $f2,$f4

c.eq.d 1,$f2,$f4

Compare equal double precision : If $f2 is equal to $f4 (double-precision), set

Coprocessor 1 condition flag specified by immediate to true else set it to false

c.eq.s $f0,$f1

Compare equal single precision : If $f0 is equal to $f1, set Coprocessor 1 condition
flag 0 true else set it false
Compare equal single precision : If $f0 is equal to $f1, set Coprocessor 1 condition
flag specied by immediate to true else set it to false

c.eq.s 1,$f0,$f1

c.le.d $f2,$f4

Compare less or equal double precision : If $f2 is less than or equal to $f4 (doubleprecision), set Coprocessor 1 condition flag 0 true else set it false

c.le.d 1,$f2,$f4

Compare less or equal double precision : If $f2 is less than or equal to $f4 (doubleprecision), set Coprocessor 1 condition flag specfied by immediate true else set it
false

[4]

c.le.s $f0,$f1

Compare less or equal single precision : If $f0 is less than or equal to $f1, set
Coprocessor 1 condition flag 0 true else set it false

c.le.s 1,$f0,$f1

Compare less or equal single precision : If $f0 is less than or equal to $f1, set
Coprocessor 1 condition flag specified by immediate to true else set it to false

c.lt.d $f2,$f4

Compare less than double precision : If $f2 is less than $f4 (double-precision), set
Coprocessor 1 condition flag 0 true else set it false

c.lt.d 1,$f2,$f4

Compare less than double precision : If $f2 is less than $f4 (double-precision), set
Coprocessor 1 condition flag specified by immediate to true else set it to false

c.lt.s $f0,$f1

Compare less than single precision : If $f0 is less than $f1, set Coprocessor 1
condition flag 0 true else set it false
Compare less than single precision : If $f0 is less than $f1, set Coprocessor 1
condition flag specified by immediate to true else set it to false

c.lt.s 1,$f0,$f1

ceil.w.d $f1,$f2

Ceiling double precision to word : Set $f1 to 32-bit integer ceiling of doubleprecision float in $f2

ceil.w.s $f0,$f1

Ceiling single precision to word : Set $f0 to 32-bit integer ceiling of single-precision
float in $f1

clo $t1,$t2

Count number of leading ones : Set $t1 to the count of leading one bits in $t2
starting at most significant bit position

clz $t1,$t2

Count number of leading zeroes : Set $t1 to the count of leading zero bits in $t2
starting at most significant bit position

cvt.d.s $f2,$f1

Convert from single precision to double precision : Set $f2 to double precision
equivalent of single precision value in $f1
Convert from word to double precision : Set $f2 to double precision equivalent of
32-bit integer value in $f1
Convert from double precision to single precision : Set $f1 to single precision
equivalent of double precision value in $f2
Convert from word to single precision : Set $f0 to single precision equivalent of 32bit integer value in $f2
Convert from double precision to word : Set $f1 to 32-bit integer equivalent of
double precision value in $f2
Convert from single precision to word : Set $f0 to 32-bit integer equivalent of
single precision value in $f1

cvt.d.w $f2,$f1
cvt.s.d $f1,$f2
cvt.s.w $f0,$f1
cvt.w.d $f1,$f2
cvt.w.s $f0,$f1
div $t1,$t2

Division with overflow : Divide $t1 by $t2 then set LO to quotient and HI to
remainder (use mfhi to access HI, mflo to access LO)

div.d $f2,$f4,$f6

Floating point division double precision : Set $f2 to double-precision floating point
value of $f4 divided by $f6

div.s $f0,$f1,$f3

Floating point division single precision : Set $f0 to single-precision floating point
value of $f1 divided by $f3

[5]

divu $t1,$t2

Division unsigned without overflow : Divide unsigned $t1 by $t2 then set LO to
quotient and HI to remainder (use mfhi to access HI, mflo to access LO)

eret

Exception return : Set Program Counter to Coprocessor 0 EPC register value, set
Coprocessor Status register bit 1 (exception level) to zero

floor.w.d $f1,$f2

Floor double precision to word : Set $f1 to 32-bit integer floor of double-precision
float in $f2

floor.w.s $f0,$f1

Floor single precision to word : Set $f0 to 32-bit integer floor of single-precision
float in $f1

j target
jal target

Jump unconditionally : Jump to statement at target address

Jump and link : Set $ra to Program Counter (return address) then jump to
statement at target address

jalr $t1

Jump and link register : Set $ra to Program Counter (return address) then jump to
statement whose address is in $t1
Jump and link register : Set $t1 to Program Counter (return address) then jump to
statement whose address is in $t2
Jump register unconditionally : Jump to statement whose address is in $t1

jalr $t1,$t2
jr $t1
lb $t1,-100($t2)

Load byte : Set $t1 to sign-extended 8-bit value from effective memory byte
address

lbu $t1,-100($t2)

Load byte unsigned : Set $t1 to zero-extended 8-bit value from effective memory
byte address

ldc1 $f2,-100($t2)

Load double word Coprocessor 1 (FPU)) : Set $f2 to 64-bit value from effective
memory doubleword address

lh $t1,-100($t2)

Load halfword : Set $t1 to sign-extended 16-bit value from effective memory
halfword address
Load halfword unsigned : Set $t1 to zero-extended 16-bit value from effective
memory halfword address
Load linked : Paired with Store Conditional (sc) to perform atomic read-modifywrite. Treated as equivalent to Load Word (lw) because MARS does not simulate
multiple processors.

lhu $t1,-100($t2)
ll $t1,-100($t2)

lui $t1,100
lw $t1,-100($t2)

Load upper immediate : Set high-order 16 bits of $t1 to 16-bit immediate and loworder 16 bits to 0
Load word : Set $t1 to contents of effective memory word address

lwc1 $f1,-100($t2)

Load word into Coprocessor 1 (FPU) : Set $f1 to 32-bit value from effective
memory word address

lwl $t1,-100($t2)

Load word left : Load from 1 to 4 bytes left-justified into $t1, starting with effective
memory byte address and continuing through the low-order byte of its word

lwr $t1,-100($t2)

Load word right : Load from 1 to 4 bytes right-justified into $t1, starting with
effective memory byte address and continuing through the high-order byte of its
word

[6]

madd $t1,$t2

Multiply add : Multiply $t1 by $t2 then increment HI by high-order 32 bits of

product, increment LO by low-order 32 bits of product (use mfhi to access HI, mflo
to access LO)

maddu $t1,$t2

Multiply add unsigned : Multiply $t1 by $t2 then increment HI by high-order 32 bits
of product, increment LO by low-order 32 bits of product, unsigned (use mfhi to
access HI, mflo to access LO)

mfc0 $t1,$8

Move from Coprocessor 0 : Set $t1 to the value stored in Coprocessor 0 register $8

mfc1 $t1,$f1

Move from Coprocessor 1 (FPU) : Set $t1 to value in Coprocessor 1 register $f1

mfhi $t1

Move from HI register : Set $t1 to contents of HI (see multiply and divide
operations)

mflo $t1

Move from LO register : Set $t1 to contents of LO (see multiply and divide
operations)
Move floating point double precision : Set double precision $f2 to double precision
value in $f4
Move floating point single precision : Set single precision $f0 to single precision
value in $f1

mov.d $f2,$f4
mov.s $f0,$f1
movf $t1,$t2

Move if FP condition flag 0 false : Set $t1 to $t2 if FPU (Coprocessor 1) condition
flag 0 is false (zero)

movf $t1,$t2,1

Move if specified FP condition flag false : Set $t1 to $t2 if FPU (Coprocessor 1)
condition flag specified by the immediate is false (zero)

movf.d $f2,$f4

Move floating point double precision : If condition flag 0 false, set double precision
$f2 to double precision value in $f4
Move floating point double precision : If condition flag specified by immediate is
false, set double precision $f2 to double precision value in $f4

movf.d $f2,$f4,1

movf.s $f0,$f1
movf.s $f0,$f1,1

Move floating point single precision : If condition flag 0 is false, set single precision
$f0 to single precision value in $f1
Move floating point single precision : If condition flag specified by immediate is
false, set single precision $f0 to single precision value in $f1e

movn $t1,$t2,$t3
movn.d $f2,$f4,$t3

Move conditional not zero : Set $t1 to $t2 if $t3 is not zero
Move floating point double precision : If $t3 is not zero, set double precision $f2 to
double precision value in $f4

movn.s $f0,$f1,$t3

Move floating point single precision : If $t3 is not zero, set single precision $f0 to
single precision value in $f1

movt $t1,$t2

Move if FP condition flag 0 true : Set $t1 to $t2 if FPU (Coprocessor 1) condition
flag 0 is true (one)

movt $t1,$t2,1

Move if specfied FP condition flag true : Set $t1 to $t2 if FPU (Coprocessor 1)
condition flag specified by the immediate is true (one)

movt.d $f2,$f4

Move floating point double precision : If condition flag 0 true, set double precision
$f2 to double precision value in $f4
[7]

movt.d $f2,$f4,1

Move floating point double precision : If condition flag specified by immediate is

true, set double precision $f2 to double precision value in $f4e

movt.s $f0,$f1

Move floating point single precision : If condition flag 0 is true, set single precision
$f0 to single precision value in $f1e

movt.s $f0,$f1,1

Move floating point single precision : If condition flag specified by immediate is

true, set single precision $f0 to single precision value in $f1e

movz $t1,$t2,$t3
movz.d $f2,$f4,$t3

Move conditional zero : Set $t1 to $t2 if $t3 is zero

Move floating point double precision : If $t3 is zero, set double precision $f2 to
double precision value in $f4

movz.s $f0,$f1,$t3

Move floating point single precision : If $t3 is zero, set single precision $f0 to single
precision value in $f1

msub $t1,$t2

Multiply subtract : Multiply $t1 by $t2 then decrement HI by high-order 32 bits of

product, decrement LO by low-order 32 bits of product (use mfhi to access HI, mflo
to access LO)

msubu $t1,$t2

Multiply subtract unsigned : Multiply $t1 by $t2 then decrement HI by high-order

32 bits of product, decrement LO by low-order 32 bits of product, unsigned (use
mfhi to access HI, mflo to access LO)

mtc0 $t1,$8

Move to Coprocessor 0 : Set Coprocessor 0 register $8 to value stored in $t1

mtc1 $t1,$f1

Move to Coprocessor 1 (FPU) : Set Coprocessor 1 register $f1 to value in $t1

mthi $t1

Move to HI register : Set HI to contents of $t1 (see multiply and divide operations)

mtlo $t1

Move to LO register : Set LO to contents of $t1 (see multiply and divide operations)

mul $t1,$t2,$t3

Multiplication without overflow : Set HI to high-order 32 bits, LO and $t1 to loworder 32 bits of the product of $t1 and $t2 (use mfhi to access HI, mflo to access
LO)

mul.d $f2,$f4,$f6

Floating point multiplication double precision : Set $f2 to double-precision floating

point value of $f4 times $f6
Floating point multiplication single precision : Set $f0 to single-precision floating
point value of $f1 times $f3
Multiplication : Set hi to high-order 32 bits, lo to low-order 32 bits of the product of
$t1 and $t2 (use mfhi to access hi, mflo to access lo)

mul.s $f0,$f1,$f3
mult $t1,$t2

multu $t1,$t2

Multiplication unsigned : Set HI to high-order 32 bits, LO to low-order 32 bits of the

product of unsigned $t1 and $t2 (use mfhi to access HI, mflo to access LO)

neg.d $f2,$f4

Floating point negate double precision : Set double precision $f2 to negation of
double precision value in $f4

neg.s $f0,$f1

Floating point negate single precision : Set single precision $f0 to negation of single
precision value in $f1
Null operation : machine code is all zeroes

nop

[8]

nor $t1,$t2,$t3
or $t1,$t2,$t3
ori $t1,$t2,100

Bitwise NOR : Set $t1 to bitwise NOR of $t2 and $t3

Bitwise OR : Set $t1 to bitwise OR of $t2 and $t3
Bitwise OR immediate : Set $t1 to bitwise OR of $t2 and zero-extended 16-bit
immediate

round.w.d $f1,$f2

Round double precision to word : Set $f1 to 32-bit integer round of doubleprecision float in $f2

round.w.s $f0,$f1

Round single precision to word : Set $f0 to 32-bit integer round of single-precision
float in $f1

sb $t1,-100($t2)

Store byte : Store the low-order 8 bits of $t1 into the effective memory byte
address

sc $t1,-100($t2)

Store conditional : Paired with Load Linked (ll) to perform atomic read-modifywrite. Stores $t1 value into effective address, then sets $t1 to 1 for success. Always
succeeds because MARS does not simulate multiple processors.

sdc1 $f2,-100($t2)

Store double word from Coprocessor 1 (FPU)) : Store 64 bit value in $f2 to effective
memory doubleword address
Store halfword : Store the low-order 16 bits of $t1 into the effective memory
halfword address

sh $t1,-100($t2)
sll $t1,$t2,10

Shift left logical : Set $t1 to result of shifting $t2 left by number of bits specified by
immediate

sllv $t1,$t2,$t3

Shift left logical variable : Set $t1 to result of shifting $t2 left by number of bits
specified by value in low-order 5 bits of $t3

slt $t1,$t2,$t3

Set less than : If $t2 is less than $t3, then set $t1 to 1 else set $t1 to 0

slti $t1,$t2,-100

Set less than immediate : If $t2 is less than sign-extended 16-bit immediate, then
set $t1 to 1 else set $t1 to 0
Set less than immediate unsigned : If $t2 is less than sign-extended 16-bit
immediate using unsigned comparison, then set $t1 to 1 else set $t1 to 0

sltiu $t1,$t2,-100

sltu $t1,$t2,$t3
sqrt.d $f2,$f4
sqrt.s $f0,$f1
sra $t1,$t2,10

Set less than unsigned : If $t2 is less than $t3 using unsigned comparison, then set
$t1 to 1 else set $t1 to 0
Square root double precision : Set $f2 to double-precision floating point square
root of $f4
Square root single precision : Set $f0 to single-precision floating point square root
of $f1
Shift right arithmetic : Set $t1 to result of sign-extended shifting $t2 right by
number of bits specified by immediate

srav $t1,$t2,$t3

Shift right arithmetic variable : Set $t1 to result of sign-extended shifting $t2 right
by number of bits specified by value in low-order 5 bits of $t3

srl $t1,$t2,10

Shift right logical : Set $t1 to result of shifting $t2 right by number of bits specified
by immediate

srlv $t1,$t2,$t3

Shift right logical variable : Set $t1 to result of shifting $t2 right by number of bits
specified by value in low-order 5 bits of $t3
Subtraction with overflow : set $t1 to ($t2 minus $t3)

sub $t1,$t2,$t3

[9]

sub.d $f2,$f4,$f6

Floating point subtraction double precision : Set $f2 to double-precision floating

point value of $f4 minus $f6

sub.s $f0,$f1,$f3

Floating point subtraction single precision : Set $f0 to single-precision floating

point value of $f1 minus $f3

subu $t1,$t2,$t3

Subtraction unsigned without overflow : set $t1 to ($t2 minus $t3), no overflow

sw $t1,-100($t2)

Store word : Store contents of $t1 into effective memory word address

swc1 $f1,-100($t2)

Store word from Coprocessor 1 (FPU) : Store 32 bit value in $f1 to effective
memory word address

swl $t1,-100($t2)
swr $t1,-100($t2)

Store word left : Store high-order 1 to 4 bytes of $t1 into memory, starting with
effective byte address and continuing through the low-order byte of its word
Store word right : Store low-order 1 to 4 bytes of $t1 into memory, starting with
high-order byte of word containing effective byte address and continuing through
that byte address

syscall

Issue a system call : Execute the system call specified by value in $v0

teq $t1,$t2
teqi $t1,-100

Trap if equal : Trap if $t1 is equal to $t2

Trap if equal to immediate : Trap if $t1 is equal to sign-extended 16 bit immediate

tge $t1,$t2

Trap if greater or equal : Trap if $t1 is greater than or equal to $t2

tgei $t1,-100

Trap if greater than or equal to immediate : Trap if $t1 greater than or equal to
sign-extended 16 bit immediate

tgeiu $t1,-100

Trap if greater or equal to immediate unsigned : Trap if $t1 greater than or equal to
sign-extended 16 bit immediate, unsigned comparison

tgeu $t1,$t2

Trap if greater or equal unsigned : Trap if $t1 is greater than or equal to $t2 using
unsigned comparison
Trap if less than: Trap if $t1 less than $t2
Trap if less than immediate : Trap if $t1 less than sign-extended 16-bit immediate

tlt $t1,$t2
tlti $t1,-100
tltiu $t1,-100

Trap if less than immediate unsigned : Trap if $t1 less than sign-extended 16-bit
immediate, unsigned comparison

tltu $t1,$t2

Trap if less than unsigned : Trap if $t1 less than $t2, unsigned comparison

tne $t1,$t2
tnei $t1,-100

Trap if not equal : Trap if $t1 is not equal to $t2

Trap if not equal to immediate : Trap if $t1 is not equal to sign-extended 16 bit
immediate

trunc.w.d $f1,$f2

Truncate double precision to word : Set $f1 to 32-bit integer truncation of doubleprecision float in $f2
Truncate single precision to word : Set $f0 to 32-bit integer truncation of singleprecision float in $f1
Bitwise XOR (exclusive OR) : Set $t1 to bitwise XOR of $t2 and $t3

trunc.w.s $f0,$f1
xor $t1,$t2,$t3
xori $t1,$t2,100

Bitwise XOR immediate : Set $t1 to bitwise XOR of $t2 and zero-extended 16-bit
immediate

[10]

Directives
The following list provides a description of all directives available in MARS.

Directives
.align
.ascii
.asciiz
.byte
.data
.double
.extern
.float
.globl
.half
.kdata
.ktext
.set
.space
.text
.word

Align next data item on specified byte boundary (0=byte, 1=half, 2=word, 3=double)
Store the string in the Data segment but do not add null terminator
Store the string in the Data segment and add null terminator
Store the listed value(s) as 8 bit bytes
Subsequent items stored in Data segment at next available address
Store the listed value(s) as double precision floating point
Declare the listed label and byte length to be a global data field
Store the listed value(s) as single precision floating point
Declare the listed label(s) as global to enable referencing from other files
Store the listed value(s) as 16 bit halfwords on halfword boundary
Subsequent items stored in Kernel Data segment at next available address
Subsequent items (instructions) stored in Kernel Text segment at next available address
Set assembler variables. Currently ignored but included for SPIM compatibility
Reserve the next specified number of bytes in Data segment
Subsequent items (instructions) stored in Text segment at next available address
Store the listed value(s) as 32 bit words on word boundary

[11]

Syscall Functions
A number of system services, mainly for input and output, are available for use by your MIPS program.
They are described in the table below.
How to use SYSCALL system services
Step 1. Load the service number in register $v0.
Step 2. Load argument values, if any, in $a0, $a1, $a2, or $f12 as specified.
Step 3. Issue the SYSCALL instruction.
Step 4. Retrieve return values, if any, from result registers as specified.

Example: display the value stored in $t0 on the console

li $v0, 1
add $a0, $t0, $zero

# service 1 is print integer

# load desired value into argument register
# $a0, using pseudo-op

syscall

Service

Code Arguments
in $v0

print integer

$a0 = integer to print

print float

$f12 = float to print

print double

$f12 = double to print

print string

$a0 = address of nullterminated string to

print

read integer

$v0 contains integer read

read float

$f0 contains float read

read double

$f0 contains double read

read string

$a0 = address of input

buffer
$a1 = maximum number
of characters to read

See note below table

sbrk (allocate heap

memory)

$a0 = number of bytes to

allocate

$v0 contains address of allocated memory

Result

[12]

exit (terminate
execution)

10

print character

11

read character

12

open file

13

$a0 = address of nullterminated string

containing filename
$a1 = flags
$a2 = mode

$v0 contains file descriptor (negative if error). See

note below table

read from file

14

$a0 = file descriptor

$a1 = address of input
buffer
$a2 = maximum number
of characters to read

$v0 contains number of characters read (0 if end-offile, negative if error). See note below table

write to file

15

$a0 = file descriptor

$a1 = address of output
buffer
$a2 = number of
characters to write

$v0 contains number of characters written (negative

if error). See note below table

close file

16

$a0 = file descriptor

exit2 (terminate with

value)

17

$a0 = termination result

$a0 = character to print

See note below table

$v0 contains character read

See note below table

Services 1 through 17 are compatible with the SPIM simulator, other than Open File (13) as described in the Notes
below the table. Services 30 and higher are exclusive to MARS.
$a0 = low order 32 bits of system time
$a1 = high order 32 bits of system time. See note
below table

time (system time)

30

MIDI out

31

$a0 = pitch (0-127)

$a1 = duration in
milliseconds
$a2 = instrument (0-127)
$a3 = volume (0-127)

Generate tone and return immediately. See MARS

help

sleep

32

$a0 = the length of time

to sleep in milliseconds.

Causes the MARS Java thread to sleep for (at least)

the specified number of milliseconds. This timing will
not be precise, as the Java implementation will add
some overhead.

[13]

MIDI out synchronous

33

$a0 = pitch (0-127)

$a1 = duration in
milliseconds
$a2 = instrument (0-127)
$a3 = volume (0-127)

print integer in
hexadecimal

34

$a0 = integer to print

print integer in binary

35

$a0 = integer to print

print integer as
unsigned

36

$a0 = integer to print

(not used)

37-39

set seed

40

$a0 = i.d. of
pseudorandom number
generator (any int).
$a1 = seed for
corresponding
pseudorandom number
generator.

No values are returned. Sets the seed of the

corresponding underlying Java pseudorandom
number generator (java.util.Random). See note below
table

random int

41

$a0 = i.d. of
pseudorandom number
generator (any int).

$a0 contains the next pseudorandom, uniformly

distributed int value from this random number
generator's sequence. See note below table

random int range

42

$a0 = i.d. of
pseudorandom number
generator (any int).
$a1 = upper bound of
range of returned values.

$a0 contains pseudorandom, uniformly distributed

int value in the range 0 = [int] [upper bound], drawn
from this random number generator's sequence. See
note below table

random float

43

$a0 = i.d. of
pseudorandom number
generator (any int).

$f0 contains the next pseudorandom, uniformly

distributed float value in the range 0.0 = f 1.0 from
this random number generator's sequence. See note
below table

random double

44

$a0 = i.d. of
pseudorandom number
generator (any int).

$f0 contains the next pseudorandom, uniformly

distributed double value in the range 0.0 = f 1.0 from
this random number generator's sequence. See note
below table

(not used)

45-49

[14]

Generate tone and return upon tone completion. See

MARS help

ConfirmDialog

50

$a0 = address of nullterminated string that is

the message to user

$a0 contains value of user-chosen option

0: Yes
1: No
2: Cancel

InputDialogInt

51

$a0 = address of nullterminated string that is

the message to user

$a0 contains int read

$a1 contains status value
0: OK status
-1: input data cannot be correctly parsed
-2: Cancel was chosen
-3: OK was chosen but no data had been input into
field

InputDialogFloat

52

$a0 = address of nullterminated string that is

the message to user

$f0 contains float read

$a1 contains status value
0: OK status
-1: input data cannot be correctly parsed
-2: Cancel was chosen
-3: OK was chosen but no data had been input into
field

InputDialogDouble

53

$a0 = address of nullterminated string that is

the message to user

$f0 contains double read

$a1 contains status value
0: OK status
-1: input data cannot be correctly parsed
-2: Cancel was chosen
-3: OK was chosen but no data had been input into
field

InputDialogString

54

$a0 = address of nullterminated string that is

the message to user
$a1 = address of input
buffer
$a2 = maximum number
of characters to read

See Service 8 note below table

$a1 contains status value
0: OK status. Buffer contains the input string.
-2: Cancel was chosen. No change to buffer.
-3: OK was chosen but no data had been input into
field. No change to buffer.
-4: length of the input string exceeded the specified
maximum. Buffer contains the maximum allowable
input string plus a terminating null.

MessageDialog

55

$a0 = address of nullterminated string that is

the message to user
$a1 = the type of
message to be displayed:
0: error message,
indicated by Error icon

N/A

[15]

1: information message,
indicated by Information
icon
2: warning message,
indicated by Warning
icon
3: question message,
indicated by Question
icon
other: plain message (no
icon displayed)
MessageDialogInt

56

$a0 = address of nullterminated string that is

an information-type
message to user
$a1 = int value to display
in string form after the
first string

N/A

MessageDialogFloat

57

$a0 = address of nullterminated string that is

an information-type
message to user
$f12 = float value to
display in string form
after the first string

N/A

MessageDialogDouble

58

$a0 = address of nullterminated string that is

an information-type
message to user
$f12 = double value to
display in string form
after the first string

N/A

MessageDialogString

59

$a0 = address of nullterminated string that is

an information-type
message to user
$a1 = address of nullterminated string to
display after the first
string

N/A

[16]

NOTES: Services numbered 30 and higher are not provided by SPIM

Service 8 - Follows semantics of UNIX 'fgets'. For specified length n, string can be no longer than n-1. If it is less than
that, adds newline to end. In either case, then pads with null byte.
Service 11 - Prints ASCII character corresponding to contents of low-order byte.
Service 13 - MARS implements three flag values: 0 for read-only, 1 for write-only with create, and 9 for write-only with
create and append. It ignores mode. The returned file descriptor will be negative if the operation failed. The
underlying file I/O implementation uses java.io.FileInputStream.read() to read and java.io.FileOutputStream.write() to
write. MARS maintains file descriptors internally and allocates them starting with 0.
Services 13,14,15 - In MARS 3.7, the result register was changed to $v0 for SPIM compatibility. It was previously $a0 as
erroneously printed in Appendix B of Computer Organization and Design,.
Service 17 - If the MIPS program is run under control of the MARS graphical interface (GUI), the exit code in $a0 is
ignored.
Service 30 - System time comes from java.util.Date.getTime() as milliseconds since 1 January 1970.
Services 40-44 use underlying Java pseudorandom number generators provided by the java.util.Random class. Each
stream (identified by $a0 contents) is modeled by a different Random object. There are no default seed values, so use
the Set Seed service (40) if replicated random sequences are desired.
Example of File I/O
The sample MIPS program below will open a new file for writing, write text to it from a memory buffer, then close it.
The file will be created in the directory in which MARS was run.
# Sample MIPS program that writes to a new file.
#
by Kenneth Vollmar and Pete Sanderson
.data
fout:
.asciiz "testout.txt"
# filename for output
buffer: .asciiz "The quick brown fox jumps over the lazy dog."
.text
###############################################################
# Open (for writing) a file that does not exist
li
$v0, 13
# system call for open file
la
$a0, fout
# output file name
li
$a1, 1
# Open for writing (flags are 0: read, 1: write)
li
$a2, 0
# mode is ignored
syscall
# open a file (file descriptor returned in $v0)
move $s6, $v0
# save the file descriptor
###############################################################
# Write to file just opened
li
$v0, 15
# system call for write to file
move $a0, $s6
# file descriptor
la
$a1, buffer
# address of buffer from which to write
li
$a2, 44
# hardcoded buffer length
syscall
# write to file
###############################################################
# Close the file
li
$v0, 16
# system call for close file
move $a0, $s6
# file descriptor to close
syscall
# close file
[17]