CPU Instruction Set Details

CPU Instruction Set Details
This appendix provides a detailed description of the operation of each R4000 instruction in both 32- and 64-bit modes. The instructions are listed in alphabetical order. Exceptions that may occur due to the execution of each instruction are listed after the description of each instruction. Descriptions of the immediate cause and manner of handling exceptions are omitted from the instruction descriptions in this appendix. Figures at the end of this appendix list the bit encoding for the constant fields of each instruction, and the bit encoding for each individual instruction is included with that instruction.
MIPS R4000 Microprocessor User's Manual
A-1
Appendix A
A.1 Instruction Classes

CPU instructions are divided into the following classes: Load and Store instructions move data between memory and general registers. They are all I-type instructions, since the only addressing mode supported is base register + 16-bit immediate offset. Computational instructions perform arithmetic, logical and shift operations on values in registers. They occur in both R-type (both operands are registers) and I-type (one operand is a 16-bit immediate) formats. Jump and Branch instructions change the control ow of a program. Jumps are always made to absolute 26-bit word addresses (J-type format), or register addresses (R-type), for returns and dispatches. Branches have 16-bit offsets relative to the program counter (I-type). Jump and Link instructions save their return address in register 31. Coprocessor instructions perform operations in the coprocessors. Coprocessor loads and stores are I-type. Coprocessor computational instructions have coprocessordependent formats (see the FPU instructions in Appendix B). Coprocessor zero (CP0) instructions manipulate the memory management and exception handling facilities of the processor. Special instructions perform a variety of tasks, including movement of data between special and general registers, trap, and breakpoint. They are always R-type.
A-2
A.2 Instruction Formats

Every CPU instruction consists of a single word (32 bits) aligned on a word boundary and the major instruction formats are shown in Figure A-1. I-Type (Immediate)
31 26 25 21 20 16 15 0
op J-Type (Jump)
31 26 25
rs
rt
immediate
op R-Type (Register)
31 26 25 21 20
target
16 15
11 10
6 5
op
rs
rt
rd
shamt
funct
op rs rt immediate target rd shamt funct
6-bit operation code 5-bit source register specifier 5-bit target (source/destination) or branch condition 16-bit immediate, branch displacement or address displacement 26-bit jump target address 5-bit destination register specifier 5-bit shift amount 6-bit function field
Figure A-1
CPU Instruction Formats
A-3
Appendix A
A.3 Instruction Notation Conventions

In this appendix, all variable subfields in an instruction format (such as rs, rt, immediate, etc.) are shown in lowercase names. For the sake of clarity, we sometimes use an alias for a variable subfield in the formats of specific instructions. For example, we use rs = base in the format for load and store instructions. Such an alias is always lower case, since it refers to a variable subfield. Figures with the actual bit encoding for all the mnemonics are located at the end of this Appendix, and the bit encoding also accompanies each instruction. In the instruction descriptions that follow, the Operation section describes the operation performed by each instruction using a high-level language notation. The R4000 can operate as either a 32- or 64-bit microprocessor and the operation for both modes is included with the instruction description. Special symbols used in the notation are described in Table A-1.
A-4
Table A-1
Symbol
CPU Instruction Operation Notations

Meaning
|| x
y
Assignment. Bit string concatenation. Replication of bit value x into a y-bit string. Note: x is always a single-bit value. Selection of bits y through z of bit string x. Little-endian bit notation is always used. If y is less than z, this expression is an empty (zero length) bit string. 2s complement or floating-point addition. 2s complement or floating-point subtraction. 2s complement or floating-point multiplication. 2s complement integer division. 2s complement modulo. Floating-point division. 2s complement less than comparison. Bit-wise logical AND. Bit-wise logical OR. Bit-wise logical XOR. Bit-wise logical NOR. General-Register x. The content of GPR[0] is always zero. Attempts to alter the content of GPR[0] have no effect. Coprocessor unit z, general register x. Coprocessor unit z, control register x. Coprocessor unit z condition signal. Big-endian mode as configured at reset (0 Little, 1 Big). Specifies the endianness of the memory interface (see LoadMemory and StoreMemory), and the endianness of Kernel and Supervisor mode execution. Signal to reverse the endianness of load and store instructions. This feature is available in User mode only, and is effected by setting the RE bit of the Status register. Thus, ReverseEndian may be computed as (SR25 and User mode). The endianness for load and store instructions (0 Little, 1 Big). In User mode, this endianness may be reversed by setting SR25. Thus, BigEndianCPU may be computed as BigEndianMem XOR ReverseEndian. Bit of state to specify synchronization instructions. Set by LL, cleared by ERET and Invalidate and read by SC. Indicates the time steps between operations. Each of the statements within a time step are defined to be executed in sequential order (as modified by conditional and loop constructs). Operations which are marked T+i: are executed at instruction cycle i relative to the start of execution of the instruction. Thus, an instruction which starts at time j executes operations marked T+i: at time i + j. The interpretation of the order of execution between two instructions or two operations which execute at the same time should be pessimistic; the order is not defined.
xy:z + * div mod / < and or xor nor GPR[x] CPR[z,x] CCR[z,x] COC[z] BigEndianMem
ReverseEndian
BigEndianCPU
LLbit T+i:
A-5
Appendix A
Instruction Notation Examples

The following examples illustrate the application of some of the instruction notation conventions:
Example #1: GPR[rt] immediate || 016
Sixteen zero bits are concatenated with an immediate value (typically 16 bits), and the 32-bit string (with the lower 16 bits set to zero) is assigned to General-Purpose Register rt.
Example #2: (immediate15)16 || immediate15...0

Bit 15 (the sign bit) of an immediate value is extended for 16 bit positions, and the result is concatenated with bits 15 through 0 of the immediate value to form a 32-bit sign extended value.
A-6
A.4 Load and Store Instructions

In the R4000 implementation, the instruction immediately following a load may use the loaded contents of the register. In such cases, the hardware interlocks, requiring additional real cycles, so scheduling load delay slots is still desirable, although not required for functional code. Two special instructions are provided in the R4000 implementation of the MIPS ISA, Load Linked and Store Conditional. These instructions are used in carefully coded sequences to provide one of several synchronization primitives, including test-and-set, bit-level locks, semaphores, and sequencers/event counts. In the load and store descriptions, the functions listed in Table A-2 are used to summarize the handling of virtual addresses and physical memory. Table A-2 Function AddressTranslation Load and Store Common Functions Meaning Uses the TLB to find the physical address given the virtual address. The function fails and an exception is taken if the required translation is not present in the TLB. Uses the cache and main memory to find the contents of the word containing the specified physical address. The low-order two bits of the address and the Access Type field indicates which of each of the four bytes within the data word need to be returned. If the cache is enabled for this access, the entire word is returned and loaded into the cache. Uses the cache, write buffer, and main memory to store the word or part of word specified as data in the word containing the specified physical address. The low-order two bits of the address and the Access Type field indicates which of each of the four bytes within the data word should be stored.
LoadMemory
StoreMemory
A-7
Appendix A
As shown in Table A-3, the Access Type field indicates the size of the data item to be loaded or stored. Regardless of access type or byte-numbering order (endianness), the address specifies the byte which has the smallest byte address in the addressed field. For a big-endian machine, this is the leftmost byte and contains the sign for a 2s complement number; for a little-endian machine, this is the rightmost byte. Table A-3 Access Type Specifications for Loads/Stores Value 7 6 5 4 3 2 1 0 Meaning 8 bytes (64 bits) 7 bytes (56 bits) 6 bytes (48 bits) 5 bytes (40 bits) 4 bytes (32 bits) 3 bytes (24 bits) 2 bytes (16 bits) 1 byte (8 bits)
Access Type Mnemonic DOUBLEWORD SEPTIBYTE SEXTIBYTE QUINTIBYTE WORD TRIPLEBYTE HALFWORD BYTE
The bytes within the addressed doubleword which are used can be determined directly from the access type and the three low-order bits of the address.
A-8
A.5 Jump and Branch Instructions

All jump and branch instructions have an architectural delay of exactly one instruction. That is, the instruction immediately following a jump or branch (that is, occupying the delay slot) is always executed while the target instruction is being fetched from storage. A delay slot may not itself be occupied by a jump or branch instruction; however, this error is not detected and the results of such an operation are undefined. If an exception or interrupt prevents the completion of a legal instruction during a delay slot, the hardware sets the EPC register to point at the jump or branch instruction that precedes it. When the code is restarted, both the jump or branch instructions and the instruction in the delay slot are reexecuted. Because jump and branch instructions may be restarted after exceptions or interrupts, they must be restartable. Therefore, when a jump or branch instruction stores a return link value, register 31 (the register in which the link is stored) may not be used as a source register. Since instructions must be word-aligned, a Jump Register or Jump and Link Register instruction must use a register whose two low-order bits are zero. If these low-order bits are not zero, an address exception will occur when the jump target instruction is subsequently fetched.
A-9
Appendix A
A.6 Coprocessor Instructions

Coprocessors are alternate execution units, which have register files separate from the CPU. The MIPS architecture provides four coprocessor units, or classes, and these coprocessors have two register spaces, each space containing thirty-two 32-bit registers. The rst space, coprocessor general registers, may be directly loaded from memory and stored into memory, and their contents may be transferred between the coprocessor and processor. The second space, coprocessor control registers, may only have their contents transferred directly between the coprocessor and the processor. Coprocessor instructions may alter registers in either space.
A.7 System Control Coprocessor (CP0) Instructions

There are some special limitations imposed on operations involving CP0 that is incorporated within the CPU. Although load and store instructions to transfer data to/from coprocessors and to move control to/from coprocessor instructions are generally permitted by the MIPS architecture, CP0 is given a somewhat protected status since it has responsibility for exception handling and memory management. Therefore, the move to/ from coprocessor instructions are the only valid mechanism for writing to and reading from the CP0 registers. Several CP0 instructions are defined to directly read, write, and probe TLB entries and to modify the operating modes in preparation for returning to User mode or interrupt-enabled states.
A-10
ADD
31 26 25 SPECIAL 000000 6 rs 5 21 20 rt 5
Add
16 15 rd 5 11 10 6 5
ADD
0 ADD 100000 6 0 00000 5
Format:
ADD rd, rs, rt
Description:
The contents of general register rs and the contents of general register rt are added to form the result. The result is placed into general register rd. In 64-bit mode, the operands must be valid sign-extended, 32-bit values. An overflow exception occurs if the carries out of bits 30 and 31 differ (2s complement overflow). The destination register rd is not modified when an integer overflow exception occurs.
Operation:
32 64 T: T: GPR[rd] GPR[rs] + GPR[rt] temp GPR[rs] + GPR[rt] GPR[rd] (temp31)32 || temp31...0
Exceptions:
Integer overflow exception
A-11
Appendix A
ADDI
31 26 25 ADDI 001000 6 rs 5
Add Immediate
21 20 rt 5 16 15 immediate 16
ADDI
0
Format:
ADDI rt, rs, immediate
Description:
The 16-bit immediate is sign-extended and added to the contents of general register rs to form the result. The result is placed into general register rt. In 64-bit mode, the operand must be valid sign-extended, 32-bit values. An overflow exception occurs if carries out of bits 30 and 31 differ (2s complement overflow). The destination register rt is not modified when an integer overflow exception occurs.
Operation:
32 64 T: T: GPR [rt] GPR[rs] +(immediate15)16 || immediate15...0 temp GPR[rs] + (immediate15)48 || immediate15...0 GPR[rt] (temp31)32 || temp31...0
Exceptions:
A-12
ADDIU
31 26 25 ADDIU 001001 6 rs 5
Add Immediate Unsigned

21 20 rt 5 16 15
ADDIU
0
immediate 16
Format:
ADDIU rt, rs, immediate
Description:
The 16-bit immediate is sign-extended and added to the contents of general register rs to form the result. The result is placed into general register rt. No integer overflow exception occurs under any circumstances. In 64-bit mode, the operand must be valid sign-extended, 32-bit values. The only difference between this instruction and the ADDI instruction is that ADDIU never causes an overflow exception.
Operation:
32 64 T: T: GPR [rt] GPR[rs] + (immediate15)16 || immediate15...0 temp GPR[rs] + (immediate15)48 || immediate15...0 GPR[rt] (temp31)32 || temp31...0
Exceptions:
None
A-13
Appendix A
ADDU
31 26 25 SPECIAL 000000 6 rs 5
Add Unsigned
21 20 rt 5 16 15 rd 5 11 10 6
ADDU
5 ADDU 100001 6 0 0 00000 5
Format:
ADDU rd, rs, rt
Description:
The contents of general register rs and the contents of general register rt are added to form the result. The result is placed into general register rd. No overflow exception occurs under any circumstances. In 64-bit mode, the operands must be valid sign-extended, 32-bit values. The only difference between this instruction and the ADD instruction is that ADDU never causes an overflow exception.
Operation:
32 64 T: T: GPR[rd] GPR[rs] + GPR[rt] temp GPR[rs] + GPR[rt] GPR[rd] (temp31)32 || temp31...0
Exceptions:
None
A-14
AND
31 26 25 SPECIAL 000000 6 rs 5 21 20 rt 5
And
16 15 rd 5 11 10 0 00000 5 6 5
AND
0 AND 100100 6
Format:
AND rd, rs, rt
Description:
The contents of general register rs are combined with the contents of general register rt in a bit-wise logical AND operation. The result is placed into general register rd.
Operation:
32 64 T: T: GPR[rd] GPR[rs] and GPR[rt] GPR[rd] GPR[rs] and GPR[rt]
Exceptions:
None
A-15
Appendix A
ANDI
31 26 25 ANDI 001100 6 rs 5
And Immediate
21 20 rt 5 16 15 immediate 16
ANDI
0
Format:
ANDI rt, rs, immediate
Description:
The 16-bit immediate is zero-extended and combined with the contents of general register rs in a bit-wise logical AND operation. The result is placed into general register rt.
Operation:
32 64 T: T: GPR[rt] 016 || (immediate and GPR[rs]15...0) GPR[rt] 048 || (immediate and GPR[rs]15...0)
Exceptions:
None
A-16
BCzF
31 COPz 0 1 0 0 x x* 6
Branch On Coprocessor z False

21 20 16 15 offset 16
BCzF
0
26 25
BC 01000 5
BCF 00000 5
Format:
BCzF offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If coprocessor zs condition signal (CpCond), as sampled during the previous instruction, is false, then the program branches to the target address with a delay of one instruction. Because the condition line is sampled during the previous instruction, there must be at least one instruction between this instruction and a coprocessor instruction that changes the condition line.
Operation:
32 T1: condition not COC[z] T: target (offset15)14 || offset || 02 T+1: if condition then PC PC + target endif T1: condition not COC[z] T: target (offset15)46 || offset || 02 T+1: if condition then PC PC + target endif
64
*See the table Opcode Bit Encoding on next page, or CPU Instruction Opcode Bit Encoding at the end of Appendix A.
MIPS R4000 Microprocessor User's Manual A-17
Appendix A
BCzF
Branch On Coprocessor z False (continued)
BCzF
Exceptions:
Coprocessor unusable exception
Opcode Bit Encoding:
BCzF Bit #
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0
BC0F 0
Bit # 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 BC1F 0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 Bit # 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 BC2F 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 Opcode Coprocessor Unit Number BC sub-opcode Branch condition
A-18
BCzFL
31 26 25 COPz 0 1 0 0 x x* 6
Branch On Coprocessor z False Likely

21 20 16 15 offset 16
BCzFL
0
BC 01000 5
BCFL 00010 5
Format:
BCzFL offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If the contents of coprocessor zs condition line, as sampled during the previous instruction, is false, the target address is branched to with a delay of one instruction. If the conditional branch is not taken, the instruction in the branch delay slot is nullified. Because the condition line is sampled during the previous instruction, there must be at least one instruction between this instruction and a coprocessor instruction that changes the condition line.
A-19
Appendix A
BCzFL
Operation:
32
Branch On Coprocessor z False Likely (continued)
BCzFL
T1: condition not COC[z] T: target (offset15)14 || offset || 02 T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T1: condition not COC[z] T: target (offset15)46 || offset || 02 T+1: if condition then PC PC + target else NullifyCurrentInstruction endif
64
Exceptions:
BCzFL
Bit # 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 BC0FL 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 Bit # 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 BC1FL 0 1 0 0 0 1 0 1 0 0 0 0 0 0 1 0 Bit # 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 BC2FL 0 1 0 0 1 0 0 1 0 0 0 0 0 0 1 0 Opcode BC sub-opcode Branch condition
0 0
Coprocessor Unit Number
A-20
BCzT
31 26 25 COPz 0 1 0 0 x x* 6
Branch On Coprocessor z True

21 20 BCT 00001 5 16 15 offset 16
BCzT
0
BC 01000 5
Format:
BCzT offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If the coprocessor zs condition signal (CpCond) is true, then the program branches to the target address, with a delay of one instruction. Because the condition line is sampled during the previous instruction, there must be at least one instruction between this instruction and a coprocessor instruction that changes the condition line.
Operation:
32 T1: condition COC[z] T: target (offset15)14 || offset || 02 T+1: if condition then PC PC + target endif T1: condition COC[z] T: target (offset15)46 || offset || 02 T+1: if condition then PC PC + target endif
64
Appendix A
BCzT
Exceptions:
Branch On Coprocessor z True (continued)
BCzT
BCzT
Bit # 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 BC0T 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1
Bit # 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 BC1T 0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 1 Bit # 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 BC2T 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 1 Opcode Coprocessor Unit Number BC sub-opcode Branch condition
A-22
BCzTL
31 26 25 COPz 0 1 0 0 x x* 6
Branch On Coprocessor z True Likely

21 20 16 15 offset 16
BCzTL
0
BC 01000 5
BCTL 00011 5
Format:
BCzTL offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If the contents of coprocessor zs condition line, as sampled during the previous instruction, is true, the target address is branched to with a delay of one instruction. If the conditional branch is not taken, the instruction in the branch delay slot is nullified. Because the condition line is sampled during the previous instruction, there must be at least one instruction between this instruction and a coprocessor instruction that changes the condition line.
Operation:
32 T1: condition COC[z] T: target (offset15)14 || offset || 02 T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T1: condition COC[z] T: target (offset15)46|| offset || 02 T+1: if condition then PC PC + target else NullifyCurrentInstruction endif *See the table Opcode Bit Encoding on next page, or CPU Instruction Opcode Bit Encoding at the end of Appendix A.
64
Appendix A
BCzTL
Exceptions:
Branch On Coprocessor z True Likely (continued)
BCzTL
BCzTL
Bit # 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 BC0TL 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 1 Bit # 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 BC1TL 0 1 0 0 0 1 0 1 0 0 0 0 0 0 1 1
Bit # 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 BC2TL 0 1 0 0 1 0 0 1 0 0 0 0 0 0 1 1 Opcode Coprocessor Unit Number BC sub-opcode Branch condition
A-24
BEQ
31 26 25 BEQ 000100 6 rs 5
Branch On Equal
21 20 rt 5 16 15 offset 16
BEQ
0
Format:
BEQ rs, rt, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. The contents of general register rs and the contents of general register rt are compared. If the two registers are equal, then the program branches to the target address, with a delay of one instruction.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs] = GPR[rt]) T+1: if condition then PC PC + target endif T: target (offset15)46 || offset || 02 condition (GPR[rs] = GPR[rt]) T+1: if condition then PC PC + target endif T:
64
Exceptions:
None
A-25
Appendix A
BEQL
31 26 25 BEQL 010100 6 rs 5
Branch On Equal Likely

21 20 rt 5 16 15 offset 16
BEQL
0
Format:
BEQL rs, rt, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. The contents of general register rs and the contents of general register rt are compared. If the two registers are equal, the target address is branched to, with a delay of one instruction. If the conditional branch is not taken, the instruction in the branch delay slot is nullified.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs] = GPR[rt]) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T: target (offset15)46 || offset || 02 T: condition (GPR[rs] = GPR[rt]) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif
64
Exceptions:
None
A-26
BGEZ
31 26 25 REGIMM 000001 6 rs 5
Branch On Greater Than Or Equal To Zero

21 20 16 15 offset 16
BGEZ
0
BGEZ 00001 5
Format:
BGEZ rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If the contents of general register rs have the sign bit cleared, then the program branches to the target address, with a delay of one instruction.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs]31 = 0) T+1: if condition then PC PC + target endif T: T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 0) T+1: if condition then PC PC + target endif
64
Exceptions:
None
A-27
Appendix A
BGEZAL
31 26 25 REGIMM 000001 6 rs 5
Branch On Greater Than Or Equal To Zero And Link

21 20 BGEZAL 10001 5 16 15
BGEZAL
0 offset 16
Format:
BGEZAL rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. Unconditionally, the address of the instruction after the delay slot is placed in the link register, r31. If the contents of general register rs have the sign bit cleared, then the program branches to the target address, with a delay of one instruction. General register rs may not be general register 31, because such an instruction is not restartable. An attempt to execute this instruction is not trapped, however.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs]31 = 0) GPR[31] PC + 8 T+1: if condition then PC PC + target endif T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 0) GPR[31] PC + 8 T+1: if condition then PC PC + target endif T:
64
Exceptions:
None
A-28 MIPS R4000 Microprocessor User's Manual
BGEZALL
31 26 25 REGIMM 000001 6 rs 5
Branch On Greater Than Or Equal To Zero And Link Likely

16 15
BGEZALL
0 offset 16
21 20
BGEZALL 10011 5
Format:
BGEZALL rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. Unconditionally, the address of the instruction after the delay slot is placed in the link register, r31. If the contents of general register rs have the sign bit cleared, then the program branches to the target address, with a delay of one instruction. General register rs may not be general register 31, because such an instruction is not restartable. An attempt to execute this instruction is not trapped, however. If the conditional branch is not taken, the instruction in the branch delay slot is nullified. Operation: 32 target (offset15)14 || offset || 02 condition (GPR[rs]31 = 0) GPR[31] PC + 8 T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 0) GPR[31] PC + 8 T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T: None
64
Exceptions:
Appendix A
BGEZL
31 26 25 REGIMM 000001 6
Branch On Greater Than Or Equal To Zero Likely

21 20 rs 5 BGEZL 00011 5 16 15 offset 16
BGEZL
0
Format:
BGEZL rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If the contents of general register rs have the sign bit cleared, then the program branches to the target address, with a delay of one instruction. If the conditional branch is not taken, the instruction in the branch delay slot is nullified.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs]31 = 0) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 0) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T:
64
Exceptions:
None
A-30
BGTZ
31 26 25 BGTZ 000111 6
Branch On Greater Than Zero

21 20 rs 5 0 00000 5 16 15 offset 16
BGTZ
0
Format:
BGTZ rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. The contents of general register rs are compared to zero. If the contents of general register rs have the sign bit cleared and are not equal to zero, then the program branches to the target address, with a delay of one instruction.
Operation:
32 T: target (offset15)14 || offset || 02 condition (GPR[rs]31 = 0) and (GPR[rs] 032) T+1: if condition then PC PC + target endif 64 T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 0) and (GPR[rs] 064) T+1: if condition then PC PC + target endif
Exceptions:
None
A-31
Appendix A
BGTZL
31 26 25 BGTZL 010111 6 rs 5
Branch On Greater Than Zero Likely

21 20 0 00000 5 16 15 offset 16
BGTZL
0
Format:
BGTZL rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. The contents of general register rs are compared to zero. If the contents of general register rs have the sign bit cleared and are not equal to zero, then the program branches to the target address, with a delay of one instruction. If the conditional branch is not taken, the instruction in the branch delay slot is nullified.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs]31 = 0) and (GPR[rs] 032) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 0) and (GPR[rs] 064) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T:
64
Exceptions:
None
A-32
BLEZ
31 26 25 BLEZ 000110 6 rs 5
Branch on Less Than Or Equal To Zero

21 20 0 00000 5 16 15 offset 16
BLEZ
0
Format:
BLEZ rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. The contents of general register rs are compared to zero. If the contents of general register rs have the sign bit set, or are equal to zero, then the program branches to the target address, with a delay of one instruction.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs]31 = 1) or (GPR[rs] = 032) T+1: if condition then PC PC + target endif T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 1) or (GPR[rs] = 064) T+1: if condition then PC PC + target endif T:
64
Exceptions:
None
A-33
Appendix A
BLEZL
31 26 25 BLEZL 010110 6 rs 5
Branch on Less Than Or Equal To Zero Likely

21 20 0 00000 5 16 15 offset 16
BLEZL
0
Format:
BLEZL rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. The contents of general register rs is compared to zero. If the contents of general register rs have the sign bit set, or are equal to zero, then the program branches to the target address, with a delay of one instruction. If the conditional branch is not taken, the instruction in the branch delay slot is nullified.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs]31 = 1) or (GPR[rs] = 032) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 1) or (GPR[rs] = 064) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T:
64
Exceptions:
None
A-34
BLTZ
31 26 25 REGIMM 000001 6
Branch On Less Than Zero

21 20 rs 5 BLTZ 00000 5 16 15 offset 16
BLTZ
0
Format:
BLTZ rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If the contents of general register rs have the sign bit set, then the program branches to the target address, with a delay of one instruction.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs]31 = 1) T+1: if condition then PC PC + target endif T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 1) T+1: if condition then PC PC + target endif T:
64
Exceptions:
None
A-35
Appendix A
BLTZAL
31 26 25 REGIMM 000001 6 rs 5
Branch On Less Than Zero And Link

21 20 BLTZAL 10000 5 16 15
BLTZAL
0 offset 16
Format:
BLTZAL rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. Unconditionally, the address of the instruction after the delay slot is placed in the link register, r31. If the contents of general register rs have the sign bit set, then the program branches to the target address, with a delay of one instruction. General register rs may not be general register 31, because such an instruction is not restartable. An attempt to execute this instruction with register 31 specified as rs is not trapped, however.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs]31 = 1) GPR[31] PC + 8 T+1: if condition then PC PC + target endif T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 1) GPR[31] PC + 8 T+1: if condition then PC PC + target endif T:
64
Exceptions:
None
A-36
BLTZALL
31 26 25 rs 5 REGIMM 000001 6
Branch On Less Than Zero And Link Likely

21 20 16 15
BLTZALL
0 offset 16
BLTZALL 10010 5
Format:
BLTZALL rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. Unconditionally, the address of the instruction after the delay slot is placed in the link register, r31. If the contents of general register rs have the sign bit set, then the program branches to the target address, with a delay of one instruction. General register rs may not be general register 31, because such an instruction is not restartable. An attempt to execute this instruction with register 31 specified as rs is not trapped, however. If the conditional branch is not taken, the instruction in the branch delay slot is nullified.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs]31 = 1) GPR[31] PC + 8 T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 1) GPR[31] PC + 8 T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T:
64
Exceptions:
None
Appendix A
BLTZL
31 26 25 REGIMM 000001 6
Branch On Less Than Zero Likely

21 20 rs 5 BLTZL 00010 5 16 15 offset 16
BLTZL
0
Format:
BLTZ rs, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If the contents of general register rs have the sign bit set, then the program branches to the target address, with a delay of one instruction. If the conditional branch is not taken, the instruction in the branch delay slot is nullified.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs]31 = 1) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T: target (offset15)46 || offset || 02 condition (GPR[rs]63 = 1) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T:
64
Exceptions:
None
A-38
BNE
31 26 25 BNE 000101 6 rs 5
Branch On Not Equal

21 20 rt 5 16 15 offset 16
BNE
0
Format:
BNE rs, rt, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. The contents of general register rs and the contents of general register rt are compared. If the two registers are not equal, then the program branches to the target address, with a delay of one instruction.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs] GPR[rt]) T+1: if condition then PC PC + target endif T: T: target (offset15)46 || offset || 02 condition (GPR[rs] GPR[rt]) T+1: if condition then PC PC + target endif
64
Exceptions:
None
A-39
Appendix A
BNEL
31 26 25 BNEL 010101 6
Branch On Not Equal Likely

21 20 rs 5 rt 5 16 15 offset 16
BNEL
0
Format:
BNEL rs, rt, offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. The contents of general register rs and the contents of general register rt are compared. If the two registers are not equal, then the program branches to the target address, with a delay of one instruction. If the conditional branch is not taken, the instruction in the branch delay slot is nullified.
Operation:
32 target (offset15)14 || offset || 02 condition (GPR[rs] GPR[rt]) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T: target (offset15)46 || offset || 02 condition (GPR[rs] GPR[rt]) T+1: if condition then PC PC + target else NullifyCurrentInstruction endif T:
64
Exceptions:
None
BREAK
31 SPECIAL 000000 6 26 25
Breakpoint
65 code 20
BREAK
0 BREAK 001101 6
Format:
BREAK
Description:
A breakpoint trap occurs, immediately and unconditionally transferring control to the exception handler. The code field is available for use as software parameters, but is retrieved by the exception handler only by loading the contents of the memory word containing the instruction.
Operation:
32, 64 T: BreakpointException
Exceptions:
Breakpoint exception
A-41
Appendix A
CACHE
31 26 25 CACHE 101111 6 base 5 21 20 op 5
Cache
16 15 offset 16
CACHE
0
Format:
CACHE op, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The virtual address is translated to a physical address using the TLB, and the 5-bit sub-opcode specifies a cache operation for that address. If CP0 is not usable (User or Supervisor mode) the CP0 enable bit in the Status register is clear, and a coprocessor unusable exception is taken. The operation of this instruction on any operation/cache combination not listed below, or on a secondary cache when none is present, is undefined. The operation of this instruction on uncached addresses is also undefined. The Index operation uses part of the virtual address to specify a cache block. For a primary cache of 2CACHEBITS bytes with 2LINEBITS bytes per tag, vAddrCACHEBITS ... LINEBITS specifies the block. For a secondary cache of 2CACHEBITS bytes with 2LINEBITS bytes per tag, pAddrCACHEBITS ... LINEBITS specifies the block. Index Load Tag also uses vAddrLINEBITS... 3 to select the doubleword for reading ECC or parity. When the CE bit of the Status register is set, Hit WriteBack, Hit WriteBack Invalidate, Index WriteBack Invalidate, and Fill also use vAddrLINEBITS ... 3 to select the doubleword that has its ECC or parity modified. This operation is performed unconditionally. The Hit operation accesses the specified cache as normal data references, and performs the specified operation if the cache block contains valid data with the specified physical address (a hit). If the cache block is invalid or contains a different address (a miss), no operation is performed.
CACHE
Cache (continued)
CACHE
Write back from a primary cache goes to the secondary cache (if there is one), otherwise to memory. Write back from a secondary cache always goes to memory. A secondary write back always writes the most recent data; the data comes from the primary data cache, if present, and modified (the W bit is set). Otherwise the data comes from the specified secondary cache. The address to be written is specified by the cache tag and not the translated physical address. TLB Refill and TLB Invalid exceptions can occur on any operation. For Index operations (where the physical address is used to index the cache but need not match the cache tag) unmapped addresses may be used to avoid TLB exceptions. This operation never causes TLB Modified or Virtual Coherency exceptions. Bits 17...16 of the instruction specify the cache as follows: Code 0 1 2 3 Name I D SI SD primary instruction primary data secondary instruction secondary data (or combined instruction/data) Cache
A-43
Appendix A
CACHE
Cache (continued)
CACHE
Bits 20...18 (this value is listed under the Code column) of the instruction specify the operation as follows:
Code
0
Caches
I, SI
Name
Index Invalidate
Operation
Set the cache state of the cache block to Invalid. Examine the cache state and Writeback bit (W bit) of the primary data cache block at the index specified by the virtual address. If the state is not Invalid and the W bit is set, write the block back to the secondary cache (if present) or to memory (if no secondary cache). The address to write is taken from the primary cache tag. When a secondary cache is present, and the CE bit of the Status register is set, the contents of the ECC register is XORd into the computed check bits during the write to the secondary cache for the addressed doubleword. Set the cache state of primary cache block to Invalid. The W bit is unchanged (and irrelevant because the state is Invalid). Examine the cache state of the secondary data cache block at the index specified by the physical address. If the block is dirty (the state is Dirty Exclusive or Dirty Shared), write the data back to memory. Like all secondary writebacks, the operation writes any modified data for the addresses from the primary data cache. The address to write is taken from the secondary cache tag. The PIdx field of the secondary tag is used to determine the locations in the primaries to check for matching primary blocks. In all cases, set the state of the secondary cache block and all matching primary subblocks to Invalid. No Invalidate is sent on the R4000s system interface. Read the tag for the cache block at the specified index and place it iinto the TagLo and TagHi CP0 registers, ignoring any ECC or parity errors. Also load the data ECC or parity bits into the ECC register. Write the tag for the cache block at the specified index from the TagLo and TagHi CP0 registers. The processor uses computed parity for the primary caches and the TagLo register in the case of the secondary cache.
Index Writeback Invalidate
SD
Index Writeback Invalidate
All
Index Load Tag
All
Index Store Tag
A-44
CACHE
Code Caches Name
Cache (continued)
CACHE
Operation
This operation is used to avoid loading data needlessly from memory when writing new contents into an entire cache block. If the cache block is valid but does not contain the specified address (a valid miss) the secondary block is vacated. The data is written back to memory if dirty and all matching blocks in both primary caches are invalidated. As usual during a secondary writeback, if the primary data cache contains modified data (matching blocks with W bit set) that modified data is written to memory. If the cache block is valid and contains the specified physical address (a hit), the operation cleans up the primary caches to avoid virtual aliases: all blocks in both primary caches that match the secondary line are invalidated without writeback. Note that the search for matching primary blocks uses the virtual index of the PIdx field of the secondary cache tag (the virtual index when the location was last used) and not the virtual index of the virtual address used in the operation (the virtual index where the location will now be used). If the secondary tag and address do not match (miss), or the tag and address do match (hit) and the block is in a shared state, an invalidate for the specified address is sent over the System interface. In all cases, the cache block tag must be set to the specified physical address, the cache state must be set to Dirty Exclusive, and the virtual index field set from the virtual address. The CH bit in the Status register is set or cleared to indicate a hit or miss. This operation is used to avoid loading data needlessly from secondary cache or memory when writing new contents into an entire cache block. If the cache block does not contain the specified address, and the block is dirty, write it back to the secondary cache (if present) or otherwise to memory. In all cases, set the cache block tag to the specified physical address, set the cache state to Dirty Exclusive. If the cache block contains the specified address, mark the cache block invalid. If the cache block contains the specified address, mark the cache block invalid and also invalidate all matching blocks, if present, in the primary caches (the PIdx field of the secondary tag is used to determine the locations in the primaries to search). The CH bit in the Status register is set or cleared to indicate a hit or miss. If the cache block contains the specified address, write the data back if it is dirty, and mark the cache block invalid. When a secondary cache is present, and the CE bit of the Status register is set, the contents of the ECC register is XORd into the computed check bits during the write to the secondary cache for the addressed doubleword.
SD
Create Dirty Exclusive
Create Dirty Exclusive
I,D
Hit Invalidate
SI, SD
Hit Invalidate
Hit Writeback Invalidate
A-45
Appendix A
CACHE
Code Caches Name
Cache (continued)
Operation
CACHE
SD
Hit Writeback Invalidate
If the cache block contains the specified address, write back the data (if dirty), and mark the secondary cache block and all matching blocks in both primary caches invalid. As usual with secondary writebacks, modified data in the primary data cache (matching block with the W bit set) is used during the writeback. The PIdx field of the secondary tag is used to determine the locations in the primaries to check for matching primary blocks. The CH bit in the Status register is set or cleared to indicate a hit or miss. Fill the primary instruction cache block from secondary cache or memory. If the CE bit of the Status register is set, the content of the ECC register is used instead of the computed parity bits for addressed doubleword when written to the instruction cache. For the R4000PC, the cache is filled from memory. For the R4000SC and R4000MC, the cache is filled from the secondary cache whether or not the secondary cache block is valid or contains the specified address. If the cache block contains the specified address, and the W bit is set, write back the data. The W bit is not cleared; a subsequent miss to the block will write it back again. This second writeback is redundant, but not incorrect. When a secondary cache is present, and the CE bit of the Status register is set, the content of the ECC register is XORd into the computed check bits during the write to the secondary cache for the addressed doubleword. Note: The W bit is not cleared during this operation due to an artifact of the implementation; the W bit is implemented as part of the data side of the cache array so that it can be written during a data write. If the cache block contains the specified address, and the cache state is Dirty Exclusive or Dirty Shared, data is written back to memory. The cache state is unchanged; a subsequent miss to the block causes it to be written back again. This second writeback is redundant, but not incorrect. The CH bit in the Status register is set or cleared to indicate a hit or miss. The writeback looks in the primary data cache for modified data, but does not invalidate or clear the Writeback bit in the primary data cache. Note: The state of the secondary block is not changed to clean during this operation because the W bit of matching sub-blocks cannot be cleared to put the primary block in a clean state. If the cache block contains the specified address, data is written back unconditionally. When a secondary cache is present, and the CE bit of the Status register is set, the contents of the ECC register is XORd into the computed check bits during the write to the secondary cache for the addressed doubleword.
Fill
Hit Writeback
SD
Hit Writeback
Hit Writeback
A-46
CACHE
Code Caches Name
Cache (continued)
CACHE
Operation
This operation is used to change the virtual index of secondary cache contents, avoiding unnecessary memory operations. If the cache block contains the specified address, invalidate matching blocks in the primary caches at the index formed by concatenating PIdx in the secondary cache tag (not the virtual address of the operation) and vAddr11..4, and then set the virtual index field of the secondary cache tag from the specified virtual address. Modified data in the primary data cache is not preserved by the operation and should be explicitly written back before this operation. The CH bit in the Status register is set or cleared to indicate a hit or miss.
SI,SD
Hit Set Virtual
Operation:
32, 64 T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) CacheOp (op, vAddr, pAddr)
Exceptions:
A-47
Appendix A
CFCz
31 26 25 COPz 0 1 0 0 x x* 6 CF 00010 5
Move Control From Coprocessor

21 20 rt 5 16 15 rd 5 11 10
CFCz
0 0 00000 11
Format:
CFCz rt, rd
Description:
The contents of coprocessor control register rd of coprocessor unit z are loaded into general register rt. This instruction is not valid for CP0.
Operation:
32 64 T: data CCR[z,rd] T+1: GPR[rt] data T: data (CCR[z,rd]31)32 || CCR[z,rd] T+1: GPR[rt] data
Exceptions:
*Opcode Bit Encoding:
CFCz
Bit # 31 30 1 CFC1 0
29 0 29 0
28 0 28 0
27 0 27 1
26 1 26 0
25 0 25 0
24 0 24 0
23 0 23 0
22 21 1 1 0 22 21 0
0 0
Bit # 31 30 1 CFC2 0
Opcode Coprocessor Suboperation Coprocessor Unit Number
A-48
COPz
31 26 COPz CO 0 1 0 0 x x* 1 6 1
Coprocessor Operation
25 24 cofun 25
COPz
0
Format:
COPz cofun
Description:
A coprocessor operation is performed. The operation may specify and reference internal coprocessor registers, and may change the state of the coprocessor condition line, but does not modify state within the processor or the cache/memory system. Details of coprocessor operations are contained in Appendix B.
Operation:
32, 64 T: CoprocessorOperation (z, cofun)
Exceptions:
Coprocessor unusable exception Coprocessor interrupt or Floating-Point Exception (R4000 CP1 only)
COPz
Bit # 31 30 29 28 27 26 25 C0P0 0 1 0 0 0 0 1 Bit # 31 30 29 28 27 26 25 C0P1 0 1 0 0 0 1 1
0 0 0
Bit # 31 30 29 28 27 26 25 C0P2 0 1 0 0 1 0 1 Opcode
CO sub-opcode (see end of Appendix A) Coprocessor Unit Number
A-49
Appendix A
CTCz
31 26 25 COPz 0100xx* 6
Move Control to Coprocessor

21 20 rt 5 16 15 rd 5 11 10
CTCz
0
CT 00110 5
0 000 0000 0000 11
Format:
CTCz rt, rd
Description:
The contents of general register rt are loaded into control register rd of coprocessor unit z. This instruction is not valid for CP0.
Operation:
32,64 T: data GPR[rt] T + 1: CCR[z,rd] data
Exceptions:
Coprocessor unusable
*See CPU Instruction Opcode Bit Encoding at the end of Appendix A.
A-50
DADD
31 26 25 SPECIAL 000000 6 rs 5
Doubleword Add
21 20 rt 5 16 15 rd 5 11 10 6
DADD
5 DADD 101100 6 0 0 00000 5
Format:
DADD rd, rs, rt
Description:
The contents of general register rs and the contents of general register rt are added to form the result. The result is placed into general register rd. An overflow exception occurs if the carries out of bits 62 and 63 differ (2s complement overflow). The destination register rd is not modified when an integer overflow exception occurs. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: GPR[rd] GPR[rs] + GPR[rt]
Exceptions:
Integer overflow exception Reserved instruction exception (R4000 in 32-bit mode)
A-51
Appendix A
DADDI
31 26 25 DADDI 011000 6
Doubleword Add Immediate

21 20 rs 5 rt 5 16 15 immediate 16
DADDI
0
Format:
DADDI rt, rs, immediate
Description:
The 16-bit immediate is sign-extended and added to the contents of general register rs to form the result. The result is placed into general register rt. An overflow exception occurs if carries out of bits 62 and 63 differ (2s complement overflow). The destination register rt is not modified when an integer overflow exception occurs. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: GPR [rt] GPR[rs] + (immediate15)48 || immediate15...0
Exceptions:
A-52
DADDIU
31 26 25 DADDIU 011001 6 rs 5
Doubleword Add Immediate Unsigned

21 20 rt 5 16 15
DADDIU
0 immediate 16
Format:
DADDIU rt, rs, immediate
Description:
The 16-bit immediate is sign-extended and added to the contents of general register rs to form the result. The result is placed into general register rt. No integer overflow exception occurs under any circumstances. The only difference between this instruction and the DADDI instruction is that DADDIU never causes an overflow exception. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: GPR [rt] GPR[rs] + (immediate15)48 || immediate15...0
Exceptions:
Reserved instruction exception (R4000 in 32-bit mode)
A-53
Appendix A
DADDU
31 26 25 SPECIAL 000000 6
Doubleword Add Unsigned

21 20 rs 5 rt 5 16 15 rd 5 11 10
DADDU
6 5 DADDU 101101 6 0
0 00000 5
Format:
DADDU rd, rs, rt
Description:
The contents of general register rs and the contents of general register rt are added to form the result. The result is placed into general register rd. No overflow exception occurs under any circumstances. The only difference between this instruction and the DADD instruction is that DADDU never causes an overflow exception. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: GPR[rd] GPR[rs] + GPR[rt]
Exceptions:
A-54
DDIV
31 26 25 SPECIAL 000000 6 rs 5
Doubleword Divide
21 20 rt 5 16 15 0 00 0000 0000 10 6 5
DDIV
0 DDIV 011110 6
Format:
DDIV rs, rt
Description:
The contents of general register rs are divided by the contents of general register rt, treating both operands as 2s complement values. No overflow exception occurs under any circumstances, and the result of this operation is undefined when the divisor is zero. This instruction is typically followed by additional instructions to check for a zero divisor and for overflow. When the operation completes, the quotient word of the double result is loaded into special register LO, and the remainder word of the double result is loaded into special register HI. If either of the two preceding instructions is MFHI or MFLO, the results of those instructions are undefined. Correct operation requires separating reads of HI or LO from writes by two or more instructions. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T2: T1: T: LO HI LO HI LO HI undefined undefined undefined undefined GPR[rs] div GPR[rt] GPR[rs] mod GPR[rt]
Exceptions:
Appendix A
DDIVU
31 26 25 SPECIAL 000000 6
Doubleword Divide Unsigned

21 20 rs 5 rt 5 16 15 0 000000 0000 10 6
DDIVU
5 DDIVU 011111 6 0
Format:
DDIVU rs, rt
Description:
The contents of general register rs are divided by the contents of general register rt, treating both operands as unsigned values. No integer overflow exception occurs under any circumstances, and the result of this operation is undefined when the divisor is zero. This instruction is typically followed by additional instructions to check for a zero divisor. When the operation completes, the quotient word of the double result is loaded into special register LO, and the remainder word of the double result is loaded into special register HI. If either of the two preceding instructions is MFHI or MFLO, the results of those instructions are undefined. Correct operation requires separating reads of HI or LO from writes by two or more instructions. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T2: T1: T: LO HI LO HI LO HI undefined undefined undefined undefined (0 || GPR[rs]) div (0 || GPR[rt]) (0 || GPR[rs]) mod (0 || GPR[rt])
Exceptions:
DIV
31 26 25 SPECIAL 000000 6 rs 5 21 20 rt 5
Divide
16 15 0 00 0000 0000 10 6 5
DIV
0 DIV 011010 6
Format:
DIV rs, rt
Description:
The contents of general register rs are divided by the contents of general register rt, treating both operands as 2s complement values. No overflow exception occurs under any circumstances, and the result of this operation is undefined when the divisor is zero. In 64-bit mode, the operands must be valid sign-extended, 32-bit values. This instruction is typically followed by additional instructions to check for a zero divisor and for overflow. When the operation completes, the quotient word of the double result is loaded into special register LO, and the remainder word of the double result is loaded into special register HI. If either of the two preceding instructions is MFHI or MFLO, the results of those instructions are undefined. Correct operation requires separating reads of HI or LO from writes by two or more instructions.
A-57
Appendix A
DIV
Operation:
32 T2: T1: T: 64 T2: T1: T: LO HI LO HI LO HI LO HI LO HI q r LO HI
Divide (continued)
DIV
undefined undefined undefined undefined GPR[rs] div GPR[rt] GPR[rs] mod GPR[rt] undefined undefined undefined undefined GPR[rs]31...0 div GPR[rt]31...0 GPR[rs]31...0 mod GPR[rt]31...0 (q31)32 || q31...0 (r31)32 || r31...0
Exceptions:
None
A-58
DIVU
31 26 25 SPECIAL 000000 6 rs 5
Divide Unsigned
21 20 rt 5 16 15 0 000000 0000 10 6 5
DIVU
0 DIVU 011011 6
Format:
DIVU rs, rt
Description:
The contents of general register rs are divided by the contents of general register rt, treating both operands as unsigned values. No integer overflow exception occurs under any circumstances, and the result of this operation is undefined when the divisor is zero. In 64-bit mode, the operands must be valid sign-extended, 32-bit values. This instruction is typically followed by additional instructions to check for a zero divisor. When the operation completes, the quotient word of the double result is loaded into special register LO, and the remainder word of the double result is loaded into special register HI. If either of the two preceding instructions is MFHI or MFLO, the results of those instructions are undefined. Correct operation requires separating reads of HI or LO from writes by two or more instructions.
A-59
Appendix A
DIVU
Operation:
32 T2: T1: T: 64 T2: T1: T: LO HI LO HI LO HI LO HI LO HI q r LO HI
Divide Unsigned (continued)
DIVU
undefined undefined undefined undefined (0 || GPR[rs]) div (0 || GPR[rt]) (0 || GPR[rs]) mod (0 || GPR[rt]) undefined undefined undefined undefined (0 || GPR[rs]31...0) div (0 || GPR[rt]31...0) (0 || GPR[rs]31...0) mod (0 || GPR[rt]31...0) (q31)32 || q31...0 (r31)32 || r31...0
Exceptions:
None
A-60
DMFC0
31 26 25 COP0 010000 6
Doubleword Move From System Control Coprocessor

21 20 rt 5 16 15 rd 5 11 10
DMFC0
0
DMF 00001 5
0 0 0 0 0 0 0 0 0 0 00 11
Format:
DMFC0 rt, rd
Description:
The contents of coprocessor register rd of the CP0 are loaded into general register rt. This operation is dened for the R4000 operating in 64-bit mode and in 32bit kernel mode. Execution of this instruction in 32-bit user or supervisor mode causes a reserved instruction exception. All 64-bits of the general register destination are written from the coprocessor register source. The operation of DMFC0 on a 32-bit coprocessor 0 register is undefined.
Operation:
64 T: data CPR[0,rd] T+1: GPR[rt] data
Exceptions:
Coprocessor unusable exception Reserved instruction exception (R4000 in 32-bit user mode R4000 in 32-bit supervisor mode)
A-61
Appendix A
DMTC0
31 26 25 COP0 010000 6
Doubleword Move To System Control Coprocessor

21 20 rt 5 16 15 rd 5 11 10
DMTC0
0
DMT 00101 5
0 0 0 0 0 0 0 0 0 0 00 11
Format:
DMTC0 rt, rd
Description:
The contents of general register rt are loaded into coprocessor register rd of the CP0. This operation is dened for the R4000 operating in 64-bit mode or in 32bit kernel mode. Execution of this instruction in 32-bit user or supervisor mode causes a reserved instruction exception. All 64-bits of the coprocessor 0 register are written from the general register source. The operation of DMTC0 on a 32-bit coprocessor 0 register is undefined. Because the state of the virtual address translation system may be altered by this instruction, the operation of load instructions, store instructions, and TLB operations immediately prior to and after this instruction are undefined.
Operation:
64 T: data GPR[rt]
T+1: CPR[0,rd] data
Exceptions:
Coprocessor unusable exception (R4000 in 32-bit user mode R4000 in 32-bit supervisor mode)
A-62
DMULT
31 26 25 rs 5 SPECIAL 000000 6
Doubleword Multiply
21 20 rt 5 16 15 0 00 0000 0000 10
DMULT
6 5 DMULT 011100 6 0
Format:
DMULT rs, rt
Description:
The contents of general registers rs and rt are multiplied, treating both operands as 2s complement values. No integer overflow exception occurs under any circumstances. When the operation completes, the low-order word of the double result is loaded into special register LO, and the high-order word of the double result is loaded into special register HI. If either of the two preceding instructions is MFHI or MFLO, the results of these instructions are undefined. Correct operation requires separating reads of HI or LO from writes by a minimum of two other instructions. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T2: LO HI T1: LO HI T: t LO HI undefined undefined undefined undefined GPR[rs] * GPR[rt] t63...0 t127...64
Exceptions:
A-63
Appendix A
DMULTU
31 26 25 SPECIAL 000000 6 rs 5
Doubleword Multiply Unsigned

21 20 rt 5 16 15
DMULTU
6 5 DMULTU 011101 6 0
0 00 0000 0000 10
Format:
DMULTU rs, rt
Description:
The contents of general register rs and the contents of general register rt are multiplied, treating both operands as unsigned values. No overflow exception occurs under any circumstances. When the operation completes, the low-order word of the double result is loaded into special register LO, and the high-order word of the double result is loaded into special register HI. If either of the two preceding instructions is MFHI or MFLO, the results of these instructions are undefined. Correct operation requires separating reads of HI or LO from writes by a minimum of two instructions. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T2: T1: T: LO undefined HI undefined LO undefined HI undefined t (0 || GPR[rs]) * (0 || GPR[rt]) LO t63...0 HI t127...64
Exceptions:
A-64
DSLL
31 26 25 SPECIAL 000000 6
Doubleword Shift Left Logical

21 20 rt 5 16 15 rd 5 11 10 sa 5 6 5
DSLL
0 DSLL 111000 6
0 00000 5
Format:
DSLL rd, rt, sa
Description:
The contents of general register rt are shifted left by sa bits, inserting zeros into the low-order bits. The result is placed in register rd.
Operation:
64 T: s 0 || sa GPR[rd] GPR[rt](63s)...0 || 0s
Exceptions:
A-65
Appendix A
DSLLV
31 26 25 SPECIAL 000000 6 rs 5
Doubleword Shift Left Logical Variable

21 20 rt 5 16 15 rd 5 11 10
DSLLV
6 5 DSLLV 010100 6 0
0 00000 5
Format:
DSLLV rd, rt, rs
Description:
The contents of general register rt are shifted left by the number of bits specified by the low-order six bits contained in general register rs, inserting zeros into the low-order bits. The result is placed in register rd. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: s GPR[rs]5...0 GPR[rd] GPR[rt](63s)...0 || 0s
Exceptions:
A-66
DSLL32
31 26 25 SPECIAL 000000 6
Doubleword Shift Left Logical + 32

21 20 rt 5 16 15 rd 5 11 10 sa 5
DSLL32
6 5 DSLL32 111100 6 0
0 00000 5
Format:
DSLL32 rd, rt, sa
Description:
The contents of general register rt are shifted left by 32+sa bits, inserting zeros into the low-order bits. The result is placed in register rd. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: s 1 || sa GPR[rd] GPR[rt](63s)...0 || 0s
Exceptions:
A-67
Appendix A
DSRA
31 26 25 SPECIAL 000000 6
Doubleword Shift Right Arithmetic

21 20 rt 5 16 15 rd 5 11 10 sa 5 6
DSRA
5 DSRA 111011 6 0
0 00000 5
Format:
DSRA rd, rt, sa
Description:
The contents of general register rt are shifted right by sa bits, signextending the high-order bits. The result is placed in register rd. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: s 0 || sa GPR[rd] (GPR[rt]63)s || GPR[rt] 63...s
Exceptions:
A-68
DSRAV
31 26 25 SPECIAL 000000 6 rs 5
Doubleword Shift Right Arithmetic Variable

21 20 rt 5 16 15 rd 5 11 10
DSRAV
6 5 DSRAV 010111 6 0
0 00000 5
Format:
DSRAV rd, rt, rs
Description:
The contents of general register rt are shifted right by the number of bits specified by the low-order six bits of general register rs, sign-extending the high-order bits. The result is placed in register rd. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: s GPR[rs]5...0 GPR[rd] (GPR[rt]63)s || GPR[rt]63...s
Exceptions:
A-69
Appendix A
DSRA32
31 26 25 SPECIAL 000000 6
Doubleword Shift Right Arithmetic + 32

21 20 rt 5 16 15 rd 5 11 10
DSRA32
6 sa 5 5 DSRA32 111111 6 0
0 00000 5
Format:
DSRA32 rd, rt, sa
Description:
The contents of general register rt are shifted right by 32+sa bits, signextending the high-order bits. The result is placed in register rd. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: s 1 || sa GPR[rd] (GPR[rt]63)s || GPR[rt] 63...s
Exceptions:
A-70
DSRL
31 26 25 SPECIAL 000000 6 0 00000 5
Doubleword Shift Right Logical

21 20 rt 5 16 15 rd 5 11 10 sa 5 6
DSRL
5 DSRL 111010 6 0
Format:
DSRL rd, rt, sa
Description:
The contents of general register rt are shifted right by sa bits, inserting zeros into the high-order bits. The result is placed in register rd. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: s 0 || sa GPR[rd] 0s || GPR[rt]63...s
Exceptions:
A-71
Appendix A
DSRLV
31 26 25 SPECIAL 000000 6 rs 5
Doubleword Shift Right Logical Variable

21 20 rt 5 16 15 rd 5 11 10
DSRLV
6 5 DSRLV 010110 6 0
0 00000 5
Format:
DSRLV rd, rt, rs
Description:
The contents of general register rt are shifted right by the number of bits specified by the low-order six bits of general register rs, inserting zeros into the high-order bits. The result is placed in register rd. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: s GPR[rs]5...0 GPR[rd] 0s || GPR[rt]63...s
Exceptions:
A-72
DSRL32
31 26 25 SPECIAL 000000 6
Doubleword Shift Right Logical + 32

21 20 rt 5 16 15 rd 5 11 10 sa 5
DSRL32
6 5 DSRL32 111110 6 0
0 00000 5
Format:
DSRL32 rd, rt, sa
Description:
The contents of general register rt are shifted right by 32+sa bits, inserting zeros into the high-order bits. The result is placed in register rd. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: s 1 || sa GPR[rd] 0s || GPR[rt]63...s
Exceptions:
A-73
Appendix A
DSUB
31 26 25 SPECIAL 000000 6 rs 5
Doubleword Subtract
21 20 rt 5 16 15 rd 5 11 10 6
DSUB
5 DSUB 101110 6 0 0 00000 5
Format:
DSUB rd, rs, rt
Description:
The contents of general register rt are subtracted from the contents of general register rs to form a result. The result is placed into general register rd. The only difference between this instruction and the DSUBU instruction is that DSUBU never traps on overflow. An integer overflow exception takes place if the carries out of bits 62 and 63 differ (2s complement overflow). The destination register rd is not modified when an integer overflow exception occurs. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: GPR[rd] GPR[rs] GPR[rt]
Exceptions:
A-74
DSUBU
31 26 25 SPECIAL 000000 6
Doubleword Subtract Unsigned

21 20 rs 5 rt 5 16 15 rd 5 11 10
DSUBU
6 5 DSUBU 101111 6 0
0 00000 5
Format:
DSUBU rd, rs, rt
Description:
The contents of general register rt are subtracted from the contents of general register rs to form a result. The result is placed into general register rd. The only difference between this instruction and the DSUB instruction is that DSUBU never traps on overflow. No integer overflow exception occurs under any circumstances. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: GPR[rd] GPR[rs] GPR[rt]
Exceptions:
A-75
Appendix A
ERET
31 26 COP0 010000 6 25 24 CO 1 1
Exception Return
ERET
6 5 0 ERET 011000 6
0 000 0000 0000 0000 0000 19
Format:
ERET
Description:
ERET is the R4000 instruction for returning from an interrupt, exception, or error trap. Unlike a branch or jump instruction, ERET does not execute the next instruction. ERET must not itself be placed in a branch delay slot. If the processor is servicing an error trap (SR2 = 1), then load the PC from the ErrorEPC and clear the ERL bit of the Status register (SR2). Otherwise (SR2 = 0), load the PC from the EPC, and clear the EXL bit of the Status register (SR1). An ERET executed between a LL and SC also causes the SC to fail.
Operation:
32, 64 T: if SR2 = 1 then PC ErrorEPC SR SR31...3 || 0 || SR1...0 else PC EPC SR SR31...2 || 0 || SR0 endif LLbit 0
Exceptions:
A-76
J
31 26 25 J 000010 6
Jump
J
0
target 26
Format:
J target
Description:
The 26-bit target address is shifted left two bits and combined with the high-order bits of the address of the delay slot. The program unconditionally jumps to this calculated address with a delay of one instruction.
Operation:
32 T: temp target T+1: PC PC31...28 || temp || 02 T: temp target T+1: PC PC63...28 || temp || 02
64
Exceptions:
None
A-77
Appendix A
JAL
31 26 25 JAL 000011 6
Jump And Link
JAL
0
target 26
Format:
JAL target
Description:
The 26-bit target address is shifted left two bits and combined with the high-order bits of the address of the delay slot. The program unconditionally jumps to this calculated address with a delay of one instruction. The address of the instruction after the delay slot is placed in the link register, r31.
Operation:
32 temp target GPR[31] PC + 8 T+1: PC PC 31...28 || temp || 02 T: temp target GPR[31] PC + 8 T+1: PC PC 63...28 || temp || 02 T:
64
Exceptions:
None
A-78
JALR
31 26 25 SPECIAL 000000 6 rs 5
Jump And Link Register

21 20 16 15 rd 5 11 10 6 5
JALR
0 JALR 001001 6
0 00000 5
0 00000 5
Format:
JALR rs JALR rd, rs
Description:
The program unconditionally jumps to the address contained in general register rs, with a delay of one instruction. The address of the instruction after the delay slot is placed in general register rd. The default value of rd, if omitted in the assembly language instruction, is 31. Register specifiers rs and rd may not be equal, because such an instruction does not have the same effect when re-executed. However, an attempt to execute this instruction is not trapped, and the result of executing such an instruction is undefined. Since instructions must be word-aligned, a Jump and Link Register instruction must specify a target register (rs) whose two low-order bits are zero. If these low-order bits are not zero, an address exception will occur when the jump target instruction is subsequently fetched.
Operation:
32, 64 T: T+1: temp GPR [rs] GPR[rd] PC + 8 PC temp
Exceptions:
None
A-79
Appendix A
JR
31 SPECIAL 000000 6 26 25 rs 5
Jump Register
21 20 0 000 0000 0000 0000 15 65
JR
0 JR 001000 6
Format:
JR rs
Description:
The program unconditionally jumps to the address contained in general register rs, with a delay of one instruction. Since instructions must be word-aligned, a Jump Register instruction must specify a target register (rs) whose two low-order bits are zero. If these low-order bits are not zero, an address exception will occur when the jump target instruction is subsequently fetched.
Operation:
32, 64 T: T+1: temp GPR[rs] PC temp
Exceptions:
None
A-80
LB
31 26 25 LB 100000 6 base 5 21 20
Load Byte
16 15 rt 5 offset 16
LB
0
Format:
LB rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of the byte at the memory location specified by the effective address are sign-extended and loaded into general register rt.
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1 ... 3 || (pAddr2...0 xor ReverseEndian3) mem LoadMemory (uncached, BYTE, pAddr, vAddr, DATA) byte vAddr2...0 xor BigEndianCPU3 GPR[rt] (mem7+8*byte)24 || mem7+8*byte...8*byte vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1 ... 3 || (pAddr2...0 xor ReverseEndian3) mem LoadMemory (uncached, BYTE, pAddr, vAddr, DATA) byte vAddr2...0 xor BigEndianCPU3 GPR[rt] (mem7+8*byte)56 || mem7+8*byte...8*byte
64
T:
Exceptions:
TLB refill exception TLB invalid exception Bus error exception Address error exception
A-81
Appendix A
LBU
31 26 25 base 5 LBU 100100 6
Load Byte Unsigned

21 20 rt 5 16 15 offset 16
LBU
0
Format:
LBU rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of the byte at the memory location specified by the effective address are zero-extended and loaded into general register rt.
Operation: 32
T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1 ...3 || (pAddr2...0 xor ReverseEndian3) mem LoadMemory (uncached, BYTE, pAddr, vAddr, DATA) byte vAddr2...0 xor BigEndianCPU3 GPR[rt] 024 || mem7+8* byte...8* byte vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1...3 || (pAddr2...0 xor ReverseEndian3) mem LoadMemory (uncached, BYTE, pAddr, vAddr, DATA) byte vAddr2...0 xor BigEndianCPU3 GPR[rt] 056 || mem7+8* byte...8* byte
64
T:
Exceptions:
TLB refill exception Bus error exception TLB invalid exception Address error exception
A-82
LD
31 26 25 LD 110111 6 base 5
Load Doubleword
21 20 rt 5 16 15 offset 16
LD
0
Format:
LD rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of the 64-bit doubleword at the memory location specified by the effective address are loaded into general register rt. If any of the three least-significant bits of the effective address are nonzero, an address error exception occurs. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) mem LoadMemory (uncached, DOUBLEWORD, pAddr, vAddr, DATA) GPR[rt] mem
Exceptions:
TLB refill exception TLB invalid exception Bus error exception Address error exception Reserved instruction exception
(R4000 in 32-bit user mode R4000 in 32-bit supervisor mode)
A-83
Appendix A
LDCz
31 LDCz 1 1 0 1 x x* 6
Load Doubleword To Coprocessor

26 25 base 5 21 20 rt 5 16 15 offset 16
LDCz
0
Format:
LDCz rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The processor reads a doubleword from the addressed memory location and makes the data available to coprocessor unit z. The manner in which each coprocessor uses the data is defined by the individual coprocessor specifications. If any of the three least-significant bits of the effective address are nonzero, an address error exception takes place. This instruction is not valid for use with CP0. This instruction is undefined when the least-significant bit of the rt field is non-zero.
A-84
LDCz
Load Doubleword To Coprocessor (continued)
LDCz
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) mem LoadMemory (uncached, DOUBLEWORD, pAddr, vAddr, DATA) COPzLD (rt, mem) vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) mem LoadMemory (uncached, DOUBLEWORD, pAddr, vAddr, DATA) COPzLD (rt, mem)
64
T:
Exceptions:
TLB refill exception TLB invalid exception Bus error exception Address error exception Coprocessor unusable exception
LDCz
Bit # 31 LDC1 1 Bit # 31 LDC2 1
30 1 30 1
29 0 29 0
28 1 28 1
27 0 27 1
26 1 26 0
Opcode
A-85
Appendix A
LDL
31 26 25 base 5 LDL 011010 6
Load Doubleword Left

21 20 rt 5 16 15 offset 16
LDL
0
Format:
LDL rt, offset(base)
Description:
This instruction can be used in combination with the LDR instruction to load a register with eight consecutive bytes from memory, when the bytes cross a doubleword boundary. LDL loads the left portion of the register with the appropriate part of the high-order doubleword; LDR loads the right portion of the register with the appropriate part of the low-order doubleword. The LDL instruction adds its sign-extended 16-bit offset to the contents of general register base to form a virtual address which can specify an arbitrary byte. It reads bytes only from the doubleword in memory which contains the specified starting byte. From one to eight bytes will be loaded, depending on the starting byte specified. Conceptually, it starts at the specified byte in memory and loads that byte into the high-order (left-most) byte of the register; then it loads bytes from memory into the register until it reaches the low-order byte of the doubleword in memory. The least-significant (right-most) byte(s) of the register will not be changed. memory (big-endian) 10 11 12 13 14 15 2 3 4 5 6 7 register
address 8 address 0
8 0
9 1
before A B C D E F G H $24
LDL $24,3($0)
after
3 4 5 6 7 F G H $24
A-86
LDL
Load Doubleword Left (continued)
LDL
The contents of general register rt are internally bypassed within the processor so that no NOP is needed between an immediately preceding load instruction which specifies register rt and a following LDL (or LDR) instruction which also specifies register rt. No address exceptions due to alignment are possible. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE1...3 || (pAddr2...0 xor ReverseEndian3) if BigEndianMem = 0 then pAddr pAddrPSIZE1...3 || 03 endif byte vAddr2...0 xor BigEndianCPU3 mem LoadMemory (uncached, byte, pAddr, vAddr, DATA) GPR[rt] mem7+8*byte...0 || GPR[rt]558*byte...0
A-87
Appendix A
LDL
Load Doubleword Left (continued)
LDL
Given a doubleword in a register and a doubleword in memory, the operation of LDL is as follows:
LDL
Register Memory A I B J C K D L E M F N G O H P
BigEndianCPU = 0
vAddr2..0 destination type offset
BigEndianCPU = 1
destination type offset
LEM BEM
LEM BEM
0 1 2 3 4 5 6 7
P O N M L K J I
B P O N M L K J
C C P O N M L K
DE DE DE PE OP NO MN L M
F F F F F P O N
G G G G G G P O
H H H P H H H P
0 1 2 3 4 5 6 7
0 0 0 0 0 0 0 0
7 6 5 4 3 2 1 0
I J K L M N O P
J K L M N O P B
K L M N O P C C
L M N O P D D D
MN N O OP P F E F E F E F E F
O P G G G G G G
P H H H H H H H
7 6 5 4 3 2 1 0
0 0 0 0 0 0 0 0
0 1 2 3 4 5 6 7
LEM BEM Type Offset
Little-endian memory (BigEndianMem = 0) BigEndianMem = 1 AccessType (see Table 2-1) sent to memory pAddr2...0 sent to memory
Exceptions:
TLB refill exception TLB invalid exception Bus error exception Address error exception Reserved instruction exception (R4000 in 32-bit mode)
A-88
LDR
31 26 25 LDR 011011 6 base 5
Load Doubleword Right

21 20 rt 5 16 15 offset 16
LDR
0
Format:
LDR rt, offset(base)
Description:
This instruction can be used in combination with the LDL instruction to load a register with eight consecutive bytes from memory, when the bytes cross a doubleword boundary. LDR loads the right portion of the register with the appropriate part of the low-order doubleword; LDL loads the left portion of the register with the appropriate part of the high-order doubleword. The LDR instruction adds its sign-extended 16-bit offset to the contents of general register base to form a virtual address which can specify an arbitrary byte. It reads bytes only from the doubleword in memory which contains the specified starting byte. From one to eight bytes will be loaded, depending on the starting byte specified. Conceptually, it starts at the specified byte in memory and loads that byte into the low-order (right-most) byte of the register; then it loads bytes from memory into the register until it reaches the high-order byte of the doubleword in memory. The most significant (left-most) byte(s) of the register will not be changed. memory (big-endian) 10 11 12 13 14 15 2 3 4 5 6 7
address 8 address 0
8 0
9 1
register
before A B C D E F G H $24
LDR $24,4($0)
register
after
A B C 0
1 2 3 4
$24
A-89
Appendix A
LDR
Load Doubleword Right (continued)
LDR
The contents of general register rt are internally bypassed within the processor so that no NOP is needed between an immediately preceding load instruction which specifies register rt and a following LDR (or LDL) instruction which also specifies register rt. No address exceptions due to alignment are possible. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE1...3 || (pAddr2...0 xor ReverseEndian3) if BigEndianMem = 1 then pAddr pAddr31...3 || 03 endif byte vAddr2...0 xor BigEndianCPU3 mem LoadMemory (uncached, byte, pAddr, vAddr, DATA) GPR[rt] GPR[rt]63...64-8*byte || mem63...8*byte
A-90
LDR
Load Doubleword Right (continued)
LDR
Given a doubleword in a register and a doubleword in memory, the operation of LDR is as follows:
LDR
BigEndianCPU = 0
BigEndianCPU = 1
LEM BEM
LEM BEM
0 1 2 3 4 5 6 7
I A A A A A A A
J I B B B B B B
K J I C C C C C
L K J I D D D D
M L K J I E E E
N M L K J I F F
O N M L K J I G
P O N M L K J I
7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7
0 0 0 0 0 0 0 0
A A A A A A A I
B B B B B B I J
C C C C C I J K
D D D D I J K L
E F G E F I E I J I J K J K L K L M L MN MNO
I J K L M N O P
0 1 2 3 4 5 6 7
7 6 5 4 3 2 1 0
0 0 0 0 0 0 0 0
LEM BEM Type Offset
Exceptions:
Appendix A
LH
31 26 25 LH 100001 6 base 5
Load Halfword
21 20 rt 5 16 15 offset 16
LH
0
Format:
LH rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of the halfword at the memory location specified by the effective address are sign-extended and loaded into general register rt. If the least-significant bit of the effective address is non-zero, an address error exception occurs.
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1...3 || (pAddr2...0 xor (ReverseEndian || 0)) mem LoadMemory (uncached, HALFWORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU2 || 0) GPR[rt] (mem15+8*byte)16 || mem15+8*byte...8* byte vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1...3 || (pAddr2...0 xor (ReverseEndian || 0)) mem LoadMemory (uncached, HALFWORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU2 || 0) GPR[rt] (mem15+8*byte)48 || mem15+8*byte...8* byte
64
T:
Exceptions:
LHU
31 26 25 LHU 100101 6
Load Halfword Unsigned

21 20 base 5 rt 5 16 15 offset 16
LHU
0
Format:
LHU rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of the halfword at the memory location specified by the effective address are zero-extended and loaded into general register rt. If the least-significant bit of the effective address is non-zero, an address error exception occurs.
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1...3 || (pAddr2...0 xor (ReverseEndian2 || 0)) mem LoadMemory (uncached, HALFWORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU2 || 0) GPR[rt] 016 || mem15+8*byte...8*byte vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1...3 || (pAddr2...0 xor (ReverseEndian2 || 0)) mem LoadMemory (uncached, HALFWORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU2 || 0) GPR[rt] 048 || mem15+8*byte...8*byte
64
T:
Exceptions:
TLB refill exception Bus Error exception TLB invalid exception Address error exception
A-93
Appendix A
LL
31 26 25 LL 110000 6 base 5 21 20
Load Linked
LL
0
Format:
LL rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of the word at the memory location specified by the effective address are loaded into general register rt. In 64-bit mode, the loaded word is sign-extended. The processor begins checking the accessed word for modification by other processor and devices. Load Linked and Store Conditional can be used to atomically update memory locations as shown: L1: LL ADD SC BEQ NOP T1, (T0) T2, T1, 1 T2, (T0) T2, 0, L1
This atomically increments the word addressed by T0. Changing the ADD to an OR changes this to an atomic bit set. This instruction is available in User mode, and it is not necessary for CP0 to be enabled. The operation of LL is undefined if the addressed location is uncached and, for synchronization between multiple processors, the operation of LL is undefined if the addressed location is noncoherent. A cache miss that occurs between LL and SC may cause SC to fail, so no load or store operation should occur between LL and SC, otherwise the SC may never be successful. Exceptions also cause SC to fail, so persistent exceptions must be avoided. If either of the two least-significant bits of the effective address are non-zero, an address error exception takes place.
LL
Operation:
32 T:
Load Linked (continued)
LL
vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02)) mem LoadMemory (uncached, WORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU || 02) GPR[rt] mem31+8*byte...8*byte LLbit 1 vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02)) mem LoadMemory (uncached, WORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU || 02) GPR[rt] (mem31+8*byte)32 || mem31+8*byte...8*byte LLbit 1
64
T:
Exceptions:
A-95
Appendix A
LLD
31 26 25 LLD 110100 6
Load Linked Doubleword

21 20 base 5 rt 5 16 15 offset 16
LLD
0
Format:
LLD rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of the doubleword at the memory location specified by the effective address are loaded into general register rt. The processor begins checking the accessed word for modification by other processor and devices. Load Linked Doubleword and Store Conditional Doubleword can be used to atomically update memory locations: L1: LLD ADD SCD BEQ NOP T1, (T0) T2, T1, 1 T2, (T0) T2, 0, L1
This atomically increments the word addressed by T0. Changing the ADD to an OR changes this to an atomic bit set.
A-96
LLD
Load Linked Doubleword (continued)
LLD
The operation of LLD is undefined if the addressed location is uncached and, for synchronization between multiple processors, the operation of LLD is undefined if the addressed location is noncoherent. A cache miss that occurs between LLD and SCD may cause SCD to fail, so no load or store operation should occur between LLD and SCD, otherwise the SCD may never be successful. Exceptions also cause SCD to fail, so persistent exceptions must be avoided. This instruction is available in User mode, and it is not necessary for CP0 to be enabled. If any of the three least-significant bits of the effective address are nonzero, an address error exception takes place. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) mem LoadMemory (uncached, DOUBLEWORD, pAddr, vAddr, DATA) GPR[rt] mem LLbit 1
Exceptions:
A-97
Appendix A
LUI
31 26 25 LUI 001111 6
Load Upper Immediate

21 20 rt 5 16 15 immediate 16
LUI
0
0 00000 5
Format:
LUI rt, immediate
Description:
The 16-bit immediate is shifted left 16 bits and concatenated to 16 bits of zeros. The result is placed into general register rt. In 64-bit mode, the loaded word is sign-extended.
Operation:
32 64 T: T: GPR[rt] immediate || 016 GPR[rt] (immediate15)32 || immediate || 016
Exceptions:
None
A-98
LW
31 26 25 LW 100011 6 base 5 21 20
Load Word
LW
0
Format:
LW rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of the word at the memory location specified by the effective address are loaded into general register rt. In 64-bit mode, the loaded word is sign-extended. If either of the two least-significant bits of the effective address is non-zero, an address error exception occurs.
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02)) mem LoadMemory (uncached, WORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU || 02) GPR[rt] mem31+8*byte...8*byte vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02)) mem LoadMemory (uncached, WORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU || 02) GPR[rt] (mem31+8*byte)32 || mem31+8*byte...8*byte
64
T:
Exceptions:
TLB refill exception Bus error exception TLB invalid exception Address error exception
A-99
Appendix A
LWCz
31 26 25 LWCz 1 1 0 0 x x* 6
Load Word To Coprocessor

21 20 base 5 rt 5 16 15 offset 16
LWCz
0
Format:
LWCz rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The processor reads a word from the addressed memory location, and makes the data available to coprocessor unit z. The manner in which each coprocessor uses the data is defined by the individual coprocessor specifications. If either of the two least-significant bits of the effective address is non-zero, an address error exception occurs. This instruction is not valid for use with CP0.
A-100
LWCz
Operation:
32 T:
Load Word To Coprocessor (continued)
LWCz
vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02)) mem LoadMemory (uncached, WORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU || 02) COPzLW (byte, rt, mem) vAddr ((offset15)48 || offset15...0) + GPR[base} (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02)) mem LoadMemory (uncached, WORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU || 02) COPzLW (byte, rt, mem)
64
T:
Exceptions:
TLB refill exception TLB invalid exception Bus error exception Address error exception Coprocessor unusable exception
LWCz
Bit # 31 LWC1 1
30 1 30 1
29 0 29 0
28 0 28 0
27 0 27 1
26 1 26 0
Bit # 31 LWC2 1
Opcode
A-101
Appendix A
LWL
31 26 25 base 5 LWL 100010 6
Load Word Left

21 20 rt 5 16 15 offset 16
LWL
0
Format:
LWL rt, offset(base)
Description:
This instruction can be used in combination with the LWR instruction to load a register with four consecutive bytes from memory, when the bytes cross a word boundary. LWL loads the left portion of the register with the appropriate part of the high-order word; LWR loads the right portion of the register with the appropriate part of the low-order word. The LWL instruction adds its sign-extended 16-bit offset to the contents of general register base to form a virtual address which can specify an arbitrary byte. It reads bytes only from the word in memory which contains the specified starting byte. From one to four bytes will be loaded, depending on the starting byte specified. In 64-bit mode, the loaded word is sign-extended. Conceptually, it starts at the specified byte in memory and loads that byte into the high-order (left-most) byte of the register; then it loads bytes from memory into the register until it reaches the low-order byte of the word in memory. The least-significant (right-most) byte(s) of the register will not be changed. memory (big-endian) address 4 address 0 4 0 5 1 6 2 7 3 register
before
$24
LWL $24,1($0)
after
1 2 3 D $24
A-102
LWL
Load Word Left (continued)
LWL
The contents of general register rt are internally bypassed within the processor so that no NOP is needed between an immediately preceding load instruction which specifies register rt and a following LWL (or LWR) instruction which also specifies register rt. No address exceptions due to alignment are possible.
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE1...3 || (pAddr2...0 xor ReverseEndian3) if BigEndianMem = 0 then pAddr pAddrPSIZE1...2 || 02 endif byte vAddr1...0 xor BigEndianCPU2 word vAddr2 xor BigEndianCPU mem LoadMemory (uncached, 0 || byte, pAddr, vAddr, DATA) temp mem32*word+8*byte+7...32*word || GPR[rt]23-8*byte...0 GPR[rt] temp 64 T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE1...3 || (pAddr2...0 xor ReverseEndian3) if BigEndianMem = 0 then pAddr pAddrPSIZE1...2 || 02 endif byte vAddr1...0 xor BigEndianCPU2 word vAddr2 xor BigEndianCPU mem LoadMemory (uncached, 0 || byte, pAddr, vAddr, DATA) temp mem32*word+8*byte+7...32*word || GPR[rt]23-8*byte...0 GPR[rt] (temp31)32 || temp
A-103
Appendix A
LWL
Load Word Left (continued)
LWL
Given a doubleword in a register and a doubleword in memory, the operation of LWL is as follows:
LWL
BigEndianCPU = 0
BigEndianCPU = 1
LEM BEM
LEM BEM
0 1 2 3 4 5 6 7
S S S S S S S S
S S S S S S S S
S S S S S S S S
S S S S S S S S
P O N M L K J I
F P O N F L K J
G G P O G G L K
H H H P H H H L
0 1 2 3 0 1 2 3
0 0 0 0 4 4 4 4
7 6 5 4 3 2 1 0
S S S S S S S S
S S S S S S S S
S S S S S S S S
S S S S S S S S
I J J K K L L F MN N O OP P F
K L G G O P G G
L H H H P H H H
3 2 1 0 3 2 1 0
4 4 4 4 0 0 0 0
0 1 2 3 4 5 6 7
LEM BEM Type Offset S
Little-endian memory (BigEndianMem = 0) BigEndianMem = 1 AccessType (see Table 2-1) sent to memory pAddr2...0 sent to memory sign-extend of destination31
Exceptions:
A-104
LWR
31 26 25 LWR 100110 6 base 5
Load Word Right

21 20 rt 5 16 15 offset 16
LWR
0
Format:
LWR rt, offset(base)
Description:
This instruction can be used in combination with the LWL instruction to load a register with four consecutive bytes from memory, when the bytes cross a word boundary. LWR loads the right portion of the register with the appropriate part of the low-order word; LWL loads the left portion of the register with the appropriate part of the high-order word. The LWR instruction adds its sign-extended 16-bit offset to the contents of general register base to form a virtual address which can specify an arbitrary byte. It reads bytes only from the word in memory which contains the specified starting byte. From one to four bytes will be loaded, depending on the starting byte specified. In 64-bit mode, if bit 31 of the destination register is loaded, then the loaded word is sign-extended. Conceptually, it starts at the specified byte in memory and loads that byte into the low-order (right-most) byte of the register; then it loads bytes from memory into the register until it reaches the high-order byte of the word in memory. The most significant (left-most) byte(s) of the register will not be changed. memory (big-endian) address 4 address 0 4 0 5 1 6 2 7 3 register
before
$24
LWR $24,4($0)
after
A B C 4
A-105
Appendix A
LWR
Load Word Right (continued)
LWR
The contents of general register rt are internally bypassed within the processor so that no NOP is needed between an immediately preceding load instruction which specifies register rt and a following LWR (or LWL) instruction which also specifies register rt. No address exceptions due to alignment are possible.
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE1...3 || (pAddr2...0 xor ReverseEndian3) if BigEndianMem = 1 then pAddr pAddrPSIZE31...3 || 03 endif byte vAddr1...0 xor BigEndianCPU2 word vAddr2 xor BigEndianCPU mem LoadMemory (uncached, 0 || byte, pAddr, vAddr, DATA) temp GPR[rt]31...32-8*byte || mem31+32*word...32*word+8*byte GPR[rt] temp 64 T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE1...3 || (pAddr2...0 xor ReverseEndian3) if BigEndianMem = 1 then pAddr pAddrPSIZE31...3 || 03 endif byte vAddr1...0 xor BigEndianCPU2 word vAddr2 xor BigEndianCPU mem LoadMemory (uncached, 0 || byte, pAddr, vAddr, DATA) temp GPR[rt]31...32-8*byte || mem31+32*word...32*word+8*byte GPR[rt] (temp31)32 || temp
A-106
LWR
Load Word Right (continued)
LWR
Given a word in a register and a word in memory, the operation of LWR is as follows:
LWR
BigEndianCPU = 0
BigEndianCPU = 1
LEM BEM
LEM BEM
0 1 2 3 4 5 6 7
S X X X S X X X
S X X X S X X X
S X X X S X X X
S X X X S X X X
M E E E I E E E
N M F F J I F F
O N M G K J I G
P O N M L K J I
0 1 2 3 0 1 2 3
0 1 2 3 4 5 6 7
4 4 4 4 0 0 0 0
X X X S X X X S
X X X S X X X S
X X X S X X X S
X X X S X X X S
E F G E F I E I J I J K E F G E F M E MN MNO
I J K L M N O P
0 1 2 3 0 1 2 3
7 6 5 4 3 2 1 0
0 0 0 0 4 4 4 4
LEM BEM Type Offset S X
Little-endian memory (BigEndianMem = 0) BigEndianMem = 1 AccessType (see Table 2-1) sent to memory pAddr2...0 sent to memory sign-extend of destination31 either unchanged or sign-extend of destination31
Exceptions:
A-107
Appendix A
LWU
31 26 25 LWU 100111 6 base 5
Load Word Unsigned

21 20 rt 5 16 15 offset 16
LWU
0
Format:
LWU rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of the word at the memory location specified by the effective address are loaded into general register rt. The loaded word is zero-extended. If either of the two least-significant bits of the effective address is non-zero, an address error exception occurs. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02)) mem LoadMemory (uncached, WORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU || 02) GPR[rt] 032 || mem31+8*byte...8*byte
Exceptions:
A-108
MFC0
31 26 25 COP0 010000 6
Move From System Control Coprocessor

21 20 rt 5 16 15 rd 5 11 10
MFC0
0
MF 00000 5
0 000 0000 0000 11
Format:
MFC0 rt, rd
Description:
The contents of coprocessor register rd of the CP0 are loaded into general register rt.
Operation:
32 T: data CPR[0,rd] T+1: GPR[rt] data 64 T: data CPR[0,rd]
T+1: GPR[rt] (data31)32 || data31...0
Exceptions:
A-109
Appendix A
MFCz
31 26 25 COPz 0 1 0 0 x x* 6
Move From Coprocessor

21 20 rt 5 16 15 rd 5 11 10
MFCz
0
MF 00000 5
0 000 0000 0000 11
Format:
MFCz rt, rd
Description:
The contents of coprocessor register rd of coprocessor z are loaded into general register rt.
Operation:
32 64 T: T: data CPR[z,rd] if rd0 = 0 then else data CPR[z,rd4...1 || 0]63...32 endif T+1: GPR[rt] (data31)32 || data T+1: GPR[rt] data data CPR[z,rd4...1 || 0]31...0
Exceptions:
A-110
MFCz
Move From Coprocessor (continued)
MFCz
MFCz
Bit # 31 MFC0 0 Bit # 31 MFC1 0
30 1 30 1 30 1
29 0 29 0 29 0
28 0 28 0 28 0
27 0 27 0 27 1
26 0 26 1 26 0
25 0 25 0 25 0
24 0 24 0 24 0
23 0 23 0 23 0
22 21 0 0 0 0 22 21 0 22 21 0
0 0 0
Bit # 31 MFC2 0
Opcode
Coprocessor Suboperation Coprocessor Unit Number
A-111
Appendix A
MFHI
31 26 25 SPECIAL 000000 6
Move From HI
16 15 rd 5 11 10 0 00000 5 6 5
MFHI
0 MFHI 010000 6
0 00 0000 0000 10
Format:
MFHI rd
Description:
The contents of special register HI are loaded into general register rd. To ensure proper operation in the event of interruptions, the two instructions which follow a MFHI instruction may not be any of the instructions which modify the HI register: MULT, MULTU, DIV, DIVU, MTHI, DMULT, DMULTU, DDIV, DDIVU.
Operation:
32, 64 T: GPR[rd] HI
Exceptions:
None
A-112
MFLO
31 26 25 SPECIAL 000000 6
Move From Lo
16 15 rd 5 11 10 0 00000 5 6
MFLO
5 MFLO 010010 6 0
0 00 0000 0000 10
Format:
MFLO rd
Description:
The contents of special register LO are loaded into general register rd. To ensure proper operation in the event of interruptions, the two instructions which follow a MFLO instruction may not be any of the instructions which modify the LO register: MULT, MULTU, DIV, DIVU, MTLO, DMULT, DMULTU, DDIV, DDIVU.
Operation:
32, 64 T: GPR[rd] LO
Exceptions:
None
A-113
Appendix A
MTC0
31 26 25 COP0 010000 6
Move To System Control Coprocessor

21 20 rt 5 16 15 rd 5 11 10
MTC0
0
MT 00100 5
0 0 0 0 0 0 0 0 0 0 00 11
Format:
MTC0 rt, rd
Description:
The contents of general register rt are loaded into coprocessor register rd of CP0. Because the state of the virtual address translation system may be altered by this instruction, the operation of load instructions, store instructions, and TLB operations immediately prior to and after this instruction are undefined.
Operation:
32, 64 T: T+1: data GPR[rt] CPR[0,rd] data
Exceptions:
A-114
MTCz
31
Move To Coprocessor
21 20 rt 5 16 15 rd 5 11 10 MT 00100 5
26 25
MTCz
0
COPz 0 1 0 0 x x* 6
0 000 0000 0000 11
Format:
MTCz rt, rd
Description:
The contents of general register rt are loaded into coprocessor register rd of coprocessor z.
Operation:
32 64 T: data GPR[rt] T+1: CPR[z,rd] data T: data GPR[rt]31...0 T+1: if rd0 = 0 CPR[z,rd4...1 || 0] CPR[z, rd4...1 || 0]63...32 || data else CPR[z,rd4...1 || 0] data || CPR[z,rd4...1 || 0]31...0 endif Coprocessor unusable exception
Exceptions:
MTCz
Bit # 31 C0P0 0
30 1 30 1 30 1
29 0 29 0 29 0
28 0 28 0 28 0
27 0 27 0 27 1
26 0 26 1 26 0
25 0 25 0 25 0
24 0 24 0 24 0
23 1 23 1 23 1
22 21 0 0 0 0 22 21 0 22 21 0
0 0 0
Bit # 31 C0P1 0 Bit # 31 C0P2 0
Opcode
Coprocessor Suboperation
A-115
Appendix A
MTHI
31 SPECIAL 000000 6 26 25 rs 5
Move To HI
21 20 65
MTHI
0 MTHI 010001 6
0 000 000000000000 15
Format:
MTHI rs
Description:
The contents of general register rs are loaded into special register HI. If a MTHI operation is executed following a MULT, MULTU, DIV, or DIVU instruction, but before any MFLO, MFHI, MTLO, or MTHI instructions, the contents of special register LO are undefined.
Operation:
32,64 T2: HI undefined T1: HI undefined T: HI GPR[rs]
Exceptions:
None
A-116
MTLO
31 SPECIAL 000000 6 26 25 rs 5
Move To LO
21 20 0 000000000000000 15 65
MTLO
0 MTLO 010011 6
Format:
MTLO rs
Description:
The contents of general register rs are loaded into special register LO. If a MTLO operation is executed following a MULT, MULTU, DIV, or DIVU instruction, but before any MFLO, MFHI, MTLO, or MTHI instructions, the contents of special register HI are undefined.
Operation:
32,64 T2: LO undefined T1: LO undefined T: LO GPR[rs]
Exceptions:
None
A-117
Appendix A
MULT
31 26 25 rs 5 21 20 SPECIAL 000000 6
Multiply
16 15 rt 5 0 00 0000 0000 10 6
MULT
5 MULT 011000 6 0
Format:
MULT rs, rt
Description:
The contents of general registers rs and rt are multiplied, treating both operands as 32-bit 2s complement values. No integer overflow exception occurs under any circumstances. In 64-bit mode, the operands must be valid 32-bit, sign-extended values. When the operation completes, the low-order word of the double result is loaded into special register LO, and the high-order word of the double result is loaded into special register HI. If either of the two preceding instructions is MFHI or MFLO, the results of these instructions are undefined. Correct operation requires separating reads of HI or LO from writes by a minimum of two other instructions.
A-118
MULT
Operation:
32 T2: LO HI T1: LO HI T: t LO HI T2: LO HI T1: LO HI T: t LO HI
Multiply (continued)
MULT
undefined undefined undefined undefined GPR[rs] * GPR[rt] t31...0 t63...32 undefined undefined undefined undefined GPR[rs]31...0 * GPR[rt]31...0 (t31)32 || t31...0 (t63)32 || t63...32
64
Exceptions:
None
A-119
Appendix A
MULTU
31 26 25 SPECIAL 000000 6 rs 5
Multiply Unsigned
21 20 rt 5 16 15
MULTU
6 5 MULTU 011001 6 0
0 00 0000 0000 10
Format:
MULTU rs, rt
Description:
The contents of general register rs and the contents of general register rt are multiplied, treating both operands as unsigned values. No overflow exception occurs under any circumstances. In 64-bit mode, the operands must be valid 32-bit, sign-extended values. When the operation completes, the low-order word of the double result is loaded into special register LO, and the high-order word of the double result is loaded into special register HI. If either of the two preceding instructions is MFHI or MFLO, the results of these instructions are undefined. Correct operation requires separating reads of HI or LO from writes by a minimum of two instructions.
A-120
MULTU
Operation:
32 T2: LO HI T1: LO HI T: t LO HI T2: LO HI T1: LO HI T: t LO HI
Multiply Unsigned (continued)
MULTU
undefined undefined undefined undefined (0 || GPR[rs]) * (0 || GPR[rt]) t31...0 t63...32 undefined undefined undefined undefined (0 || GPR[rs]31...0) * (0 || GPR[rt]31...0) (t31)32 || t31...0 (t63)32 || t63...32
64
Exceptions:
None
A-121
Appendix A
NOR
31 26 25 SPECIAL 000000 6 rs 5 21 20 rt 5
Nor
16 15 rd 5 11 10 6 5
NOR
0 0 00000 5 NOR 100111 6
Format:
NOR rd, rs, rt
Description:
The contents of general register rs are combined with the contents of general register rt in a bit-wise logical NOR operation. The result is placed into general register rd.
Operation:
32, 64 T: GPR[rd] GPR[rs] nor GPR[rt]
Exceptions:
None
A-122
OR
31 26 25 SPECIAL 000000 6 rs 5 21 20 rt 5
Or
16 15 rd 5 11 10 6 5
OR
0 0 00000 5 OR 100101 6
Format:
OR rd, rs, rt
Description:
The contents of general register rs are combined with the contents of general register rt in a bit-wise logical OR operation. The result is placed into general register rd.
Operation:
32, 64 T: GPR[rd] GPR[rs] or GPR[rt]
Exceptions:
None
A-123
Appendix A
ORI
31 26 25 ORI 001101 6 rs 5
Or Immediate
21 20 rt 5 16 15 immediate 16
ORI
0
Format:
ORI rt, rs, immediate
Description:
The 16-bit immediate is zero-extended and combined with the contents of general register rs in a bit-wise logical OR operation. The result is placed into general register rt.
Operation:
32 64 T: T: GPR[rt] GPR[rs]31...16 || (immediate or GPR[rs]15...0) GPR[rt] GPR[rs]63...16 || (immediate or GPR[rs]15...0)
Exceptions:
None
A-124
SB
31 26 25 SB 101000 6 base 5 21 20
Store Byte
SB
0
Format:
SB rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The least-significant byte of register rt is stored at the effective address.
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor ReverseEndian3) byte vAddr2...0 xor BigEndianCPU3 data GPR[rt]638*byte...0 || 08*byte StoreMemory (uncached, BYTE, data, pAddr, vAddr, DATA) vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor ReverseEndian3) byte vAddr2...0 xor BigEndianCPU3 data GPR[rt]638*byte...0 || 08*byte StoreMemory (uncached, BYTE, data, pAddr, vAddr, DATA)
64
T:
Exceptions:
TLB refill exception TLB invalid exception TLB modification exception Bus error exception Address error exception
A-125
Appendix A
SC
31 26 25 SC 111000 6 base 5
Store Conditional
21 20 rt 5 16 15 offset 16
SC
0
Format:
SC rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of general register rt are conditionally stored at the memory location specified by the effective address. If any other processor or device has modified the physical address since the time of the previous Load Linked instruction, or if an ERET instruction occurs between the Load Linked instruction and this store instruction, the store fails and is inhibited from taking place. The success or failure of the store operation (as defined above) is indicated by the contents of general register rt after execution of the instruction. A successful store sets the contents of general register rt to 1; an unsuccessful store sets it to 0. The operation of Store Conditional is undefined when the address is different from the address used in the last Load Linked. This instruction is available in User mode; it is not necessary for CP0 to be enabled. If either of the two least-significant bits of the effective address is non-zero, an address error exception takes place. If this instruction should both fail and take an exception, the exception takes precedence.
A-126
SC
Operation:
32 T:
Store Conditional (continued)
SC
vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02)) data GPR[rt]63-8*byte...0 || 08*byte if LLbit then StoreMemory (uncached, WORD, data, pAddr, vAddr, DATA) endif GPR[rt] 031 || LLbit vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02)) data GPR[rt]63-8*byte...0 || 08*byte if LLbit then StoreMemory (uncached, WORD, data, pAddr, vAddr, DATA) endif GPR[rt] 063 || LLbit
64
T:
Exceptions:
A-127
Appendix A
SCD
31 26 25 SCD 111100 6
Store Conditional Doubleword

21 20 base 5 rt 5 16 15 offset 16
SCD
0
Format:
SCD rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of general register rt are conditionally stored at the memory location specified by the effective address. If any other processor or device has modified the physical address since the time of the previous Load Linked Doubleword instruction, or if an ERET instruction occurs between the Load Linked Doubleword instruction and this store instruction, the store fails and is inhibited from taking place. The success or failure of the store operation (as defined above) is indicated by the contents of general register rt after execution of the instruction. A successful store sets the contents of general register rt to 1; an unsuccessful store sets it to 0. The operation of Store Conditional Doubleword is undefined when the address is different from the address used in the last Load Linked Doubleword. This instruction is available in User mode; it is not necessary for CP0 to be enabled. If either of the three least-significant bits of the effective address is nonzero, an address error exception takes place.
A-128
SCD
Store Conditional Doubleword (continued)
SCD
If this instruction should both fail and take an exception, the exception takes precedence. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) data GPR[rt] if LLbit then StoreMemory (uncached, DOUBLEWORD, data, pAddr, vAddr, DATA) endif GPR[rt] 063 || LLbit
Exceptions:
TLB refill exception TLB invalid exception TLB modification exception Bus error exception Address error exception Reserved instruction exception (R4000 in 32-bit mode)
A-129
Appendix A
SD
31 26 25 SD 111111 6 base 5
Store Doubleword
21 20 rt 5 16 15 offset 16
SD
0
Format:
SD rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of general register rt are stored at the memory location specified by the effective address. If either of the three least-significant bits of the effective address are nonzero, an address error exception occurs. This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) data GPR[rt] StoreMemory (uncached, DOUBLEWORD, data, pAddr, vAddr, DATA)
Exceptions:
TLB refill exception TLB invalid exception TLB modification exception Bus error exception Address error exception Reserved instruction exception (R4000 in 32-bit user mode R4000 in 32-bit supervisor mode)
A-130
SDCz
31 26 25 SDCz 1 1 1 1 x x* 6 base 5
Store Doubleword From Coprocessor

21 20 rt 5 16 15 offset 16
SDCz
0
Format:
SDCz rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. Coprocessor unit z sources a doubleword, which the processor writes to the addressed memory location. The data to be stored is defined by individual coprocessor specifications. If any of the three least-significant bits of the effective address are nonzero, an address error exception takes place. This instruction is not valid for use with CP0. This instruction is undefined when the least-significant bit of the rt field is non-zero.
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) data COPzSD(rt), StoreMemory (uncached, DOUBLEWORD, data, pAddr, vAddr, DATA) vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) data COPzSD(rt), StoreMemory (uncached, DOUBLEWORD, data, pAddr, vAddr, DATA)
64
T:
*See the table, Opcode Bit Encoding on next page, or CPU Instruction Opcode Bit Encoding at the end of Appendix A.
Appendix A
SDCz
Exceptions:
Store Doubleword From Coprocessor (continued)
SDCz
TLB refill exception TLB invalid exception TLB modification exception Bus error exception Address error exception Coprocessor unusable exception
SDCz
Bit # 31 SDC1 1
30 1 30 1
29 1 29 1
28 1 28 1
27 0 27 1
26 1 26 0
Bit # 31 SDC2 1
SD opcode
A-132
SDL
31 26 25 SDL 101100 6 base 5
Store Doubleword Left

21 20 rt 5 16 15 offset 16
SDL
0
Format:
SDL rt, offset(base)
Description:
This instruction can be used with the SDR instruction to store the contents of a register into eight consecutive bytes of memory, when the bytes cross a doubleword boundary. SDL stores the left portion of the register into the appropriate part of the high-order doubleword of memory; SDR stores the right portion of the register into the appropriate part of the low-order doubleword. The SDL instruction adds its sign-extended 16-bit offset to the contents of general register base to form a virtual address which may specify an arbitrary byte. It alters only the word in memory which contains that byte. From one to four bytes will be stored, depending on the starting byte specified. Conceptually, it starts at the most-significant byte of the register and copies it to the specified byte in memory; then it copies bytes from register to memory until it reaches the low-order byte of the word in memory. No address exceptions due to alignment are possible. memory (big-endian) 10 11 12 13 14 15 before 2 3 4 5 6 7
address 8 address 0
8 0
9 1
register A B C D E F G H $24
SDL $24,1($0)
address 8 address 0 8 0 9 B 10 11 12 13 14 15 after C D E F G H
A-133
Appendix A
SDL
Store Doubleword Left (continued)
SDL
This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: vAddr ((offset15)48 || offset 15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1...3 || (pAddr2...0 xor ReverseEndian3) If BigEndianMem = 0 then pAddr pAddr31...3 || 03 endif byte vAddr2...0 xor BigEndianCPU3 data 0568*byte || GPR[rt]63...568*byte Storememory (uncached, byte, data, pAddr, vAddr, DATA)
A-134
SDL
Store Doubleword Left (continued)
SDL
Given a doubleword in a register and a doubleword in memory, the operation of SDL is as follows:
SDL
BigEndianCPU = 0
offset vAddr2..0 destination type
BigEndianCPU = 1 LEM BEM

destination offset type LEM BEM
0 1 2 3 4 5 6 7
I I I I I I I A
J J J J J J A B
K K K K K A B C
L L L L A B C D
M M M A B C D E
N N A B C D E F
O A B C D E F G
A B C D E F G H
0 1 2 3 4 5 6 7
0 0 0 0 0 0 0 0
7 6 5 4 3 2 1 0
A I I I I I I I
B A J J J J J J
C B A K K K K K
D C B A L L L L
E F D E C D B C A B MA MN MN
G F E D C B A O
H G F E D C B A
7 6 5 4 3 2 1 0
0 0 0 0 0 0 0 0
0 1 2 3 4 5 6 7
LEM BEM Type Offset
Exceptions:
Appendix A
SDR
31 26 25 SDR 101101 6 5
Store Doubleword Right

21 20 base rt 5 16 15 offset 16
SDR
0
Format:
SDR rt, offset(base)
Description:
This instruction can be used with the SDL instruction to store the contents of a register into eight consecutive bytes of memory, when the bytes cross a boundary between two doublewords. SDR stores the right portion of the register into the appropriate part of the low-order doubleword; SDL stores the left portion of the register into the appropriate part of the low-order doubleword of memory. The SDR instruction adds its sign-extended 16-bit offset to the contents of general register base to form a virtual address which may specify an arbitrary byte. It alters only the word in memory which contains that byte. From one to eight bytes will be stored, depending on the starting byte specified. Conceptually, it starts at the least-significant (rightmost) byte of the register and copies it to the specified byte in memory; then it copies bytes from register to memory until it reaches the high-order byte of the word in memory. No address exceptions due to alignment are possible. memory (big-endian) address 8 address 0 8 0 9 1 10 11 12 13 14 15 before 2 3 4 5 6 7 memory (big-endian) address 8 address 0 8 E 9 F 10 11 12 13 14 15 G H 4 5 6 7
register A B C D E F G H $24
SDR $24,4($0)
after
A-136
SDR
Store Doubleword Right (continued)
SDR
This operation is only defined for the R4000 operating in 64-bit mode. Execution of this instruction in 32-bit mode causes a reserved instruction exception.
Operation:
64 T: vAddr ((offset15)48 || offset 15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1...3 || (pAddr2...0 xor ReverseEndian3) If BigEndianMem = 0 then pAddr pAddrPSIZE 31...3 || 03 endif byte vAddr1...0 xor BigEndianCPU3 data GPR[rt]638*byte || 08*byte StoreMemory (uncached, DOUBLEWORD-byte, data, pAddr, vAddr, DATA)
A-137
Appendix A
SDR
Store Doubleword Right (continued)
SDR
Given a doubleword in a register and a doubleword in memory, the operation of SDR is as follows:
SDR
BigEndianCPU = 0
vAddr2..0 destination offset type
BigEndianCPU = 1
offset destination type
LEM BEM
LEM BEM
0 1 2 3 4 5 6 7
A B C D E F G H
B C D E F G H J
C D E F G H K K
DE EF F G GH HM L M L M L M
F G H N N N N N
G H O O O O O O
H P P P P P P P
7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7
0 0 0 0 0 0 0 0
H G F E D C B A
J H G F E D C B
K K H G F E D C
L L L H G F E D
MN MN MN MN H N GH F G E F
O O O O O O H G
P P P P P P P H
0 1 2 3 4 5 6 7
7 6 5 4 3 2 1 0
0 0 0 0 0 0 0 0
LEM BEM Type Offset
Exceptions:
SH
31 26 25 SH 101001 6 base 5
Store Halfword
21 20 rt 5 16 15 offset 16
SH
0
Format:
SH rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form an unsigned effective address. The least-significant halfword of register rt is stored at the effective address. If the leastsignificant bit of the effective address is non-zero, an address error exception occurs.
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian2 || 0)) byte vAddr2...0 xor (BigEndianCPU2 || 0) data GPR[rt]638*byte...0 || 08*byte StoreMemory (uncached, HALFWORD, data, pAddr, vAddr, DATA) vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian2 || 0)) byte vAddr2...0 xor (BigEndianCPU2 || 0) data GPR[rt]638*byte...0 || 08*byte StoreMemory (uncached, HALFWORD, data, pAddr, vAddr, DATA)
64
T:
Exceptions:
A-139
Appendix A
SLL
31 26 25 SPECIAL 000000 6 0 00000 5
Shift Left Logical

21 20 rt 5 16 15 rd 5 11 10 sa 5 6 5
SLL
0 SLL 000000 6
Format:
SLL rd, rt, sa
Description:
The contents of general register rt are shifted left by sa bits, inserting zeros into the low-order bits. The result is placed in register rd. In 64-bit mode, the 32-bit result is sign extended when placed in the destination register. It is sign extended for all shift amounts, including zero; SLL with a zero shift amount truncates a 64-bit value to 32 bits and then sign extends this 32-bit value. SLL, unlike nearly all other word operations, does not require an operand to be a properly sign-extended word value to produce a valid sign-extended word result. NOTE: SLL with a shift amount of zero may be treated as a NOP by some assemblers, at some optimization levels. If using SLL with a zero shift to truncate 64-bit values, check the assembler you are using.
Operation:
32 64 T: T: GPR[rd] GPR[rt]31 sa...0 || 0sa s 0 || sa temp GPR[rt]31-s...0 || 0s GPR[rd] (temp31)32 || temp
Exceptions:
None
A-140
SLLV
31 26 25 SPECIAL 000000 6
Shift Left Logical Variable

21 20 rs 5 rt 5 16 15 rd 5 11 10 6 5
SLLV
0 SLLV 000100 6
0 00000 5
Format:
SLLV rd, rt, rs
Description:
The contents of general register rt are shifted left the number of bits specified by the low-order five bits contained in general register rs, inserting zeros into the low-order bits. The result is placed in register rd. In 64-bit mode, the 32-bit result is sign extended when placed in the destination register. It is sign extended for all shift amounts, including zero; SLLV with a zero shift amount truncates a 64-bit value to 32 bits and then sign extends this 32-bit value. SLLV, unlike nearly all other word operations, does not require an operand to be a properly sign-extended word value to produce a valid sign-extended word result. NOTE: SLLV with a shift amount of zero may be treated as a NOP by some assemblers, at some optimization levels. If using SLLV with a zero shift to truncate 64-bit values, check the assembler you are using.
Operation:
32 T: s GP[rs]4...0 GPR[rd] GPR[rt](31s)...0 || 0s 64 T: s 0 || GP[rs]4...0 temp GPR[rt](31-s)...0 || 0s GPR[rd] (temp31)32 || temp
Exceptions:
None
A-141
Appendix A
SLT
31 26 25 SPECIAL 000000 6 rs 5
Set On Less Than

21 20 rt 5 16 15 rd 5 11 10 6 5
SLT
0 SLT 101010 6 0 00000 5
Format:
SLT rd, rs, rt
Description:
The contents of general register rt are subtracted from the contents of general register rs. Considering both quantities as signed integers, if the contents of general register rs are less than the contents of general register rt, the result is set to one; otherwise the result is set to zero. The result is placed into general register rd. No integer overflow exception occurs under any circumstances. The comparison is valid even if the subtraction used during the comparison overflows.
Operation:
32 T: if GPR[rs] < GPR[rt] then GPR[rd] 031 || 1 else GPR[rd] 032 endif if GPR[rs] < GPR[rt] then GPR[rd] 063 || 1 else GPR[rd] 064 endif
64
T:
Exceptions:
None
A-142
SLTI
31 26 25 SLTI 001010 6
Set On Less Than Immediate

21 20 rs 5 rt 5 16 15 immediate 16
SLTI
0
Format:
SLTI rt, rs, immediate
Description:
The 16-bit immediate is sign-extended and subtracted from the contents of general register rs. Considering both quantities as signed integers, if rs is less than the sign-extended immediate, the result is set to one; otherwise the result is set to zero. The result is placed into general register rt. No integer overflow exception occurs under any circumstances. The comparison is valid even if the subtraction used during the comparison overflows.
Operation:
32 T: if GPR[rs] < (immediate15)16 || immediate15...0 then GPR[rd] 031 || 1 else GPR[rd] 032 endif 64 T: if GPR[rs] < (immediate15)48 || immediate15...0 then GPR[rd] 063 || 1 else GPR[rd] 064 endif
Exceptions:
None
Appendix A
SLTIU
31 26 25 SLTIU 001011 6 rs 5
Set On Less Than Immediate Unsigned

21 20 rt 5 16 15 immediate 16
SLTIU
0
Format:
SLTIU rt, rs, immediate
Description:
The 16-bit immediate is sign-extended and subtracted from the contents of general register rs. Considering both quantities as unsigned integers, if rs is less than the sign-extended immediate, the result is set to one; otherwise the result is set to zero. The result is placed into general register rt. No integer overflow exception occurs under any circumstances. The comparison is valid even if the subtraction used during the comparison overflows.
Operation:
32 T: if (0 || GPR[rs]) < (immediate15)16 || immediate15...0 then GPR[rd] 031 || 1 else GPR[rd] 032 endif if (0 || GPR[rs]) < (immediate15)48 || immediate15...0 then GPR[rd] 063 || 1 else GPR[rd] 064 endif
64
T:
Exceptions:
None
SLTU
31 26 25 SPECIAL 000000 6
Set On Less Than Unsigned

21 20 rs 5 rt 5 16 15 rd 5 11 10 6 5
SLTU
0 SLTU 101011 6
0 00000 5
Format:
SLTU rd, rs, rt
Description:
The contents of general register rt are subtracted from the contents of general register rs. Considering both quantities as unsigned integers, if the contents of general register rs are less than the contents of general register rt, the result is set to one; otherwise the result is set to zero. The result is placed into general register rd. No integer overflow exception occurs under any circumstances. The comparison is valid even if the subtraction used during the comparison overflows.
Operation:
32 T: if (0 || GPR[rs]) < 0 || GPR[rt] then GPR[rd] 031 || 1 else GPR[rd] 032 endif if (0 || GPR[rs]) < 0 || GPR[rt] then GPR[rd] 063 || 1 else GPR[rd] 064 endif
64
T:
Exceptions:
None
A-145
Appendix A
SRA
31 26 25 SPECIAL 000000 6
Shift Right Arithmetic

21 20 rt 5 16 15 rd 5 11 10 sa 5 6 5
SRA
0 SRA 000011 6
0 00000 5
Format:
SRA rd, rt, sa
Description:
The contents of general register rt are shifted right by sa bits, signextending the high-order bits. The result is placed in register rd. In 64-bit mode, the operand must be a valid sign-extended, 32-bit value.
Operation:
32 64 T: T: GPR[rd] (GPR[rt]31)sa || GPR[rt] 31...sa s 0 || sa temp (GPR[rt]31)s || GPR[rt] 31...s GPR[rd] (temp31)32 || temp
Exceptions:
None
A-146
SRAV
31 26 25 SPECIAL 000000 6 rs 5
Shift Right Arithmetic Variable

21 20 rt 5 16 15 rd 5 11 10 6
SRAV
5 SRAV 000111 6 0 0 00000 5
Format:
SRAV rd, rt, rs
Description:
The contents of general register rt are shifted right by the number of bits specified by the low-order five bits of general register rs, sign-extending the high-order bits. The result is placed in register rd. In 64-bit mode, the operand must be a valid sign-extended, 32-bit value.
Operation:
32 T: s GPR[rs]4...0 GPR[rd] (GPR[rt]31)s || GPR[rt]31...s 64 T: s GPR[rs]4...0 temp (GPR[rt]31)s || GPR[rt]31...s GPR[rd] (temp31)32 || temp
Exceptions:
None
A-147
Appendix A
SRL
31 26 25 SPECIAL 000000 6 0 00000 5
Shift Right Logical

21 20 rt 5 16 15 rd 5 11 10 sa 5 6 5
SRL
0 SRL 000010 6
Format:
SRL rd, rt, sa
Description:
The contents of general register rt are shifted right by sa bits, inserting zeros into the high-order bits. The result is placed in register rd. In 64-bit mode, the operand must be a valid sign-extended, 32-bit value.
Operation:
32 64 T: T: GPR[rd] 0 sa || GPR[rt]31...sa s 0 || sa temp 0s || GPR[rt]31...s GPR[rd] (temp31)32 || temp
Exceptions:
None
A-148
SRLV
31 26 25 SPECIAL 000000 6
Shift Right Logical Variable

21 20 rs 5 rt 5 16 15 rd 5 11 10 6
SRLV
5 SRLV 000110 6 0
0 00000 5
Format:
SRLV rd, rt, rs
Description:
The contents of general register rt are shifted right by the number of bits specified by the low-order five bits of general register rs, inserting zeros into the high-order bits. The result is placed in register rd. In 64-bit mode, the operand must be a valid sign-extended, 32-bit value.
Operation:
32 T: s GPR[rs]4...0 GPR[rd] 0s || GPR[rt]31...s 64 T: s GPR[rs]4...0 temp 0s || GPR[rt]31...s GPR[rd] (temp31)32 || temp
Exceptions:
None
A-149
Appendix A
SUB
31 26 25 SPECIAL 000000 6 rs 5 21 20
Subtract
16 15 rt 5 rd 5 11 10 6 5
SUB
0 0 00000 5 SUB 100010 6
Format:
SUB rd, rs, rt
Description:
The contents of general register rt are subtracted from the contents of general register rs to form a result. The result is placed into general register rd. In 64-bit mode, the operands must be valid sign-extended, 32bit values. The only difference between this instruction and the SUBU instruction is that SUBU never traps on overflow. An integer overflow exception takes place if the carries out of bits 30 and 31 differ (2s complement overflow). The destination register rd is not modified when an integer overflow exception occurs.
Operation:
32 64 T: T: GPR[rd] GPR[rs] GPR[rt] temp GPR[rs] - GPR[rt] GPR[rd] (temp31)32 || temp31...0
Exceptions:
A-150
SUBU
31 26 25 SPECIAL 000000 6 rs 5
Subtract Unsigned
SUBU
6 5 SUBU 100011 6 0 0 00000 5
21 20 rt 5
16 15 rd 5
11 10
Format:
SUBU rd, rs, rt
Description:
The contents of general register rt are subtracted from the contents of general register rs to form a result. The result is placed into general register rd. In 64-bit mode, the operands must be valid sign-extended, 32-bit values. The only difference between this instruction and the SUB instruction is that SUBU never traps on overflow. No integer overflow exception occurs under any circumstances.
Operation:
32 64 T: T: GPR[rd] GPR[rs] GPR[rt] temp GPR[rs] - GPR[rt] GPR[rd] (temp31)32 || temp31...0
Exceptions:
None
A-151
Appendix A
SW
31 26 25 SW 101011 6 base 5 21 20
Store Word
SW
0
Format:
SW rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. The contents of general register rt are stored at the memory location specified by the effective address. If either of the two least-significant bits of the effective address are nonzero, an address error exception occurs.
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02) byte vAddr2...0 xor (BigEndianCPU || 02) data GPR[rt]63-8*byte || 08*byte StoreMemory (uncached, WORD, data, pAddr, vAddr, DATA) T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02) byte vAddr2...0 xor (BigEndianCPU || 02) data GPR[rt]63-8*byte || 08*byte StoreMemory (uncached, WORD, data, pAddr, vAddr, DATA)
64
Exceptions:
TLB refill exception TLB modification exception Address error exception TLB invalid exception Bus error exception
A-152
SWCz
31 26 25 SWCz 1 1 1 0 x x* 6
Store Word From Coprocessor

21 20 base 5 rt 5 16 15 offset 16
SWCz
0
Format:
SWCz rt, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form a virtual address. Coprocessor unit z sources a word, which the processor writes to the addressed memory location. The data to be stored is defined by individual coprocessor specifications. This instruction is not valid for use with CP0. If either of the two least-significant bits of the effective address is non-zero, an address error exception occurs.
Operation:
32 T: vAddr ((offset15)16 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02) byte vAddr2...0 xor (BigEndianCPU || 02) data COPzSW (byte, rt) StoreMemory (uncached, WORD, data, pAddr, vAddr, DATA) T: vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02) byte vAddr2...0 xor (BigEndianCPU || 02) data COPzSW (byte,rt) StoreMemory (uncached, WORD, data, pAddr, vAddr DATA)
64
A-153
Appendix A
SWCz
Exceptions:
Store Word From Coprocessor (Continued)
SWCz
TLB refill exception TLB invalid exception TLB modification exception Bus error exception Address error exception Coprocessor unusable exception
SWCz
Bit # 31 SWC1 1
30 1 30 1
29 1 29 1
28 0 28 0
27 0 27 1
26 1 26 0
Bit # 31 SWC2 1
SW opcode
A-154
SWL
31 26 25 SWL 101010 6 base 5
Store Word Left

21 20 rt 5 16 15 offset 16
SWL
0
Format:
SWL rt, offset(base)
Description:
This instruction can be used with the SWR instruction to store the contents of a register into four consecutive bytes of memory, when the bytes cross a word boundary. SWL stores the left portion of the register into the appropriate part of the high-order word of memory; SWR stores the right portion of the register into the appropriate part of the low-order word. The SWL instruction adds its sign-extended 16-bit offset to the contents of general register base to form a virtual address which may specify an arbitrary byte. It alters only the word in memory which contains that byte. From one to four bytes will be stored, depending on the starting byte specified. Conceptually, it starts at the most-significant byte of the register and copies it to the specified byte in memory; then it copies bytes from register to memory until it reaches the low-order byte of the word in memory. No address exceptions due to alignment are possible. memory (big-endian) address 4 address 0 4 0 5 1 6 2 7 3
register
before
$24
SWL $24,1($0) address 4 address 0 4 0 5 A 6 B 7 C
after
A-155
Appendix A
SWL
Operation:
32
Store Word Left (Continued)
SWL
T: vAddr ((offset15)16 || offset 15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1...3 || (pAddr2...0 xor ReverseEndian3) If BigEndianMem = 0 then pAddr pAddr31...2 || 02 endif byte vAddr1...0 xor BigEndianCPU2 if (vAddr2 xor BigEndianCPU) = 0 then data 032 || 024-8*byte || GPR[rt]31...24-8*byte else data 024-8*byte || GPR[rt]31...24-8*byte || 032 endif Storememory (uncached, byte, data, pAddr, vAddr, DATA) T: vAddr ((offset15)48 || offset 15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1...3 || (pAddr2...0 xor ReverseEndian3) If BigEndianMem = 0 then pAddr pAddr31...2 || 02 endif byte vAddr1...0 xor BigEndianCPU2 if (vAddr2 xor BigEndianCPU) = 0 then data 032 || 024-8*byte || GPR[rt]31...24-8*byte else data 024-8*byte || GPR[rt]31...24-8*byte || 032 endif StoreMemory(uncached, byte, data, pAddr, vAddr, DATA)
64
A-156
SWL
Store Word Left (Continued)
SWL
Given a doubleword in a register and a doubleword in memory, the operation of SWL is as follows:
SWL
BigEndianCPU = 0
BigEndianCPU = 1
LEM BEM
LEM BEM
0 1 2 3 4 5 6 7
I I I I I I I E
J J J J J J E F
K K K K K E F G
L M L M L M L E EM F M GM HM
N N E F N N N N
O E F G O O O O
E F G H P P P P
0 1 2 3 0 1 2 3
0 0 0 0 4 4 4 4
7 6 5 4 3 2 1 0
E I I I I I I I
F E J J J J J J
G F E K K K K K
H G F E L L L L
M M M M E M M M
N N N N F E N N
O O O O G F E O
P P P P H G F E
3 2 1 0 3 2 1 0
4 4 4 4 0 0 0 0
0 1 2 3 4 5 6 7
LEM BEM Type Offset
Exceptions:
Appendix A
SWR
31 26 25 SWR 101110 6 base 5
Store Word Right

21 20 rt 5 16 15 offset 16
SWR
0
Format:
SWR rt, offset(base)
Description:
This instruction can be used with the SWL instruction to store the contents of a register into four consecutive bytes of memory, when the bytes cross a boundary between two words. SWR stores the right portion of the register into the appropriate part of the low-order word; SWL stores the left portion of the register into the appropriate part of the low-order word of memory. The SWR instruction adds its sign-extended 16-bit offset to the contents of general register base to form a virtual address which may specify an arbitrary byte. It alters only the word in memory which contains that byte. From one to four bytes will be stored, depending on the starting byte specified. Conceptually, it starts at the least-significant (rightmost) byte of the register and copies it to the specified byte in memory; then copies bytes from register to memory until it reaches the high-order byte of the word in memory. No address exceptions due to alignment are possible. memory (big-endian) address 4 address 0 4 0 5 1 6 2 7 3
register
before
$24
SWR $24,1($0) address 4 address 0 D 0 5 1 6 2 7 3
after
A-158
SWR
Operation:
32
Store Word Right (Continued)
SWR
T: vAddr ((offset15)16 || offset 15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1...3 || (pAddr2...0 xor ReverseEndian3) If BigEndianMem = 0 then pAddr pAddr31...2 || 02 endif byte vAddr1...0 xor BigEndianCPU2 if (vAddr2 xor BigEndianCPU) = 0 then data 032 || GPR[rt]31-8*byte...0 || 08*byte else data GPR[rt]31-8*byte...0 || 08*byte || 032 endif Storememory (uncached, WORD-byte, data, pAddr, vAddr, DATA) T: vAddr ((offset15)48 || offset 15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE 1...3 || (pAddr2...0 xor ReverseEndian3) If BigEndianMem = 0 then pAddr pAddr31...2 || 02 endif byte vAddr1...0 xor BigEndianCPU2 if (vAddr2 xor BigEndianCPU) = 0 then data 032 || GPR[rt]31-8*byte...0 || 08*byte else data GPR[rt]31-8*byte...0 || 08*byte || 032 endif StoreMemory(uncached, WORD-byte, data, pAddr, vAddr, DATA)
64
A-159
Appendix A
SWR
Store Word Right (Continued)
SWR
Given a doubleword in a register and a doubleword in memory, the operation of SWR is as follows:
SWR
BigEndianCPU = 0
BigEndianCPU = 1
LEM BEM
LEM BEM
0 1 2 3 4 5 6 7
I I I I E F G H
J J J J F G H J
K K K K G H K K
L L L L H L L L
E F G H M M M M
F G H N N N N N
G H O O O O O O
H P P P P P P P
3 2 1 0 3 2 1 0
0 1 2 3 4 5 6 7
4 4 4 4 0 0 0 0
H G F E I I I I
J H G F J J J J
K K H G K K K K
L L L H L L L L
MN MN MN MN H N GH F G E F
O O O O O O H G
P P P P P P P H
0 1 2 3 0 1 2 3
7 6 5 4 3 2 1 0
0 0 0 0 4 4 4 4
LEM BEM Type Offset
Exceptions:
SYNC
31 26 25 SPECIAL 000000 6
Synchronize
6 0 0000 0000 0000 0000 0000 20
SYNC
5 SYNC 001111 6 0
Format:
SYNC
Description:
The SYNC instruction ensures that any loads and stores fetched prior to the present instruction are completed before any loads or stores after this instruction are allowed to start. Use of the SYNC instruction to serialize certain memory references may be required in a multiprocessor environment for proper synchronization. For example: Processor A SW LI SYNC SW R1, DATA R2, 1 R2, FLAG 1: Processor B LW BEQ NOP SYNC LW R2, FLAG R2, R0, 1B
R1, DATA
The SYNC in processor A prevents DATA being written after FLAG, which could cause processor B to read stale data. The SYNC in processor B prevents DATA from being read before FLAG, which could likewise result in reading stale data. For processors which only execute loads and stores in order, with respect to shared memory, this instruction is a NOP. LL and SC instructions implicitly perform a SYNC. This instruction is allowed in User mode.
Operation:
32, 64 T: SyncOperation()
Exceptions:
None
A-161
Appendix A
SYSCALL
31 26 25 SPECIAL 000000 6
System Call
SYSCALL
6 5 SYSCALL 0 0 1 1 00 6 0
Code 20
Format:
SYSCALL
Description:
A system call exception occurs, immediately and unconditionally transferring control to the exception handler. The code field is available for use as software parameters, but is retrieved by the exception handler only by loading the contents of the memory word containing the instruction.
Operation:
32, 64 T: SystemCallException
Exceptions:
System Call exception
A-162
TEQ
31 26 25 SPECIAL 000000 6 rs 5
Trap If Equal
21 20 rt 5 16 15 code 10 6 5
TEQ
0 TEQ 110100 6
Format:
TEQ rs, rt
Description:
The contents of general register rt are compared to general register rs. If the contents of general register rs are equal to the contents of general register rt, a trap exception occurs. The code field is available for use as software parameters, but is retrieved by the exception handler only by loading the contents of the memory word containing the instruction.
Operation:
32, 64 T: if GPR[rs] = GPR[rt] then TrapException endif
Exceptions:
Trap exception
A-163
Appendix A
TEQI
31 26 25 REGIMM 000001 6 rs 5
Trap If Equal Immediate

21 20 16 15 immediate 16
TEQI
0
TEQI 01100 5
Format:
TEQI rs, immediate
Description:
The 16-bit immediate is sign-extended and compared to the contents of general register rs. If the contents of general register rs are equal to the sign-extended immediate, a trap exception occurs.
Operation:
32 T: if GPR[rs] = (immediate15)16 || immediate15...0 then TrapException endif 64 T: if GPR[rs] = (immediate15)48 || immediate15...0 then TrapException endif
Exceptions:
Trap exception
A-164
TGE
31 26 25 SPECIAL 000000 6
Trap If Greater Than Or Equal

21 20 rs 5 rt 5 16 15 code 10 6 5
TGE
0 TGE 110000 6
Format:
TGE rs, rt
Description:
The contents of general register rt are compared to the contents of general register rs. Considering both quantities as signed integers, if the contents of general register rs are greater than or equal to the contents of general register rt, a trap exception occurs. The code field is available for use as software parameters, but is retrieved by the exception handler only by loading the contents of the memory word containing the instruction.
Operation:
32, 64 T: if GPR[rs] GPR[rt] then TrapException endif
Exceptions:
Trap exception
A-165
Appendix A
TGEI
31 REGIMM 000001 6
Trap If Greater Than Or Equal Immediate

26 25 rs 5 21 20 16 15 immediate 16
TGEI
0
TGEI 01000 5
Format:
TGEI rs, immediate
Description:
The 16-bit immediate is sign-extended and compared to the contents of general register rs. Considering both quantities as signed integers, if the contents of general register rs are greater than or equal to the signextended immediate, a trap exception occurs.
Operation:
32 T: if GPR[rs] (immediate15)16 || immediate15...0 then TrapException endif T: if GPR[rs] (immediate15)48 || immediate15...0 then TrapException endif
64
Exceptions:
Trap exception
A-166
TGEIU
31 26 25 REGIMM 000001 6
Trap If Greater Than Or Equal Immediate Unsigned

21 20 rs 5 16 15 immediate 16
TGEIU
0
TGEIU 01001 5
Format:
TGEIU rs, immediate
Description:
The 16-bit immediate is sign-extended and compared to the contents of general register rs. Considering both quantities as unsigned integers, if the contents of general register rs are greater than or equal to the signextended immediate, a trap exception occurs.
Operation:
32 T: if (0 || GPR[rs]) (0 || (immediate15)16 || immediate15...0) then TrapException endif T: if (0 || GPR[rs]) (0 || (immediate15)48 || immediate15...0) then TrapException endif
64
Exceptions:
Trap exception
A-167
Appendix A
TGEU
31 SPECIAL 000000 6
Trap If Greater Than Or Equal Unsigned

21 20 rs 5 rt 5 16 15 code 10 6
TGEU
5 TGEU 110001 6 0
26 25
Format:
TGEU rs, rt
Description:
The contents of general register rt are compared to the contents of general register rs. Considering both quantities as unsigned integers, if the contents of general register rs are greater than or equal to the contents of general register rt, a trap exception occurs. The code field is available for use as software parameters, but is retrieved by the exception handler only by loading the contents of the memory word containing the instruction.
Operation:
T: if (0 || GPR[rs]) (0 || GPR[rt]) then TrapException endif
Exceptions:
Trap exception
A-168
TLBP
31 COP0 010000 6
Probe TLB For Matching Entry

26 25 CO 1 1 24 0 000 0000 0000 0000 0000 19
TLBP
6 5 0 TLBP 001000 6
Format:
TLBP
Description:
The Index register is loaded with the address of the TLB entry whose contents match the contents of the EntryHi register. If no TLB entry matches, the high-order bit of the Index register is set. The architecture does not specify the operation of memory references associated with the instruction immediately after a TLBP instruction, nor is the operation specified if more than one TLB entry matches.
Operation:
32 T: Index 1 || 025 || undefined6 for i in 0...TLBEntries1 if (TLB[i]95...77 = EntryHi31...12) and (TLB[i]76 or (TLB[i]71...64 = EntryHi7...0)) then Index 026 || i 5...0 endif endfor Index 1 || 0 25 || undefined6 for i in 0...TLBEntries1 if (TLB[i]167...141 and not (015 || TLB[i]216...205)) = EntryHi39...13) and not (015 || TLB[i]216...205)) and (TLB[i]140 or (TLB[i]135...128 = EntryHi7...0)) then Index 026 || i 5...0 endif endfor
64
T:
Exceptions:
A-169
Appendix A
TLBR
31 26 COP0 010000 6 CO 1 1
Read Indexed TLB Entry

25 24 0 000 0000 0000 0000 0000 19
TLBR
6 5 0 TLBR 000001 6
Format:
TLBR
Description:
The G bit (which controls ASID matching) read from the TLB is written into both of the EntryLo0 and EntryLo1 registers. The EntryHi and EntryLo registers are loaded with the contents of the TLB entry pointed at by the contents of the TLB Index register. The operation is invalid (and the results are unspecified) if the contents of the TLB Index register are greater than the number of TLB entries in the processor.
Operation:
32 T: PageMask TLB[Index5...0]127...96 EntryHi TLB[Index5...0]95...64 and not TLB[Index5...0]127...96 EntryLo1 TLB[Index5...0]63...32 EntryLo0 TLB[Index5...0]31...0 T: PageMask TLB[Index5...0]255...192 EntryHi TLB[Index5...0]191...128 and not TLB[Index5...0]255...192 EntryLo1 TLB[Index5...0]127...65 || TLB[Index5...0]140 EntryLo0 TLB[Index5...0]63...1 || TLB[Index5...0]140
64
Exceptions:
A-170
TLBWI
31 COP0 010000 6 26 25 CO 1 1
Write Indexed TLB Entry

24 0 000 0000 0000 0000 0000 19
TLBWI
6 5 0 TLBWI 000010 6
Format:
TLBWI
Description:
The G bit of the TLB is written with the logical AND of the G bits in the EntryLo0 and EntryLo1 registers. The TLB entry pointed at by the contents of the TLB Index register is loaded with the contents of the EntryHi and EntryLo registers. The operation is invalid (and the results are unspecified) if the contents of the TLB Index register are greater than the number of TLB entries in the processor.
Operation:
32, 64T: TLB[Index5...0] PageMask || (EntryHi and not PageMask) || EntryLo1 || EntryLo0
Exceptions:
A-171
Appendix A
TLBWR
31 26 COP0 010000 6 CO 1 1
Write Random TLB Entry
TLBWR
6 5 0 TLBWR 000110 6
25 24 0 000 0000 0000 0000 0000 19
Format:
TLBWR
Description:
The G bit of the TLB is written with the logical AND of the G bits in the EntryLo0 and EntryLo1 registers. The TLB entry pointed at by the contents of the TLB Random register is loaded with the contents of the EntryHi and EntryLo registers.
Operation:
32, 64T: TLB[Random5...0]
PageMask || (EntryHi and not PageMask) || EntryLo1 || EntryLo0
Exceptions:
A-172
TLT
31 26 25 SPECIAL 000000 6 rs 5
Trap If Less Than

21 20 rt 5 16 15 code 10 6 5
TLT
0 TLT 110010 6
Format:
TLT rs, rt
Description:
The contents of general register rt are compared to general register rs. Considering both quantities as signed integers, if the contents of general register rs are less than the contents of general register rt, a trap exception occurs. The code field is available for use as software parameters, but is retrieved by the exception handler only by loading the contents of the memory word containing the instruction.
Operation:
32, 64 T: if GPR[rs] < GPR[rt] then TrapException endif
Exceptions:
Trap exception
A-173
Appendix A
TLTI
31 26 25 REGIMM 000001 6
Trap If Less Than Immediate

21 20 rs 5 16 15 immediate 16
TLTI
0
TLTI 01010 5
Format:
TLTI rs, immediate
Description:
The 16-bit immediate is sign-extended and compared to the contents of general register rs. Considering both quantities as signed integers, if the contents of general register rs are less than the sign-extended immediate, a trap exception occurs.
Operation:
32 T: if GPR[rs] < (immediate15)16 || immediate15...0 then TrapException endif T: if GPR[rs] < (immediate15)48 || immediate15...0 then TrapException endif
64
Exceptions:
Trap exception
A-174
TLTIU
31 REGIMM 000001 6
Trap If Less Than Immediate Unsigned

21 20 rs 5 16 15 immediate 16
TLTIU
0
26 25
TLTIU 01011 5
Format:
TLTIU rs, immediate
Description:
The 16-bit immediate is sign-extended and compared to the contents of general register rs. Considering both quantities as signed integers, if the contents of general register rs are less than the sign-extended immediate, a trap exception occurs.
Operation:
32 T: if (0 || GPR[rs]) < (0 || (immediate15)16 || immediate15...0) then TrapException endif if (0 || GPR[rs]) < (0 || (immediate15)48 || immediate15...0) then TrapException endif
64
T:
Exceptions:
Trap exception
A-175
Appendix A
TLTU
31 26 25 SPECIAL 000000 6
Trap If Less Than Unsigned

21 20 rs 5 rt 5 16 15 code 10 6 5
TLTU
0 TLTU 110011 6
Format:
TLTU rs, rt
Description:
The contents of general register rt are compared to general register rs. Considering both quantities as unsigned integers, if the contents of general register rs are less than the contents of general register rt, a trap exception occurs. The code field is available for use as software parameters, but is retrieved by the exception handler only by loading the contents of the memory word containing the instruction.
Operation:
32, 64T: if (0 || GPR[rs]) < (0 || GPR[rt]) then TrapException endif
Exceptions:
Trap exception
A-176
TNE
31 26 25 SPECIAL 000000 6 rs 5
Trap If Not Equal

21 20 rt 5 16 15 code 10 6 5
TNE
0 TNE 110110 6
Format:
TNE rs, rt
Description:
The contents of general register rt are compared to general register rs. If the contents of general register rs are not equal to the contents of general register rt, a trap exception occurs. The code field is available for use as software parameters, but is retrieved by the exception handler only by loading the contents of the memory word containing the instruction.
Operation:
32, 64T: if GPR[rs] GPR[rt] then TrapException endif
Exceptions:
Trap exception
A-177
Appendix A
TNEI
31 26 25 REGIMM 000001 6
Trap If Not Equal Immediate

21 20 rs 5 16 15 immediate 16
TNEI
0
TNEI 01110 5
Format:
TNEI rs, immediate
Description:
The 16-bit immediate is sign-extended and compared to the contents of general register rs. If the contents of general register rs are not equal to the sign-extended immediate, a trap exception occurs.
Operation:
32 T: if GPR[rs] (immediate15)16 || immediate15...0 then TrapException endif if GPR[rs] (immediate15)48 || immediate15...0 then TrapException endif
64
T:
Exceptions:
Trap exception
A-178
XOR
31 26 25 SPECIAL 000000 6 rs 5
Exclusive Or
21 20 rt 5 16 15 rd 5 11 10 6 5
XOR
0 XOR 100110 6 0 00000 5
Format:
XOR rd, rs, rt
Description:
The contents of general register rs are combined with the contents of general register rt in a bit-wise logical exclusive OR operation. The result is placed into general register rd.
Operation:
32, 64 T: GPR[rd] GPR[rs] xor GPR[rt]
Exceptions:
None
A-179
Appendix A
XORI
31 26 25 XORI 001110 6 rs 5
Exclusive OR Immediate
21 20 rt 5 16 15 immediate 16
XORI
0
Format:
XORI rt, rs, immediate
Description:
The 16-bit immediate is zero-extended and combined with the contents of general register rs in a bit-wise logical exclusive OR operation. The result is placed into general register rt.
Operation:
32 64 T: T: GPR[rt] GPR[rs] xor (016 || immediate) GPR[rt] GPR[rs] xor (048 || immediate)
Exceptions:
None
A-180
CPU Instruction Opcode Bit Encoding

The remainder of this Appendix presents the opcode bit encoding for the CPU instruction set (ISA and extensions), as implemented by the R4000. Figure A-2 lists the R4000 Opcode Bit Encoding.
28...26 0 1 31...29 0 SPECIAL REGIMM 1 ADDI ADDIU COP0 COP1 2 3 DADDI DADDIU 4 LB LH 5 SB SH 6 LL LWC1 7 SC SWC1 2...0 0 SLL JR MFHI MULT ADD * TGE DSLL 1 * JALR MTHI MULTU ADDU * TGEU *
Opcode
2 J SLTI COP2 LDL LWL SWL LWC2 SWC2 2 SRL * MFLO DIV SUB SLT TLT DSRL 3 JAL SLTIU * LDR LW SW * * 3 SRA * MTLO DIVU SUBU SLTU TLTU DSRA 3 BGEZL TLTIU
BGEZALL
4 BEQ ANDI BEQL * LBU SDL LLD SCD
5 BNE ORI BNEL * LHU SDR LDC1 SDC1
6 BLEZ XORI BLEZL * LWR SWR LDC2 SDC2
7 BGTZ LUI BGTZL * LWU CACHE LD SD
SPECIAL function
4 5 6 7 * SLLV SRLV SRAV * SYNC SYSCALL BREAK DSLLV * DSRLV DSRAV DMULT DMULTU DDIV DDIVU AND OR XOR NOR DADD DADDU DSUB DSUBU TEQ TNE * * DSLL32 * DSRL32 DSRA32 4 * TEQI * * 5 * * * * 6 * TNEI * * 7 * * * *
5...3 0 1 2 3 4 5 6 7
20...19 0 1 2 3
18...16 0 1 2 BLTZ BGEZ BLTZL TLTI TGEI TGEIU BLTZAL BGEZAL BLTZALL * * * 23...21 0 MF BC
REGIMM rt
25, 24 0 1 2 3
1 DMF
2 CF
COPz rs
4 MT
5 DMT
6 CT
CO
Figure A-2
R4000 Opcode Bit Encoding
A-181
Appendix A
20...19 0 1 2 3
18...16 0 BCF
COPz rt
1 BCT 2 BCFL 3 BCTL 4 5 6 7
2 ... 0 0 5 ... 3 0 1 TLBP 2 3 ERET 0 1 2 3
CP0 Function
1 TLBR 2 TLBWI 3 4 5 6 TLBWR 7
Figure A-2 (cont.) Key: *
R4000 Opcode Bit Encoding
Operation codes marked with an asterisk cause reserved instruction exceptions in all current implementations and are reserved for future versions of the architecture. Operation codes marked with a gamma cause a reserved instruction exception. They are reserved for future versions of the architecture. Operation codes marked with a delta are valid only for R4000 processors with CP0 enabled, and cause a reserved instruction exception on other processors. Operation codes marked with a phi are invalid but do not cause reserved instruction exceptions in R4000 implementations. Operation codes marked with a xi cause a reserved instruction exception on R4000 processors. Operation codes marked with a chi are valid only on R4000. Operation codes marked with epsilon are valid when the processor is operating either in the Kernel mode or in the 64-bit non-Kernel (User or Supervisor) mode. These instructions cause a reserved instruction exception if 64-bit operation is not enabled in User or Supervisor mode.
A-182
FPU Instruction Set Details
This appendix provides a detailed description of each floating-point unit (FPU) instruction (refer to Appendix A for a detailed description of the CPU instructions). The instructions are listed alphabetically, and any exceptions that may occur due to the execution of each instruction are listed after the description of each instruction. Descriptions of the immediate causes and the manner of handling exceptions are omitted from the instruction descriptions in this appendix (refer to Chapter 7 for detailed descriptions of floating-point exceptions and handling). Figure B-3 at the end of this appendix lists the entire bit encoding for the constant fields of the floating-point instruction set; the bit encoding for each instruction is included with that individual instruction.
B-1
Appendix B
B.1 Instruction Formats

There are three basic instruction format types: I-Type, or Immediate instructions, which include load and store operations M-Type, or Move instructions R-Type, or Register instructions, which include the twoand three-register oating-point operations.
The instruction description subsections that follow show how these three basic instruction formats are used by: Load and store instructions Move instructions Floating-Point computational instructions Floating-Point branch instructions
Floating-point instructions are mapped onto the MIPS coprocessor instructions, defining coprocessor unit number one (CP1) as the floatingpoint unit. Each operation is valid only for certain formats. Implementations may support some of these formats and operations through emulation, but they only need to support combinations that are valid (marked V in Table B-1). Combinations marked R in Table B-1 are not currently specified by this architecture, and cause an unimplemented operation trap. They will be available for future extensions to the architecture.
B-2
Table B-1 Operation ADD SUB MUL DIV SQRT ABS MOV NEG TRUNC.L ROUND.L CEIL.L FLOOR.L TRUNC.W ROUND.W CEIL.W FLOOR.W CVT.S CVT.D CVT.W CVT.L C V V V V
Valid FPU Instruction Formats Source Format
Single V V V V V V V V V V V V V V V V
Double V V V V V V V V V V V V V V V V V V V V
Word R R R R R R R
Longword R R R R R R R
V V
V V
B-3
Appendix B
The coprocessor branch on condition true/false instructions can be used to logically negate any predicate. Thus, the 32 possible conditions require only 16 distinct comparisons, as shown in Table B-2 below. Table B-2 Condition Mnemonic True F UN EQ UEQ OLT ULT OLE ULE SF NGLE SEQ NGL LT NGE LE NGT T OR NEQ OGL UGE OGE UGT OGT ST GLE SNE GL NLT GE NLE GT False Code 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Greater Than F F F F F F F F F F F F F F F F Logical Negation of Predicates by Condition True/False Relations Less Than F F F F T T T T F F F F T T T T Equal Unordered F F T T F F T T F F T T F F T T F T F T F T F T F T F T F T F T Invalid Operation Exception If Unordered No No No No No No No No Yes Yes Yes Yes Yes Yes Yes Yes
B-4
Floating-Point Loads, Stores, and Moves

All movement of data between the floating-point coprocessor and memory is accomplished by coprocessor load and store operations, which reference the floating-point coprocessor General Purpose registers. These operations are unformatted; no format conversions are performed and, therefore, no floating-point exceptions can occur due to these operations. Data may also be directly moved between the floating-point coprocessor and the processor by move to coprocessor and move from coprocessor instructions. Like the floating-point load and store operations, move to/ from operations perform no format conversions and never cause floatingpoint exceptions. An additional pair of coprocessor registers are available, called FloatingPoint Control registers for which the only data movement operations supported are moves to and from processor General Purpose registers.
Floating-Point Operations
The floating-point unit operation set includes: floating-point add floating-point subtract floating-point multiply floating-point divide floating-point square root convert between xed-point and oating-point formats convert between oating-point formats oating-point compare
These operations satisfy the requirements of IEEE Standard 754 requirements for accuracy. Specifically, these operations obtain a result which is identical to an infinite-precision result rounded to the specified format, using the current rounding mode. Instructions must specify the format of their operands. Except for conversion functions, mixed-format operations are not provided.
B-5
Appendix B
B.2 Instruction Notation Conventions

In this appendix, all variable subfields in an instruction format (such as fs, ft, immediate, and so on) are shown in lower-case. The instruction name (such as ADD, SUB, and so on) is shown in upper-case. For the sake of clarity, we sometimes use an alias for a variable subfield in the formats of specific instructions. For example, we use rs = base in the format for load and store instructions. Such an alias is always lower case, since it refers to a variable subfield. In some instructions, the instruction subfields op and function can have constant 6-bit values. When reference is made to these instructions, upper-case mnemonics are used. For instance, in the floating-point ADD instruction we use op = COP1 and function = ADD. In other cases, a single field has both fixed and variable subfields, so the name contains both upper and lower case characters. Bit encodings for mnemonics are shown in Figure B-3 at the end of this appendix, and are also included with each individual instruction. In the instruction description examples that follow, the Operation section describes the operation performed by each instruction using a high-level language notation.
Instruction Notation Examples

The following examples illustrate the application of some of the instruction notation conventions: Example #1: GPR[rt] immediate || 016
Sixteen zero bits are concatenated with an immediate value (typically 16 bits), and the 32-bit string (with the lower 16 bits set to zero) is assigned to General Purpose Register rt.
Example #2: (immediate15)16 || immediate15...0

Bit 15 (the sign bit) of an immediate value is extended for 16 bit positions, and the result is concatenated with bits 15 through 0 of the immediate value to form a 32-bit sign extended value.
B-6
B.3 Load and Store Instructions

In the R4000 implementation, the instruction immediately following a load may use the contents of the register being loaded. In such cases, the hardware interlocks, requiring additional real cycles, so scheduling load delay slots is still desirable, although not required for functional code. The behavior of the load store instructions is dependent on the width of the FGRs. When the FR bit in the Status register equals zero, the FloatingPoint General registers (FGRs) are 32-bits wide. When the FR bit in the Status register equals one, the FloatingPoint General registers (FGRs) are 64-bits wide.
In the load and store operation descriptions, the functions listed in Table B-3 are used to summarize the handling of virtual addresses and physical memory. Table B-3 Function AddressTranslation Load and Store Common Functions Meaning Uses the TLB to find the physical address given the virtual address. The function fails and an exception is taken if the required translation is not present in the TLB. Uses the cache and main memory to find the contents of the word containing the specified physical address. The low-order two bits of the address and the Access Type field indicates which of each of the four bytes within the data word need to be returned. If the cache is enabled for this access, the entire word is returned and loaded into the cache. Uses the cache, write buffer, and main memory to store the word or part of word specified as data in the word containing the specified physical address. The low-order two bits of the address and the Access Type field indicates which of each of the four bytes within the data word should be stored.
LoadMemory
StoreMemory
B-7
Appendix B
Figure B-1 shows the I-Type instruction format used by load and store operations. I-Type (Immediate)
31 26 25 21 20 16 15 0
op
6 op base ft
base
5
ft
5
offset
16
is a 6-bit operation code is the 5-bit base register specifier is a 5-bit source (for stores) or destination (for loads) FPA register specifier
offset is the 16-bit signed immediate offset
Figure B-1
Load and Store Instruction Format
All coprocessor loads and stores reference aligned data items. Thus, for word loads and stores, the access type field is always WORD, and the loworder two bits of the address must always be zero. For doubleword loads and stores, the access type field is always DOUBLEWORD, and the low-order three bits of the address must always be zero. Regardless of byte-numbering order (endianness), the address specifies that byte which has the smallest byte-address in the addressed field. For a big-endian machine, this is the leftmost byte; for a little-endian machine, this is the rightmost byte.
B-8
B.4 Computational Instructions

Computational instructions include all of the arithmetic floating-point operations performed by the FPU. Figure B-2 shows the R-Type instruction format used for computational operations.
R-Type (Register)
31 26 25 21 20 16 15 11 10 6 5 0
COP1
6 COP1 fmt fs ft fd function
fmt
5
ft
5
fs
5
fd
5
function
6
is a 6-bit operation code is a 5-bit format specifier is a 5-bit source1 register is a 5-bit source2 register is a 5-bit destination register is a 6-bit function field
Figure B-2
Computational Instruction Format
The function field indicates the floating-point operation to be performed. Each floating-point instruction can be applied to a number of operand formats. The operand format for an instruction is specified by the 5-bit format field; decoding for this field is shown in Table B-4. Table B-4 Code 16 17 18 19 20 21 2231 W L single longword Mnemonic S D Format Field Decoding Format Binary floating-point Binary floating-point Reserved Reserved 32-bit binary fixed-point 64-bit binary fixed-point Reserved
Size single double
Table B-5 lists all floating-point instructions.

MIPS R4000 Microprocessor User's Manual B-9
Appendix B
Table B-5 Code (5: 0) 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1631 32 33 34 35 36 37 3847 4863 Mnemonic ADD SUB MUL DIV SQRT ABS MOV NEG ROUND.L TRUNC.L CEIL.L FLOOR.L ROUND.W TRUNC.W CEIL.W FLOOR.W CVT.S CVT.D CVT.W CVT.L C
Floating-Point Instructions and Operations Operation Add Subtract Multiply Divide Square root Absolute value Move Negate Convert to 64-bit (long) fixed-point, rounded to nearest/ even Convert to 64-bit (long) fixed-point, rounded toward zero Convert to 64-bit (long) xed-point, rounded to + Convert to 64-bit (long) xed-point, rounded to - Convert to single fixed-point, rounded to nearest/even Convert to single fixed-point, rounded toward zero Convert to single fixed-point, rounded to + Convert to single fixed-point, rounded to Reserved Convert to single floating-point Convert to double floating-point Reserved Reserved Convert to 32-bit binary fixed-point Convert to 64-bit (long) binary fixed-point Reserved Floating-point compare
B-10
In the following pages, the notation FGR refers to the 32 General Purpose registers FGR0 through FGR31 of the FPU, and FPR refers to the floatingpoint registers of the FPU. When the FR bit in the Status register (SR(26)) equals zero, only the even oating-point registers are valid and the 32 General Purpose registers of the FPU are 32-bits wide. When the FR bit in the Status register (SR(26)) equals one, both odd and even oating-point registers may be used and the 32 General Purpose registers of the FPU are 64-bits wide.
The following routines are used in the description of the floating-point operations to retrieve the value of an FPR or to change the value of an FGR:
value ValueFPR(fpr,fmt) if SR26 = 1 then /* 64-bit wide FGRs */ case fmt of S, W: value FGR[fpr]31...0 return D, L: value FGR[fpr] return endcase elseif fpr0 = 0 then /* valid specifier, 32-bit wide FGRs */ case fmt of S, W: value FGR[fpr] return D, L: value FGR[fpr+1] || FGR[fpr] return endcase else /* undefined result for odd 32-bit reg #s */ value undefined endif
B-11
Appendix B
StoreFPR(fpr, fmt, value) if SR26 = 1 then /* 64-bit wide FGRs */ case fmt of S, W: FGR[fpr] undefined32 || value return D, L: FGR[fpr] value return endcase elseif fpr0 = 0 then /* valid specifier, 32-bit wide FGRs */ case fmt of S, W: FGR[fpr+1] undefined FGR[fpr] value return D, L: FGR[fpr+1] value63...32 FGR[fpr] value31...0 return endcase else /* undefined result for odd 32-bit reg #s */ undefined_result endif
B-12
ABS.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Absolute Value

21 20 16 15 fs 5 11 10 fd 5
ABS.fmt
6 5 ABS 000101 6 0
0 00000 5
Format:
ABS.fmt fd, fs
Description:
The contents of the FPU register specified by fs are interpreted in the specified format and the arithmetic absolute value is taken. The result is placed in the floating-point register specified by fd. The absolute value operation is arithmetic; a NaN operand signals invalid operation. This instruction is valid only for single- and double-precision floatingpoint formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid.
Operation:
T: StoreFPR(fd, fmt, AbsoluteValue(ValueFPR(fs, fmt)))
Exceptions:
Coprocessor unusable exception Coprocessor exception trap
Coprocessor Exceptions:
Unimplemented operation exception Invalid operation exception
B-13
Appendix B
ADD.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Add
21 20 ft 5 16 15 fs 5 11 10 fd 5
ADD.fmt
6 5 ADD 000000 6 0
Format:
ADD.fmt fd, fs, ft
Description:
The contents of the FPU registers specified by fs and ft are interpreted in the specified format and arithmetically added. The result is rounded as if calculated to infinite precision and then rounded to the specified format (fmt), according to the current rounding mode. The result is placed in the floating-point register (FPR) specified by fd. This instruction is valid only for single- and double-precision floatingpoint formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid.
Operation:
T: StoreFPR (fd, fmt, ValueFPR(fs, fmt) + ValueFPR(ft, fmt))
Exceptions:
Coprocessor unusable exception Floating-Point exception
Unimplemented operation exception Invalid operation exception Inexact exception Overflow exception Underflow exception
B-14 MIPS R4000 Microprocessor User's Manual
BC1F
31 26 25 COP1 010001 6 5
Branch On FPA False (Coprocessor 1)

21 20 16 15 offset 16
BC1F
0
BC 01000
BCF 00000 5
Format:
BC1F offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If the result of the last floating-point compare is false (zero), the program branches to the target address, with a delay of one instruction. There must be at least one instruction between C.cond.fmt and BC1F.
Operation:
32 T1: T: T+1: condition not COC[1] target (offset15)14 || offset || 02 if condition then PC PC + target endif condition not COC[1] target (offset15)46 || offset || 02 if condition then PC PC + target endif
64
T1: T: T+1:
Exceptions:
B-15
Appendix B
BC1FL
31 26 25 COP1 010001 6
Branch On FPU False Likely (Coprocessor 1)

21 20 16 15 offset 16
BC1FL
0
BC 01000 5
BCFL 00010 5
Format:
BC1FL offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If the result of the last floating-point compare is false (zero), the program branches to the target address, with a delay of one instruction. If the conditional branch is not taken, the instruction in the branch delay slot is nullified. There must be at least one instruction between C.cond.fmt and BC1FL.
Operation:
32 T1: T: T+1: condition not COC[1] target (offset15)14 || offset || 02 if condition then PC PC + target else NullifyCurrentInstruction endif condition not COC[1] target (offset15)46 || offset || 02 if condition then PC PC + target else NullifyCurrentInstruction endif
64
T1: T: T+1:
Exceptions:
BC1T
31 26 25 COP1 010001 6
Branch On FPU True (Coprocessor 1)

21 20 16 15 offset 16
BC1T
0
BC 01000 5
BCT 00001 5
Format:
BC1T offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If the result of the last floating-point compare is true (one), the program branches to the target address, with a delay of one instruction. There must be at least one instruction between C.cond.fmt and BC1T.
Operation:
32 T1: T: T+1: condition COC[1] target (offset15)14 || offset || 02 if condition then PC PC + target endif condition COC[1] target (offset15)46 || offset || 02 if condition then PC PC + target endif
64
T1: T: T+1:
Exceptions:
B-17
Appendix B
BC1TL
31 26 25 COP1 010001 6
Branch On FPU True Likely (Coprocessor 1)

21 20 16 15 offset 16
BC1TL
0
BC 01000 5
BCTL 00011 5
Format:
BC1TL offset
Description:
A branch target address is computed from the sum of the address of the instruction in the delay slot and the 16-bit offset, shifted left two bits and sign-extended. If the result of the last floating-point compare is true (one), the program branches to the target address, with a delay of one instruction. If the conditional branch is not taken, the instruction in the branch delay slot is nullified. There must be at least one instruction between C.cond.fmt and BC1TL.
Operation:
32 T1: T: T+1: condition COC[1] target (offset15)14 || offset || 02 if condition then PC PC + target else NullifyCurrentInstruction endif condition COC[1] target (offset15)46 || offset || 02 if condition then PC PC + target else NullifyCurrentInstruction endif
64
T1: T: T+1:
Exceptions:
C.cond.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Compare
21 20 ft 5 16 15 fs 5 11 10
C.cond.fmt
6 5 43 cond* 4 0 0 00000 5 FC* 2
Format:
C.cond.fmt fs, ft
Description:
The contents of the floating-point registers specified by fs and ft are interpreted in the specified format, fmt, and arithmetically compared. A result is determined based on the comparison and the conditions specified in the cond field. If one of the values is a Not a Number (NaN), and the high-order bit of the cond field is set, an invalid operation exception is taken. After a one-instruction delay, the condition is available for testing with branch on floating-point coprocessor condition instructions. There must be at least one instruction between the compare and the branch. Comparisons are exact and can neither overflow nor underflow. Four mutually-exclusive relations are possible results: less than, equal, greater than, and unordered. The last case arises when one or both of the operands are NaN; every NaN compares unordered with everything, including itself. Comparisons ignore the sign of zero, so +0 = 0. This instruction is valid only for single- and double-precision floatingpoint formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid.
*See FPU Instruction Opcode Bit Encoding at the end of Appendix B.

Appendix B
C.cond.fmt
Floating-Point Compare (continued)
C.cond.fmt
Operation:
T: if NaN(ValueFPR(fs, fmt)) or NaN(ValueFPR(ft, fmt)) then less false equal false unordered true if cond3 then signal InvalidOperationException endif else less ValueFPR(fs, fmt) < ValueFPR(ft, fmt) equal ValueFPR(fs, fmt) = ValueFPR(ft, fmt) unordered false endif condition (cond2 and less) or (cond1 and equal) or (cond0 and unordered) FCR[31]23 condition COC[1] condition
Exceptions:
Coprocessor unusable Floating-Point exception
B-20
CEIL.L.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Ceiling to Long Fixed-Point Format

21 20 16 15 fs 5 11 10
CEIL.L.fmt
6 5 fd 5 CEIL.L 001010 6 0
0 00000 5
Format:
CEIL.L.fmt fd, fs
Description:
The contents of the floating-point register specified by fs are interpreted in the specified source format, fmt, and arithmetically converted to the long fixed-point format. The result is placed in the floating-point register specified by fd. Regardless of the setting of the current rounding mode, the conversion is rounded as if the current rounding mode is round to + (2). This instruction is valid only for conversion from single- or doubleprecision floating-point formats. When the FR bit in the Status register equals one, both even and odd register numbers are valid. When the source operand is an Infinity, NaN, or the correctly rounded integer result is outside of 263 to 263 1, the Invalid operation exception is raised. If the Invalid operation is not enabled then no exception is taken and 2631 is returned.
B-21
Appendix B
CEIL.L.fmt
Floating-Point Ceiling to Long Fixed-Point Format (continued)
CEIL.L.fmt
Operation:
T: StoreFPR(fd, L, ConvertFmt(ValueFPR(fs, fmt), fmt, L))
Exceptions:
Invalid operation exception Unimplemented operation exception Inexact exception Overflow exception
B-22
CEIL.W.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Ceiling to Single Fixed-Point Format

21 20 16 15 fs 5 11 10
CEIL.W.fmt
6 5 fd 5 CEIL.W 001110 6 0
0 00000 5
Format:
CEIL.W.fmt fd, fs
Description:
The contents of the floating-point register specified by fs are interpreted in the specified source format, fmt, and arithmetically converted to the single fixed-point format. The result is placed in the floating-point register specified by fd. Regardless of the setting of the current rounding mode, the conversion is rounded as if the current rounding mode is round to + (2). This instruction is valid only for conversion from a single- or doubleprecision floating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid. When the source operand is an Infinity or NaN, or the correctly rounded integer result is outside of 231 to 231 1, the Invalid operation exception is raised. If the Invalid operation is not enabled then no exception is taken and 2311 is returned.
B-23
Appendix B
CEIL.W.fmt
Floating-Point Ceiling to Single Fixed-Point Format (continued)
CEIL.W.fmt
Operation:
T: StoreFPR(fd, W, ConvertFmt(ValueFPR(fs, fmt), fmt, W))
Exceptions:
B-24
CFC1
31 26 25 COP1 010001 6
Move Control Word From FPU (Coprocessor 1)

21 20 rt 5 16 15 fs 5 11 10
CFC1
0
CF 00010 5
0 000 0000 0000 11
Format:
CFC1 rt, fs
Description:
The contents of the FPU control register fs are loaded into general register rt. This operation is only defined when fs equals 0 or 31. The contents of general register rt are undefined for the instruction immediately following CFC1.
Operation:
32 64 T: temp FCR[fs] T+1: GPR[rt] temp T: temp FCR[fs] T+1: GPR[rt] (temp31)32 || temp
Exceptions:
B-25
Appendix B
CTC1
31 26 25 COP1 010001 6
Move Control Word To FPU (Coprocessor 1)

21 20 rt 5 16 15 fs 5 11 10
CTC1
0
CT 00110 5
0 000 0000 0000 11
Format:
CTC1 rt, fs
Description:
The contents of general register rt are loaded into FPU control register fs. This operation is only defined when fs equals 0 or 31. Writing to Control Register 31, the floating-point Control/Status register, causes an interrupt or exception if any cause bit and its corresponding enable bit are both set. The register will be written before the exception occurs. The contents of floating-point control register fs are undefined for the instruction immediately following CTC1.
Operation:
32 T: T+1: T: T+1: temp GPR[rt] FCR[fs] temp COC[1] FCR[31]23 temp GPR[rt]31...0 FCR[fs] temp COC[1] FCR[31]23
64
Exceptions:
Unimplemented operation exception Invalid operation exception Division by zero exception Inexact exception Overflow exception Underflow exception
CVT.D.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Convert to Double Floating-Point Format

21 20 16 15 fs 5 11 10
CVT.D.fmt
6 5 fd 5 CVT.D 100001 6 0
0 00000 5
Format:
CVT.D.fmt fd, fs
Description:
The contents of the floating-point register specified by fs is interpreted in the specified source format, fmt, and arithmetically converted to the double binary floating-point format. The result is placed in the floatingpoint register specified by fd. This instruction is valid only for conversions from single floating-point format, 32-bit or 64-bit fixed-point format. If the single floating-point or single fixed-point format is specified, the operation is exact. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid.
Operation:
T: StoreFPR (fd, D, ConvertFmt(ValueFPR(fs, fmt), fmt, D))
Exceptions:
Invalid operation exception Unimplemented operation exception Inexact exception Overflow exception Underflow exception
Appendix B
CVT.L.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Convert to Long Fixed-Point Format

21 20 16 15 fs 5 11 10 fd 5
CVT.L.fmt
6 5 CVT.L 100101 6 0
0 00000 5
Format:
CVT.L.fmt fd, fs
Description:
The contents of the floating-point register specified by fs are interpreted in the specified source format, fmt, and arithmetically converted to the long fixed-point format. The result is placed in the floating-point register specified by fd. This instruction is valid only for conversions from singleor double-precision oating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero. When the source operand is an Infinity, NaN, or the correctly rounded integer result is outside of 263 to 2631, the Invalid operation exception is raised. If the Invalid operation is not enabled then no exception is taken and 2631 is returned.
Operation:
T: StoreFPR (fd, L, ConvertFmt(ValueFPR(fs, fmt), fmt, L))
Exceptions:
CVT.S.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Convert to Single Floating-Point Format

21 20 16 15 fs 5 11 10 fd 5
CVT.S.fmt
6 5 CVT.S 100000 6 0
0 00000 5
Format:
CVT.S.fmt fd, fs
Description:
The contents of the floating-point register specified by fs are interpreted in the specified source format, fmt, and arithmetically converted to the single binary floating-point format. The result is placed in the floating-point register specified by fd. Rounding occurs according to the currently specified rounding mode. This instruction is valid only for conversions from double oating-point format, or from 32-bit or 64-bit xed-point format. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid.
Operation:
T: StoreFPR(fd, S, ConvertFmt(ValueFPR(fs, fmt), fmt, S))
Exceptions:
Invalid operation exception Unimplemented operation exception Inexact exception Overflow exception Underflow exception
B-29
Appendix B
CVT.W.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Convert to Fixed-Point Format

21 20 16 15 fs 5 11 10 fd 5
CVT.W.fmt
6 5 CVT.W 100100 6 0
0 00000 5
Format:
CVT.W.fmt fd, fs
Description:
The contents of the floating-point register specified by fs are interpreted in the specified source format, fmt, and arithmetically converted to the single fixed-point format. The result is placed in the floating-point register specified by fd. This instruction is valid only for conversion from a singleor double-precision floating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid. When the source operand is an Infinity or NaN, or the correctly rounded integer result is outside of 231 to 2311, an Invalid operation exception is raised. If Invalid operation is not enabled, then no exception is taken and 231 1 is returned.
Operation:
Exceptions:
DIV.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Divide
21 20 ft 5 16 15 fs 5 11 10 fd 5
DIV.fmt
6 5 DIV 000011 6 0
Format:
DIV.fmt fd, fs, ft
Description:
The contents of the floating-point registers specified by fs and ft are interpreted in the specified format and the value in the fs field is divided by the value in the ft field. The result is rounded as if calculated to infinite precision and then rounded to the specified format, according to the current rounding mode. The result is placed in the floating-point register specified by fd. This instruction is valid for only single or double precision floating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid.
Operation:
T: StoreFPR (fd, fmt, ValueFPR(fs, fmt)/ValueFPR(ft, fmt))
Exceptions:
Unimplemented operation exception Division-by-zero exception Overflow exception Invalid operation exception Inexact exception Underflow exception
B-31
Appendix B
DMFC1
31 26 25 COP1 010001 6
Doubleword Move From Floating-Point Coprocessor

21 20 rt 5 16 15 fs 5 11 10
DMFC1
0
DMF 00001 5
0 0 0 0 0 0 0 0 0 0 00 11
Format:
DMFC1 rt, fs
Description:
The contents of register fs from the floating-point coprocessor is stored into processor register rt. The contents of general register rt are undefined for the instruction immediately following DMFC1. The FR bit in the Status register specifies whether all 32 registers of the R4000 are addressable. When FR equals zero, this instruction is not defined when the least significant bit of fs is non-zero. When FR is set, fs may specify either odd or even registers.
Operation:
64 T: if SR26 = 1 then /* 64-bit wide FGRs */ data FGR[fs] elseif fs0 = 0 then /* valid specifier, 32-bit wide FGRs */ data FGR[fs+1] || FGR[fs] else /* undefined for odd 32-bit reg #s */ data undefined64 endif GPR[rt] data
T+1:
Exceptions:
Unimplemented operation exception
B-32
DMTC1
31 26 25 COP1 010001 6
Doubleword Move To Floating-Point Coprocessor

21 20 rt 5 16 15 fs 5 11 10
DMTC1
0
DMT 00101 5
0 0 0 0 0 0 0 0 0 0 00 11
Format:
DMTC1 rt, fs
Description:
The contents of general register rt are loaded into coprocessor register fs of the CP1. The contents of floating-point register fs are undefined for the instruction immediately following DMTC1. The FR bit in the Status register specifies whether all 32 registers of the R4000 are addressable. When FR equals zero, this instruction is not defined when the least significant bit of fs is non-zero. When FR equals one, fs may specify either odd or even registers.
Operation:
64 T: T+1: data GPR[rt] if SR26 = 1 then /* 64-bit wide FGRs */ FGR[fs] data elseif fs0 = 0 then /*valid specifier, 32-bit wide valid FGRs */ FGR[fs+1] data63...32 FGR[fs] data31...0 else /* undefined result for odd 32-bit reg #s */ undefined_result endif
Exceptions:
Appendix B
FLOOR.L.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Floor to Long Fixed-Point Format

16 15 fs 5
FLOOR.L.fmt
6 5 fd 5 FLOOR.L 001011 6 0
21 20
11 10
0 00000 5
Format:
FLOOR.L.fmt fd, fs
Description:
The contents of the floating-point register specified by fs are interpreted in the specified source format, fmt, and arithmetically converted to the long fixed-point format. The result is placed in the floating-point register specified by fd. Regardless of the setting of the current rounding mode, the conversion is rounded as if the current rounding mode is round to - (3). This instruction is valid only for conversion from single- or doubleprecision floating-point formats. When the source operand is an Infinity, NaN, or the correctly rounded integer result is outside of 263 to 263 1, the Invalid operation exception is raised. If the Invalid operation is not enabled then no exception is taken and 2631 is returned.
B-34
FLOOR.L.fmt
Floating-Point Floor to Long Fixed-Point Format (continued)
FLOOR.L.fmt
Operation:
Exceptions:
B-35
Appendix B
FLOOR.W.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Floor to Single Fixed-Point Format

16 15 fs 5
FLOOR.W.fmt
6 5 fd 5 FLOOR.W 001111 6 0
21 20
11 10
0 00000 5
Format:
FLOOR.W.fmt fd, fs
Description:
The contents of the floating-point register specified by fs are interpreted in the specified source format, fmt, and arithmetically converted to the single fixed-point format. The result is placed in the floating-point register specified by fd. Regardless of the setting of the current rounding mode, the conversion is rounded as if the current rounding mode is round to (RM = 3). This instruction is valid only for conversion from a single- or doubleprecision floating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid. When the source operand is an Infinity or NaN, or the correctly rounded integer result is outside of 231 to 2311, an Invalid operation exception is raised. If Invalid operation is not enabled, then no exception is taken and 2311 is returned.
B-36
FLOOR.W.fmt
Floating-Point Floor to Single Fixed-Point Format (continued)
FLOOR.W.fmt
Operation:
Exceptions:
B-37
Appendix B
LDC1
31 26 25 LDC1 110101 6
Load Doubleword to FPU (Coprocessor 1)

21 20 base 5 ft 5 16 15 offset 16
LDC1
0
Format:
LDC1 ft, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form an unsigned effective address. In 32-bit mode, the contents of the doubleword at the memory location specied by the effective address is loaded into registers ft and ft+1 of the oating-point coprocessor. This instruction is not valid, and is undened, when the least signicant bit of ft is non-zero. In 64-bit mode, the contents of the doubleword at the memory location specied by the effective address are loaded into the 64-bit register ft of the oating point coprocessor. The FR bit of the Status register (SR26) species whether all 32 registers of the R4000 are addressable. If FR equals zero, this instruction is not dened when the least signicant bit of ft is non-zero. If FR equals one, ft may specify either odd or even registers. If any of the three least-significant bits of the effective address are nonzero, an address error exception takes place.
B-38
LDC1
Operation:
32 64 32, 64 T: T:
Load Doubleword to FPU (Coprocessor 1) (continued)
LDC1
vAddr ((offset15)16 || offset15...0) + GPR[base] vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) data LoadMemory(uncached, DOUBLEWORD, pAddr, vAddr, DATA) if SR26 = 1 then /* 64-bit wide FGRs */ FGR[ft] data elseif ft0 = 0 then /* valid specifier, 32-bit wide FGRs */ FGR[ft+1] data63...32 FGR[ft] data31...0 else /* undefined result if odd */ undefined_result endif
Exceptions:
Coprocessor unusable TLB refill exception TLB invalid exception Bus error exception Address error exception
B-39
Appendix B
LWC1
31 26 25 LWC1 110001 6 base 5
Load Word to FPU (Coprocessor 1)

21 20 ft 5 16 15 offset 16
LWC1
0
Format:
LWC1 ft, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form an unsigned effective address. The contents of the word at the memory location specified by the effective address is loaded into register ft of the floating-point coprocessor. The FR bit of the Status register specifies whether all 64-bit Floating-Point registers are addressable. If FR equals zero, LWC1 loads either the high or low half of the 16 even Floating-Point registers. If FR equals one, LWC1 loads the low 32-bits of both even and odd Floating-Point registers. If either of the two least-significant bits of the effective address is non-zero, an address error exception occurs.
B-40
LWC1
Operation:
32 64 32, 64 T: T:
Load Word to FPU (Coprocessor 1) (continued)
LWC1
vAddr ((offset15)16 || offset15...0) + GPR[base] vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02)) mem LoadMemory(uncached, WORD, pAddr, vAddr, DATA) byte vAddr2...0 xor (BigEndianCPU || 02) /* mem is aligned 64-bits from memory. Pick out correct bytes. */ if SR26 = 1 then /* 64-bit wide FGRs */ FGR[ft] undefined32 || mem31+8*byte...8*byte else /* 32-bit wide FGRs */ FGR[ft] mem31+8*byte...8*byte endif
Exceptions:
Coprocessor unusable TLB refill exception TLB invalid exception Bus error exception Address error exception
B-41
Appendix B
MFC1
31 26 25 COP1 010001 6 MF 00000 5
Move From FPU (Coprocessor 1)

21 20 rt 5 16 15 fs 5 11 10
MFC1
0 0 000 0000 0000 11
Format:
MFC1 rt, fs
Description:
The contents of register fs from the floating-point coprocessor are stored into processor register rt. The contents of register rt are undefined for the instruction immediately following MFC1. The FR bit of the Status register specifies whether all 32 registers of the R4000 are addressable. If FR equals zero, MFC1 stores either the high or low half of the 16 even Floating-Point registers. If FR equals one, MFC1 stores the low 32-bits of both even and odd Floating-Point registers.
Operation:
32 T: T+1: T: T+1: data FGR[fs]31...0 GPR[rt] data data FGR[fs]31...0 GPR[rt] (data31)32 || data
64
Exceptions:
B-42
MOV.fmt
31 26 25 fmt 5 COP1 010001 6
Floating-Point Move
21 20 16 15 fs 5 11 10 fd 5
MOV.fmt
6 5 MOV 000110 6 0
0 00000 5
Format:
MOV.fmt fd, fs
Description:
The contents of the FPU register specified by fs are interpreted in the specified format and are copied into the FPU register specified by fd. The move operation is non-arithmetic; no IEEE 754 exceptions occur as a result of the instruction. This instruction is valid only for single- or double-precision floating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid.
Operation:
T: StoreFPR(fd, fmt, ValueFPR(fs, fmt))
Exceptions:
B-43
Appendix B
MTC1
31 26 25 COP1 010001 6 MT 00100 5
Move To FPU (Coprocessor 1)

21 20 rt 5 16 15 fs 5 11 10
MTC1
0 0 000 0000 0000 11
Format:
MTC1 rt, fs
Description:
The contents of register rt are loaded into the FPU general register at location fs. The contents of floating-point register fs is undefined for the instruction immediately following MTC1. The FR bit of the Status register specifies whether all 32 registers of the R4000 are addressable. If FR equals zero, MTC1 loads either the high or low half of the 16 even Floating-Point registers. If FR equals one, MTC1 loads the low 32-bits of both even and odd Floating-Point registers.
Operation:
32,64 T: T+1: data GPR[rt]31...0 if SR26 = 1 then /* 64-bit wide FGRs */ FGR[fs] undefined32 || data else /* 32-bit wide FGRs */ FGR[fs] data endif
Exceptions:
B-44
MUL.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Multiply
21 20 ft 5 16 15 fs 5 11 10 fd 5
MUL.fmt
6 5 MUL 000010 6 0
Format:
MUL.fmt fd, fs, ft
Description:
The contents of the floating-point registers specified by fs and ft are interpreted in the specified format and arithmetically multiplied. The result is rounded as if calculated to infinite precision and then rounded to the specified format, according to the current rounding mode. The result is placed in the floating-point register specified by fd. This instruction is valid only for single- or double-precision floating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid.
Operation:
T: StoreFPR (fd, fmt, ValueFPR(fs, fmt) * ValueFPR(ft, fmt))
Exceptions:
Appendix B
NEG.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Negate
21 20 16 15 fs 5 11 10 fd 5
NEG.fmt
6 5 NEG 000111 6 0
0 00000 5
Format:
NEG.fmt fd, fs
Description:
The contents of the FPU register specified by fs are interpreted in the specified format and the arithmetic negation is taken (polarity of the signbit is changed). The result is placed in the FPU register specified by fd. The negate operation is arithmetic; an NaN operand signals invalid operation. This instruction is valid only for single- or double-precision floating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid.
Operation:
T: StoreFPR(fd, fmt, Negate(ValueFPR(fs, fmt)))
Exceptions:
B-46
ROUND.L.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Round to Long Fixed-Point Format

16 15 fs 5
ROUND.L.fmt
6 5 fd 5 ROUND.L 001000 6 0
21 20
11 10
0 00000 5
Format:
ROUND.L.fmt fd, fs
Description:
The contents of the floating-point register specified by fs are interpreted in the specified source format, fmt, and arithmetically converted to the long fixed-point format. The result is placed in the floating-point register specified by fd. Regardless of the setting of the current rounding mode, the conversion is rounded as if the current rounding mode is round to nearest/even (0). This instruction is valid only for conversion from single- or doubleprecision floating-point formats. When the source operand is an Infinity, NaN, or the correctly rounded integer result is outside of 263 to 263 1, the Invalid operation exception is raised. If the Invalid operation is not enabled then no exception is taken and 263 1 is returned.
B-47
Appendix B
ROUND.L.fmt
Floating-Point Round to Long Fixed-Point Format (continued)
ROUND.L.fmt
Operation:
Exceptions:
B-48
Floating-Point ROUND.W.fmt Round ROUND.W.fmt to Single Fixed-Point Format

31 COP1 010001 6 26 25 fmt 5 21 20 16 15 fs 5 11 10 fd 5 6 5 ROUND.W 001100 6 0
0 00000 5
Format:
ROUND.W.fmt fd, fs
Description:
The contents of the floating-point register specified by fs are interpreted in the specified source format, fmt, and arithmetically converted to the single fixed-point format. The result is placed in the floating-point register specified by fd. Regardless of the setting of the current rounding mode, the conversion is rounded as if the current rounding mode is round to the nearest/even (RM = 0). This instruction is valid only for conversion from a single- or doubleprecision floating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid. When the source operand is an Infinity or NaN, or the correctly rounded integer result is outside of 231 to 231 1, an Invalid operation exception is raised. If Invalid operation is not enabled, then no exception is taken and 231 1 is returned.
B-49
Appendix B
Floating-Point ROUND.W.fmt Round ROUND.W.fmt to Single Fixed-Point Format (continued)
Operation:
Exceptions:
B-50
SDC1
31 26 25 SDC1 111101 6
Store Doubleword from FPU (Coprocessor 1)

21 20 base 5 ft 5 16 15 offset 16
SDC1
0
Format:
SDC1 ft, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form an unsigned effective address. In 32-bit mode, the contents of registers ft and ft+1 from the oating-point coprocessor are stored at the memory location specied by the effective address. This instruction is not valid, and is undened, when the least signicant bit of ft is non-zero. In 64-bit mode, the 64-bit register ft is stored to the contents of the doubleword at the memory location specified by the effective address. The FR bit of the Status register (SR26) specifies whether all 32 registers of the R4000 are addressable. When FR equals zero, this instruction is not defined if the least significant bit of ft is non-zero. If FR equals one, ft may specify either odd or even registers. If any of the three least-significant bits of the effective address are nonzero, an address error exception takes place.
B-51
Appendix B
SDC1
Operation:
32 64 32,64 T: T:
Store Doubleword from FPU (Coprocessor 1) (continued)
SDC1
vAddr (offset15)16 || offset15...0) + GPR[base] vAddr (offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) if SR26 = 1 /* 64-bit wide FGRs */ data FGR[ft] elseif ft0 = 0 then /* valid specifier, 32-bit wide FGRs */ data FGR[ft+1] || FGR[ft] else /* undefined for odd 32-bit reg #s */ data undefined64 endif StoreMemory(uncached, DOUBLEWORD, data, pAddr, vAddr, DATA)
Exceptions:
Coprocessor unusable TLB refill exception TLB invalid exception TLB modification exception Bus error exception Address error exception
B-52
SQRT.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Square Root

21 20 16 15 fs 5 11 10 fd 5
SQRT.fmt
6 5 SQRT 000100 6 0
0 00000 5
Format:
SQRT.fmt fd, fs
Description:
The contents of the floating-point register specified by fs are interpreted in the specified format and the positive arithmetic square root is taken. The result is rounded as if calculated to infinite precision and then rounded to the specified format, according to the current rounding mode. If the value of fs corresponds to 0, the result will be 0. The result is placed in the floating-point register specified by fd. This instruction is valid only for single- or double-precision floating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid.
Operation:
T: StoreFPR(fd, fmt, SquareRoot(ValueFPR(fs, fmt)))
Exceptions:
Unimplemented operation exception Invalid operation exception Inexact exception
B-53
Appendix B
SUB.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Subtract
21 20 ft 5 16 15 fs 5 11 10 fd 5
SUB.fmt
6 5 SUB 000001 6 0
Format:
SUB.fmt fd, fs, ft
Description:
The contents of the floating-point registers specified by fs and ft are interpreted in the specified format and the value in the ft field is subtracted from the value in the fs field. The result is rounded as if calculated to infinite precision and then rounded to the specified format, according to the current rounding mode. The result is placed in the floating-point register specified by fd. This instruction is valid only for single- or doubleprecision floating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid.
Operation:
T: StoreFPR (fd, fmt, ValueFPR(fs, fmt) ValueFPR(ft, fmt))
Exceptions:
B-54
SWC1
31 26 25 SWC1 111001 6 base 5
Store Word from FPU (Coprocessor 1)

21 20 ft 5 16 15 offset 16
SWC1
0
Format:
SWC1 ft, offset(base)
Description:
The 16-bit offset is sign-extended and added to the contents of general register base to form an unsigned effective address. The contents of register ft from the floating-point coprocessor are stored at the memory location specified by the effective address. The FR bit of the Status register specifies whether all 64-bit floating-point registers are addressable. If FR equals zero, SWC1 stores either the high or low half of the 16 even floating-point registers. If FR equals one, SWC1 stores the low 32-bits of both even and odd floating-point registers. If either of the two least-significant bits of the effective address are nonzero, an address error exception occurs.
B-55
Appendix B
SWC1
Operation:
32 64 32, 64 T: T:
Store Word from FPU (Coprocessor 1) (continued)
SWC1
vAddr ((offset15)16 || offset15...0) + GPR[base] vAddr ((offset15)48 || offset15...0) + GPR[base] (pAddr, uncached) AddressTranslation (vAddr, DATA) pAddr pAddrPSIZE-1...3 || (pAddr2...0 xor (ReverseEndian || 02)) byte vAddr2...0 xor (BigEndianCPU || 02) /* the bytes of the word are put in the correct byte lanes in * data for a 64-bit path to memory */ if SR26 = 1 then /* 64-bit wide FGRs */ data FGR[ft]63-8*byte...0 || 08*byte else /* 32-bit wide FGRs */ data 032-8*byte || FGR[ft] || 08*byte endif StoreMemory (uncached, WORD, data, pAddr, vAddr, DATA)
Exceptions:
Coprocessor unusable TLB refill exception TLB invalid exception TLB modification exception Bus error exception Address error exception
B-56
TRUNC.L.fmt
31 COP1 010001 6 26 25 fmt 5
Floating-Point Truncate to Long Fixed-Point Format

16 15 fs 5
TRUNC.L.fmt
6 5 fd 5 TRUNC.L 0 0 1 0 01 6 0
21 20
11 10
0 00000 5
Format:
TRUNC.L.fmt fd, fs
Description:
The contents of the floating-point register specified by fs are interpreted in the specified source format, fmt, and arithmetically converted to the long fixed-point format. The result is placed in the floating-point register specified by fd. Regardless of the setting of the current rounding mode, the conversion is rounded as if the current rounding mode is round toward zero (1). This instruction is valid only for conversion from single- or doubleprecision floating-point formats. When the source operand is an Infinity, NaN, or the correctly rounded integer result is outside of 263 to 2631, the Invalid operation exception is raised. If the Invalid operation is not enabled then no exception is taken and 2631 is returned.
B-57
Appendix B
TRUNC.L.fmt
Floating-Point Truncate to Long Fixed-Point Format (continued)
TRUNC.L.fmt
Operation:
Exceptions:
B-58
Floating-Point TRUNC.W.fmt Truncate to Single TRUNC.W.fmt Fixed-Point Format

31 COP1 010001 6 26 25 fmt 5 21 20 16 15 fs 5 11 10 fd 5 6 5 TRUNC.W 001101 6 0
0 00000 5
Format:
TRUNC.W.fmt fd, fs
Description:
The contents of the FPU register specified by fs are interpreted in the specified source format fmt and arithmetically converted to the single fixed-point format. The result is placed in the FPU register specified by fd. Regardless of the setting of the current rounding mode, the conversion is rounded as if the current rounding mode is round toward zero (RM = 1). This instruction is valid only for conversion from a single- or doubleprecision floating-point formats. The operation is not defined if bit 0 of any register specification is set and the FR bit in the Status register equals zero, since the register numbers specify an even-odd pair of adjacent coprocessor general registers. When the FR bit in the Status register equals one, both even and odd register numbers are valid. When the source operand is an Infinity or NaN, or the correctly rounded integer result is outside of 231 to 2311, an Invalid operation exception is raised. If Invalid operation is not enabled, then no exception is taken and 231 is returned.
B-59
Appendix B
Floating-Point TRUNC.W.fmt TRUNC.W.fmt Truncate to Single Fixed-Point Format (continued)
Operation:
Exceptions:
B-60
FPU Instruction Opcode Bit Encoding
31...29 0 1 2 3 4 5 6 7
28...26 0
Opcode 1 2 3 4 5 6 7
COP1
LWC1 SWC1
LDC1 SDC1
23...21 25...24 0 MF 0 1 BC S 2 3
sub 1 DMF D 2 CF 3 4 MT W 5 DMT L 6 CT 7
18...16 20...19 0 0 BCF 1 2 3
br 1 BCT 2 BCFL 3 BCTL 4 5 6 7
Figure B-3
Bit Encoding for FPU Instructions
B-61
Appendix B
5...3 0 1 2 3 4 5 6 7
2 MUL ROUND.L TRUNC.L CEIL.L CVT.S C.F C.SF CVT.D C.UN C.EQ C.NGLE C.SEQ
2...0 0 ADD
1 SUB
function 3 4 DIV SQRT FLOOR.L ROUND.W C.UEQ C.NGL CVT.W C.OLT C.LT
5 ABS
TRUNC.W
6 MOV
CEIL.W
7 NEG
FLOOR.W
CVT.L C.ULT C.NGE
C.OLE C.LE
C.ULE C.NGT
Figure B-3 (cont.) Key:
Bit Encoding for FPU Instructions
Operation codes marked with a gamma cause a reserved instruction exception. They are reserved for future versions of the architecture. Operation codes marked with a delta cause unimplemented operation exceptions in all current implementations and are reserved for future versions of the architecture. Operation codes marked with an eta are valid only when MIPS III instructions are enabled. Any attempt to execute these without MIPS III instructions enabled causes an unimplemented operation exception.
B-62

CPU Instruction Set Details

Uploaded by

Copyright:

Available Formats

CPU Instruction Set Details

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CPU Instruction Set Details

Uploaded by

Copyright:

Available Formats

CPU Instruction Set Details

MIPS R4000 Microprocessor User's Manual

A.1 Instruction Classes

MIPS R4000 Microprocessor User's Manual