MIPS HELP

File:		mips.help
Author:		course (send problems to walton@das)
Version:	1

General		$0		always zero
Registers:	$a0, ..., $a3	argument
		$v0, $v1	return value
		$t0, ..., $t9	temporary
		$s0, ..., $s7	save
		$sp		stack pointer
		$ra		return address

Special		$pc		program counter
Registers:	$hi, $lo	multiply/divide

In The Following:

    integer    ::= signed 16 bit integer
    unsigned   ::= unsigned 16 bit integer
    rd, rs, rt ::= any general register

Immediate Instructions:

    addi  rt, rs, integer	rt = rs + integer
				  with trap on overflow
    addiu rt, rs, integer	rt = rs + integer
				  without trap
    slti  rt, rs, integer	rt = rs < integer
				  signed 32-bit <
    sltiu rt, rs, integer	rt = rs < integer
				  unsigned 32-bit <
    andi  rt, rs, unsigned	rt = rs & unsigned
    ori   rt, rs, unsigned	rt = rs | unsigned
    xori  rt, rs, unsigned	rt = rs ^ unsigned
    lui   rt, unsigned		rt = unsigned * 2**16

Register Instructions:

    add  rd, rs, rt	    rd = rs + rt  with trap
			      on signed overflow
    addu rd, rs, rt	    rd = rs + rt
			      without trap
    sub  rd, rs, rt	    rd = rs - rt  with trap
			      on signed overflow
    subu rd, rs, rt	    rd = rs - rt
			      without trap
    slt  rd, rs, rt	    rd = rs < rt
			      signed 32-bit <
    sltu rd, rs, rt	    rd = rs < rt
			      unsigned 32-bit <
    and  rd, rs, rt	    rd = rs & rt
    or   rd, rs, rt	    rd = rs | rt
    xor  rd, rs, rt	    rd = rs ^ rt

Branches and Jumps:

  symbol:		    Labels the next location.

    beq rs, rt, symbol	    if (rs == rt) $pc = symbol
    bne rs, rt, symbol	    if (rs != rt) $pc = symbol

    jal  symbol		    $ra = $pc + 4; $pc = symbol
    jalr rs		    $ra = $pc + 4; $pc = rs
    jr   rs		    $pc = rs

Memory Instructions:

    lw rt, offset(base)	    rt = W(base + offset)
    sw rt, offset(base)	    W(base + offset) = rt

    base   ::= any general register
    offset ::= signed 16-bit integer
    W(x)   ::= the RAM word at byte address x,
	       where x must be a multiple of 4

Multiply Instructions:

    mult  rs, rt	   $hi$lo = rs * rt
				signed 32-bit inputs;
				signed 64-bit product
    multu rs, rt	   $hi$lo = rs * rt
				unsigned 32-bit inputs;
				unsigned 64-bit product
    mfhi  rd		   rd = $hi
    mflo  rd		   rd = $lo

Pseudo Instructions:

    li rt, large_integer   rt = large_integer
    la rt, symbol	   rt = symbol value
				  (an address)
    move rd, rt		   rd = rt
    beqz rs, symbol	   if (rs == 0) $pc = symbol
    bnez rs, symbol	   if (rs != 0) $pc = symbol
    b    symbol		   $pc = symbol

    large_integer = 32-bit signed integer
       
System Calls:

    li $v0, 5
    syscall		    $v0 = read_int()

    li $v0, 1
    syscall		    print_int ($a0)

    li $v0, 10
    syscall		    exit()

    li $v0, 9
    syscall		    $v0 = sbrk ($a0)
	# address of block = sbrk (size in bytes)

Data Directives:

    .data		Switch to data segment.
    .text		Switch to text segment.
    .ascii "..."	Character string datum.
    .word integer	One word integer.
    .align 2		Bump next location to word
			  boundary.
    .globl symbol	Make symbol be global.


Standard Subroutine Prolog:

    Assumes arguments are in $a registers and
      return $pc address is in $ra.
    Push $s registers and $ra into stack, largest
      register number first ($ra, then $s7, ..., $s0).
    Move arguments from $a registers to $s registers.

Standard Subroutine Epilog:

    Assumes return value is in $v registers.
    Pop registers pushed by prolog.
    Jump to $ra.

Standard Subroutine Call:

    Copy arguments into $a registers.
    jal subroutine_name
    Return with value in $v registers;
      all registers but $s registers and $sp may be
      changed by called subroutine.