RISC-V Complete Documentation

Addition: set t1 to (t2 plus t3)

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)

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

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

Branch : Branch to statement at label unconditionally

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

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

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

CALL: call a far-away subroutine

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

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

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

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

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 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 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)

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 immediate : Set t1 to bitwise OR of t2 and sign-extended 12-bit immediate

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

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 double word : Store contents of t1 into effective memory double word address (64bit)

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

Sign EXTend Byte: extract the low byte from t2 and sign extend it into t1

Sign EXTend Byte: extract the low byte from t2 and sign extend it into t1 (64bit)

Sign EXTend Half: extract the low 16 bit from t2 and sign extend it into t1

Sign EXTend Half: extract the low 16 bit from t2 and sign extend it into t1 (64bit)

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

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

Shift left logical : 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 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

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

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

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

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: extract the low 16 bit into t1

Zero EXTend Half: extract the low 16 bit into t1 (64bit)

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