RISC-V Complete Documentation

Addition: set t1 to (t2 plus t3)

Add unsigned word : Set t1 to the low 32 bits of t2, zero extended, plus t3. Adds an unsigned 32 bit index to a 64 bit base without a separate zero extension (64bit)

Addition immediate: set t1 to (t2 plus signed 12-bit immediate)

Load Lower Address : Set t1 to t2 + lower 12-bit label's address

Addition immediate: set t1 to (t2 plus signed 12-bit immediate) using only the lower 32 bits (64bit)

Addition: set t1 to (t2 plus t3) using only the lower 32 bits (64bit)

Atomic add : Set t1 to the double word at the address in t3, and store that value plus t2 there. Useful for a shared counter that several agents increment (64bit)

Atomic add : Set t1 to the word at the address in t3, and store that value plus t2 there. Useful for a shared counter that several agents increment

Atomic and : Set t1 to the double word at the address in t3, and store the bitwise AND of that value and t2 there. Clears a bit mask in shared memory (64bit)

Atomic and : Set t1 to the word at the address in t3, and store the bitwise AND of that value and t2 there. Clears a bit mask in shared memory

Atomic maximum (signed) : Set t1 to the double word at the address in t3, and store the larger of that value and t2 there, comparing as signed (64bit)

Atomic maximum (signed) : Set t1 to the word at the address in t3, and store the larger of that value and t2 there, comparing as signed

Atomic maximum (unsigned) : Set t1 to the double word at the address in t3, and store the larger of that value and t2 there, comparing as unsigned (64bit)

Atomic maximum (unsigned) : Set t1 to the word at the address in t3, and store the larger of that value and t2 there, comparing as unsigned

Atomic minimum (signed) : Set t1 to the double word at the address in t3, and store the smaller of that value and t2 there, comparing as signed (64bit)

Atomic minimum (signed) : Set t1 to the word at the address in t3, and store the smaller of that value and t2 there, comparing as signed

Atomic minimum (unsigned) : Set t1 to the double word at the address in t3, and store the smaller of that value and t2 there, comparing as unsigned (64bit)

Atomic minimum (unsigned) : Set t1 to the word at the address in t3, and store the smaller of that value and t2 there, comparing as unsigned

Atomic or : Set t1 to the double word at the address in t3, and store the bitwise OR of that value and t2 there. Sets a bit mask in shared memory (64bit)

Atomic or : Set t1 to the word at the address in t3, and store the bitwise OR of that value and t2 there. Sets a bit mask in shared memory

Atomic swap : Set t1 to the double word at the address in t3, and store t2 there. The exchange is indivisible, which makes this the natural way to implement a spinlock (64bit)

Atomic swap : Set t1 to the word at the address in t3, and store t2 there. The exchange is indivisible, which makes this the natural way to implement a spinlock

Atomic xor : Set t1 to the double word at the address in t3, and store the bitwise XOR of that value and t2 there (64bit)

Atomic xor : Set t1 to the word at the address in t3, and store the bitwise XOR of that value and t2 there

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

Bitwise AND immediate : Set t1 to bitwise AND of t2 and sign-extended 12-bit immediate

AND with inverted operand : Set t1 to the bitwise AND of t2 and the bitwise NOT of t3. Clears in t2 every bit that is set in t3

Add upper immediate to pc: set t1 to (pc plus an upper 20-bit immediate)

Branch : Branch to statement at label unconditionally

Clear bit : Set t1 to t2 with the single bit numbered by the low bits of t3 cleared

Clear bit by immediate : Set t1 to t2 with the single bit numbered by the immediate cleared

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

Branch if EQual Zero : Branch to statement at label if t1 == 0

Extract bit : Set t1 to the single bit of t2 numbered by the low bits of t3, as 0 or 1

Extract bit by immediate : Set t1 to the single bit of t2 numbered by the immediate, as 0 or 1

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

Branch if greater than or equal to (unsigned): Branch to statement at label's address if t1 is greater than or equal to t2 (with an unsigned interpretation)

Branch if Greater than or Equal to Zero : Branch to statement at label if t1 >= 0

Branch if Greater Than : Branch to statement at label if t1 > t2

Branch if Greater Than Unsigned: Branch to statement at label if t1 > t2 (unsigned compare)

Branch if Greater Than Zero: Branch to statement at label if t1 > 0

Invert bit : Set t1 to t2 with the single bit numbered by the low bits of t3 flipped

Invert bit by immediate : Set t1 to t2 with the single bit numbered by the immediate flipped

Branch if Less or Equal : Branch to statement at label if t1 <= t2

Branch if Less or Equal Unsigned : Branch to statement at label if t1 <= t2 (unsigned compare)

Branch if Less than or Equal to Zero : Branch to statement at label if t1 <= 0

Branch if less than: Branch to statement at label's address if t1 is less than t2

Branch if less than (unsigned): Branch to statement at label's address if t1 is less than t2 (with an unsigned interpretation)

Branch if Less Than Zero : Branch to statement at label if t1 < 0

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

Branch if Not Equal Zero : Branch to statement at label if t1 != 0

Set bit : Set t1 to t2 with the single bit numbered by the low bits of t3 set

Set bit by immediate : Set t1 to t2 with the single bit numbered by the immediate set

CALL: call a far-away subroutine

Count leading zeros : Set t1 to the number of 0 bits above the most significant 1 bit of t2, which is the full register width when t2 is zero

Count leading zeros (32 bit) : Set t1 to the number of 0 bits above the most significant 1 bit of the low 32 bits of t2, which is 32 when they are zero (64bit)

Count set bits : Set t1 to the number of 1 bits in t2, also known as the population count

Count set bits (32 bit) : Set t1 to the number of 1 bits in the low 32 bits of t2 (64bit)

Clear bits in control and status register

Clear bits in control and status register

Read control and status register

Atomic Read/Clear CSR: read from the CSR into t0 and clear bits of the CSR according to t1

Atomic Read/Clear CSR Immediate: read from the CSR into t0 and clear bits of the CSR according to a constant

Atomic Read/Set CSR: read from the CSR into t0 and logical or t1 into the CSR

Atomic Read/Set CSR Immediate: read from the CSR into t0 and logical or a constant into the CSR

Atomic Read/Write CSR: read from the CSR into t0 and write t1 into the CSR

Atomic Read/Write CSR Immediate: read from the CSR into t0 and write a constant into the CSR

Set bits in control and status register

Set bits in control and status register

Write control and status register

Write control and status register

Count trailing zeros : Set t1 to the number of 0 bits below the least significant 1 bit of t2, which is the full register width when t2 is zero

Count trailing zeros (32 bit) : Set t1 to the number of 0 bits below the least significant 1 bit of the low 32 bits of t2, which is 32 when they are zero (64bit)

Division: set t1 to the result of t2/t3

Division: set t1 to the result of t2/t3 using unsigned division

Division: set t1 to the result of t2/t3 using unsigned division limited to 32 bits (64bit)

Division: set t1 to the result of t2/t3 using only the lower 32 bits (64bit)

Pause execution

Issue a system call : Execute the system call specified by value in a7

Set f1 to the absolute value of f2 (64 bit)

Set f1 to the absolute value of f2

Floating ADD (64 bit): assigns f1 to f2 + f3

Floating ADD: assigns f1 to f2 + f3

Classify a floating point number (64 bit)

Classify a floating point number

Convert double from long: Assigns the value of t1 to f1 (64bit)

Convert double from signed 64 bit integer: Assigns the value of t1 to f1 (64bit)

Convert double from unsigned long: Assigns the value of t1 to f1 (64bit)

Convert double from unsigned 64 bit integer: Assigns the value of t1 to f1 (64bit)

Convert a float to a double: Assigned the value of f2 to f1

Convert float to double: Assigned the value of f2 to f1

Convert double from integer: Assigns the value of t1 to f1

Convert double from signed integer: Assigns the value of t1 to f1

Convert double from unsigned integer: Assigns the value of t1 to f1

Convert 64 bit integer from double: Assigns the value of f1 (rounded) to t1 (64bit)

Convert signed 64 bit integer from double: Assigns the value of f1 (rounded) to t1 (64bit)

Convert 64 bit integer from float: Assigns the value of f1 (rounded) to t1 (64bit)

Convert signed 64 bit integer from float: Assigns the value of f1 (rounded) to t1 (64bit)

Convert unsigned 64 bit integer from double: Assigns the value of f1 (rounded) to t1 (64bit)

Convert unsigned 64 bit integer from float: Assigns the value of f1 (rounded) to t1 (64bit)

Convert a double to a float: Assigned the value of f2 to f1

Convert double to float: Assigned the value of f2 to f1

Convert float from long: Assigns the value of t1 to f1 (64bit)

Convert float from signed 64 bit integer: Assigns the value of t1 to f1 (64bit)

Convert float from unsigned long: Assigns the value of t1 to f1 (64bit)

Convert float from unsigned 64 bit integer: Assigns the value of t1 to f1 (64bit)

Convert float from integer: Assigns the value of t1 to f1

Convert float from signed integer: Assigns the value of t1 to f1

Convert float from unsigned integer: Assigns the value of t1 to f1

Convert integer from double: Assigns the value of f1 (rounded) to t1

Convert signed integer from double: Assigns the value of f1 (rounded) to t1

Convert integer from float: Assigns the value of f1 (rounded) to t1

Convert signed integer from float: Assigns the value of f1 (rounded) to t1

Convert unsinged integer from double: Assigns the value of f1 (rounded) to t1

Convert unsigned integer from double: Assigns the value of f1 (rounded) to t1

Convert unsinged integer from float: Assigns the value of f1 (rounded) to t1

Convert unsigned integer from float: Assigns the value of f1 (rounded) to t1

Floating DIVide (64 bit): assigns f1 to f2 / f3

Floating DIVide: assigns f1 to f2 / f3

Ensure that IO and memory accesses before the fence happen before the following IO and memory accesses as viewed by a different thread

Ensure that stores to instruction memory are visible to instruction fetches

Floating EQuals (64 bit): if f1 = f2, set t1 to 1, else set t1 to 0

Floating EQuals: if f1 = f2, set t1 to 1, else set t1 to 0

Floating Greater Than or Equal (64 bit): if f2 >= f3, set t1 to 1, else set t1 to 0

Floating Greater Than or Equal: if f2 >= f3, set t1 to 1, else set t1 to 0

Floating Greater Than (64 bit): if f2 > f3, set t1 to 1, else set t1 to 0

Floating Greater Than: if f2 > f3, set t1 to 1, else set t1 to 0

Load a double from memory

Load Word: Set f1 to 64-bit value from effective memory word address

Load Word: Set f1 to 64-bit value from effective memory word address using t3 as a temporary

Load from Address

Floating Less than or Equals (64 bit): if f1 <= f2, set t1 to 1, else set t1 to 0

Floating Less than or Equals: if f1 <= f2, set t1 to 1, else set t1 to 0

Floating Less Than (64 bit): if f1 < f2, set t1 to 1, else set t1 to 0

Floating Less Than: if f1 < f2, set t1 to 1, else set t1 to 0

Load a float from memory

Load Word Coprocessor 1 : Set f1 to 32-bit value from effective memory word address

Load Word Coprocessor 1 : Set f1 to 32-bit value from effective memory word address using t3 as a temporary

Load from Address

Fused Multiply Add (64 bit): Assigns f2*f3+f4 to f1

Fused Multiply Add: Assigns f2*f3+f4 to f1

Floating MAXimum (64 bit): assigns f1 to the larger of f1 and f3

Floating MAXimum: assigns f1 to the larger of f1 and f3

Floating MINimum (64 bit): assigns f1 to the smaller of f1 and f3

Floating MINimum: assigns f1 to the smaller of f1 and f3

Fused Multiply Subatract: Assigns f2*f3-f4 to f1

Fused Multiply Subatract (64 bit): Assigns f2*f3-f4 to f1

Fused Multiply Subatract: Assigns f2*f3-f4 to f1

Floating MULtiply (64 bit): assigns f1 to f2 * f3

Floating MULtiply: assigns f1 to f2 * f3

Move the value of f2 to f1 (64 bit)

Move float: move bits representing a double from an 64 bit integer register (64bit)

Move the value of f2 to f1

Move float: move bits representing a float from an integer register

Move float (New mnemonic): move bits representing a float from an integer register

Move double: move bits representing a double to an 64 bit integer register (64bit)

Move float: move bits representing a float to an integer register

Move float (New mnemonic): move bits representing a float to an integer register

Set f1 to the negation of f2 (64 bit)

Set f1 to the negation of f2

Fused Negate Multiply Add (64 bit): Assigns -(f2*f3+f4) to f1

Fused Negate Multiply Add: Assigns -(f2*f3+f4) to f1

Fused Negated Multiply Subatract: Assigns -(f2*f3-f4) to f1

Fused Negated Multiply Subatract (64 bit): Assigns -(f2*f3-f4) to f1

Fused Negated Multiply Subatract: Assigns -(f2*f3-f4) to f1

Read FP control/status register

Read FP exception flags

Read FP rounding mode

Alias for frcsr t1

Swap FP control/status register

Write FP control/status register

Store a double to memory

Store Word: Store 64-bit value from f1 to effective memory word address

Store Word: Store 64-bit value from f1 to effective memory word address using t3 as a temporary

Store to Address

Swap FP exception flags

Write FP exception flags

Floating point sign injection (64 bit): replace the sign bit of f2 with the sign bit of f3 and assign it to f1

Floating point sign injection: replace the sign bit of f2 with the sign bit of f3 and assign it to f1

Floating point sign injection (inverted 64 bit): replace the sign bit of f2 with the opposite of sign bit of f3 and assign it to f1

Floating point sign injection (inverted): replace the sign bit of f2 with the opposite of sign bit of f3 and assign it to f1

Floating point sign injection (xor 64 bit): xor the sign bit of f2 with the sign bit of f3 and assign it to f1

Floating point sign injection (xor): xor the sign bit of f2 with the sign bit of f3 and assign it to f1

Floating SQuare RooT (64 bit): Assigns f1 to the square root of f2

Floating SQuare RooT: Assigns f1 to the square root of f2

Swap FP rounding mode

Write FP rounding mode

Alias for fscsr t1, t2

Alias for fscsr t1

Floating SUBtract (64 bit): assigns f1 to f2 - f3

Floating SUBtract: assigns f1 to f2 - f3

Store a float to memory

Store Word Coprocessor 1 : Store 32-bit value from f1 to effective memory word address

Store Word Coprocessor 1 : Store 32-bit value from f1 to effective memory word address using t3 as a temporary

Store to Address

Jump : Jump to statement at label

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

Jump And Link: Jump to statement at label and set the return address to ra

Jump and link register: Set t1 to Program Counter (return address) then jump to statement at t2 + immediate

Jump And Link Register: Jump to address in t0 and set the return address to ra

Jump And Link Register: Jump to address in t1 and set the return address to t0

Jump Register: Jump to address in t0

Load Address : Set t1 to label's address

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

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

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

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

Load from Address

Set t1 to zero-extended 8-bit value from effective memory byte address

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

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

Load from Address

Set t1 to contents of effective memory double word address (64bit)

Load Double word : Set t1 to contents of effective memory word address (64bit)

Load Double word : Set t1 to contents of memory word at label's address (64bit)

Load from Address (64bit)

Set t1 to sign-extended 16-bit value from effective memory halfword address

Load Halfword : Set t1 to sign-extended 16-bit value from effective memory halfword address

Load from Address

Set t1 to zero-extended 16-bit value from effective memory halfword address

Load Halfword Unsigned : Set t1 to zero-extended 16-bit value from effective memory halfword address

Load from Address

Load Immediate : Set t1 to 12-bit immediate (sign-extended)

Load Immediate : Set t1 to 32-bit immediate

Load Immediate : Set t1 to 12-bit immediate (sign-extended) (64bit)

Load Immediate : Set t1 to 32-bit immediate (sign-extended) (64bit)

Load Immediate : Set t1 to 64-bit immediate (64bit)

Load reserved (double word) : Set t1 to the double word at the address in t2 and reserve that address. Pair with sc.d to build an atomic read-modify-write that can be retried (64bit)

Load reserved (word) : Set t1 to the word at the address in t2 and reserve that address. Pair with sc.w to build an atomic read-modify-write that can be retried

Load upper immediate: set t1 to 20-bit followed by 12 0s

Load Upper Address : Set t1 to upper 20-bit label's address

Set t1 to contents of effective memory word address

Load Word : Set t1 to contents of effective memory word address

Load Word : Set t1 to contents of memory word at label's address

Load from Address

Set t1 to contents of effective memory word address without sign-extension (64bit)

Load from Address (64bit)

Maximum (signed) : Set t1 to the larger of t2 and t3, comparing as signed. Branch free, unlike the usual blt and move

Maximum (unsigned) : Set t1 to the larger of t2 and t3, comparing as unsigned

Minimum (signed) : Set t1 to the smaller of t2 and t3, comparing as signed. Branch free, unlike the usual blt and move

Minimum (unsigned) : Set t1 to the smaller of t2 and t3, comparing as unsigned

Multiplication: set t1 to the lower 32 bits of t2*t3

Multiplication: set t1 to the upper 32 bits of t2*t3 using signed multiplication

Multiplication: set t1 to the upper 32 bits of t2*t3 where t2 is signed and t3 is unsigned

Multiplication: set t1 to the upper 32 bits of t2*t3 using unsigned multiplication

Multiplication: set t1 to the lower 32 bits of t2*t3 using only the lower 32 bits of the input (64bit)

MoVe : Set t1 to contents of t2

NEGate : Set t1 to negation of t2

NEGate Word: Set t1 to negation of t2 (only lower 32 bits) (64bit)

NO OPeration

Bitwise NOT (bit inversion)

Bitwise OR : Set t1 to bitwise OR of t2 and t3

Bitwise OR combine within bytes : Set every byte of t1 to 0xFF when the matching byte of t2 has any bit set, and to 0 otherwise. Used to find a zero byte inside a word

Bitwise OR immediate : Set t1 to bitwise OR of t2 and sign-extended 12-bit immediate

OR with inverted operand : Set t1 to the bitwise OR of t2 and the bitwise NOT of t3

Read from cycle

Read from cycleh

Read from instret

Read from instreth

Read from time

Read from timeh

Remainder: set t1 to the remainder of t2/t3

Remainder: set t1 to the remainder of t2/t3 using unsigned division

Remainder: set t1 to the remainder of t2/t3 using unsigned division limited to 32 bits (64bit)

Remainder: set t1 to the remainder of t2/t3 using only the lower 32 bits (64bit)

Return: return from a subroutine

Reverse bytes : Set t1 to t2 with its bytes in the opposite order, converting between little and big endian

Rotate left : Set t1 to t2 rotated left by the low bits of t3, so bits shifted off the top re-enter at the bottom

Rotate left (32 bit) : Set t1 to the low 32 bits of t2 rotated left by the low 5 bits of t3, sign extended (64bit)

Rotate right : Set t1 to t2 rotated right by the low bits of t3, so bits shifted off the bottom re-enter at the top

Rotate right by immediate : Set t1 to t2 rotated right by the immediate, so bits shifted off the bottom re-enter at the top

Rotate right by immediate (32 bit) : Set t1 to the low 32 bits of t2 rotated right by the immediate, sign extended (64bit)

Rotate right (32 bit) : Set t1 to the low 32 bits of t2 rotated right by the low 5 bits of t3, sign extended (64bit)

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

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

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

Store to Address

Store conditional (double word) : Store t2 as a double word at the address in t3 only if that address is still reserved by an lr.d, then set t1 to 0 on success or 1 on failure. Always branch on t1 and retry from the lr.d when it fails (64bit)

Store conditional (word) : Store t2 as a word at the address in t3 only if that address is still reserved by an lr.w, then set t1 to 0 on success or 1 on failure. Always branch on t1 and retry from the lr.w when it fails

Store double word : Store contents of t1 into effective memory double word address (64bit)

Store to Address (64bit)

Set EQual to Zero : if t2 == 0 then set t1 to 1 else 0

Sign extend byte : Set t1 to the low byte of t2 sign extended to the full register width

Sign extend half word : Set t1 to the low 16 bits of t2 sign extended to the full register width

Sign EXTend Word: extract the low 32-bits from t2 and sign extend it into t1 (64bit)

Set Greater Than : if t2 greater than t3 then set t1 to 1 else 0

Set Greater Than Unsigned : if t2 greater than t3 (unsigned compare) then set t1 to 1 else 0

Set Greater Than Zero : if t2 > 0 then set t1 to 1 else 0

Store halfword : Store the low-order 16 bits of t1 into the effective memory halfword address

Store Halfword : Store the low-order 16 bits of $1 into the effective memory halfword address

Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword address

Store Halfword : Store the low-order 16 bits of t1 into the effective memory halfword address using t2 as a temporary

Store to Address

Shift left by 1 and add : Set t1 to (t2 << 1) + t3. One instruction for stepping a pointer through an array of 2 byte elements

Shift unsigned word left by 1 and add : Set t1 to (zero extended low 32 bits of t2 << 1) + t3 (64bit)

Shift left by 2 and add : Set t1 to (t2 << 2) + t3. One instruction for indexing an array of words

Shift unsigned word left by 2 and add : Set t1 to (zero extended low 32 bits of t2 << 2) + t3 (64bit)

Shift left by 3 and add : Set t1 to (t2 << 3) + t3. One instruction for indexing an array of double words

Shift unsigned word left by 3 and add : Set t1 to (zero extended low 32 bits of t2 << 3) + t3 (64bit)

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

Shift left logical : Set t1 to result of shifting t2 left by number of bits specified by immediate (64bit)

Shift unsigned word left by immediate : Set t1 to the low 32 bits of t2, zero extended, shifted left by the immediate. Scales an unsigned 32 bit index without a separate zero extension (64bit)

Shift left logical (32 bit): Set t1 to result of shifting t2 left by number of bits specified by immediate (64bit)

Shift left logical (32 bit): Set t1 to result of shifting t2 left by number of bits specified by value in low-order 5 bits of t3 (64bit)

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

Set less than immediate : If t2 is less than sign-extended 12-bit immediate, then set t1 to 1 else set t1 to 0

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

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

Set Less Than Zero : if t2 < 0 then set t1 to 1 else 0

Set Not Equal to Zero : if t2 != 0 then set t1 to 1 else 0

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

Shift right arithmetic : Set t1 to result of sign-extended shifting t2 right by number of bits specified by immediate (64bit)

Shift right arithmetic (32 bit): Set t1 to result of sign-extended shifting t2 right by number of bits specified by immediate (64bit)

Shift left logical (32 bit): Set t1 to result of shifting t2 left by number of bits specified by value in low-order 5 bits of t3 (64bit)

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

Shift right logical : Set t1 to result of shifting t2 right by number of bits specified by immediate (64bit)

Shift right logical (32 bit): Set t1 to result of shifting t2 right by number of bits specified by immediate (64bit)

Shift left logical (32 bit): Set t1 to result of shifting t2 left by number of bits specified by value in low-order 5 bits of t3 (64bit)

Subtraction: set t1 to (t2 minus t3)

Subtraction: set t1 to (t2 minus t3) using only the lower 32 bits (64bit)

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

Store Word : Store t1 contents into effective memory word address

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

Store Word : Store $t1 contents into effective memory word address using t2 as a temporary

Store Word : Store $t1 contents into memory word at label's address using t2 as a temporary

Store to Address

TAIL call: tail call (call without saving return address)a far-away subroutine

Return from handling an interrupt or exception (to uepc)

Wait for Interrupt

Exclusive NOR : Set t1 to the bitwise NOT of the XOR of t2 and t3, so a bit is set wherever t2 and t3 agree

Bitwise XOR : Set t1 to bitwise XOR of t2 and t3

Bitwise XOR immediate : Set t1 to bitwise XOR of t2 and sign-extended 12-bit immediate

Zero EXTend Byte: extract the low byte into t1

Zero EXTend Byte: extract the low byte into t1 (64bit)

Zero extend half word : Set t1 to the low 16 bits of t2 with the rest of the register cleared

Zero EXTend Word: extract the low 32-bits from t2 into t1 (64bit)