R3000 instruction set

From Final Fantasy Hacktics Wiki
Jump to: navigation, search

Intro

Instructions

Note: This section is meant to be linked to, and used to generate tooltips (title text) for code pages.

The first paragraph of an instruction's description should be a short one-liner. It will be used as the tooltip. Think "reminder", rather than "explanation".

These are stolen from Wikipedia. Whoops.

nop

No operation

Used to cause delays between instructions, because some instructions step on each other's toes.

Example:

nop

Arithmetic

These instructions act on registers as 32-bit two's-complement integers.

add

Add

Example:

add $d,$s,$t

addu

Add unsigned

Example:

addu $d,$s,$t

This operation is used to add both signed and unsigned integers (and is in fact the default used by C compilers). The "unsigned" part is misleading: it means that, if the sign changes, don't set the "overflow" error flag, which can cause an exception handler to trigger.

sub

Subtract

Example:

sub $d,$s,$t

subu

Subtract unsigned

Example:

subu $d,$s,$t

addi

Add immediate

Example:

addi $t,$s,C

addiu

Add immediate unsigned

Example:

addiu $t,$s,C

mult

mult $s,$t

Multiply $s and $t.

Unlike most instructions, this instruction doesn't say where to store the result. The product of two 32-bit integers is at most 64 bits long, so the top and bottom parts of the result are stored separately. To access them, use the #mflo (move from low) and #mfhi (move from high) instructions.

This instruction is slow, so the compiler might instead use a combination of shifts and additions for multiplications by constants.

This instruction is sometimes used to multiply by positive decimals less than 1. For example, to multiply by 0.14, the compiler can multiply by an integer close to 0.14 * 2^32, and then only take the high part of the result.

Example:

mult r2,r3        Multiply
mflo r4           r4 = the lower part of the product
mfhi r5           r5 = the upper part of the product
                  (r5 * 2^32) + r4 == r2 * r3 (mathematically)

multu

Multiply unsigned

Example:

multu $s,$t

div

Divide

Example:

div $s, $t

divu

Divide unsigned

Example:

divu $s, $t

Memory

Getting data from/to the RAM.

lw

Load word

Example:

lw $t,C($s)

lh

Load halfword

Example:

lh $t,C($s)

lhu

Load halfword unsigned

Example:

lhu $t,C($s)

lb

Load byte

Example:

lb $t,C($s)

lbu

Load byte unsigned

Example:

lbu $t,C($s)

sw

Store word

Example:

sw $t,C($s)

sh

Store half

Example:

sh $t,C($s)

sb

Store byte

Example:

sb $t,C($s)

lui

Load upper immediate

Example:

lui $t,C

mfhi

Move from high

Example:

mfhi $d

mflo

Move from low

Example:

mflo $d

Comparison

Comparing numbers.

Set $d to 1 if true, 0 if false.

slt

Set on less than

Example:

slt $d,$s,$t

slti

Set on less than immediate

Example:

slti $t,$s,C

Binary

These instructions act on registers as sequences of 0's and 1's.

and

And

Example:

and $d,$s,$t

andi

And immediate

Example:

andi $t,$s,C

or

Or

Example:

or $d,$s,$t

ori

Or immediate

Example:

ori $t,$s,C

xor

Exclusive or

Example:

xor $d,$s,$t

nor

Nor

Example:

nor $d,$s,$t

sll

Shift left logical immediate

Example:

sll $d,$t,shamt

srl

Shift right logical immediate

Example:

srl $d,$t,shamt

sra

Shift right arithmetic immediate

Example:

sra $d,$t,shamt

sllv

Shift left logical

Example:

sllv $d,$t,$s

srlv

Shift right logical

Example:

srlv $d,$t,$s

srav

Shift right arithmetic

Example:

srav $d,$t,$s

Control

These instructions may or will cause a jump to a different part of the program.

The instruction right after one of these will always be executed, even if there's a jump.

beq

Branch on equal

Example:

beq $s,$t,C

bne

Branch on not equal

Example:

bne $s,$t,C

j

Jump

Example:

j C

jr

Jump register

Example:

jr $s

jal

Jump and link

Example:

jal C