Ribbon ISA v0.1.0 _draft

Overview
Instructions

This is an instruction set architecture (ISA) for the Ribbon bytecode.

The Ribbon bytecode is a low-level register based bytecode, with support for arbitrary effect handlers. For more information on implementation details of the Ribbon virtual machine see core, bytecode, etc.

Overview

Basic layout

The ISA is divided into Categories;

Categories are further divided into Mnemonic bases;

Mnemonics then contain tables describing each concrete instruction variation.

Example

callc and call_v are both under the call mnemonic, within the Control Flow category.

JIT-only Instructions

Instructions with a jit tag above their name are only available when Rvm is compiled with the jit option.

Encoding

We display the encoding of each instruction as segmented bytes. The Ribbon bytecode is always in little endian order, and we display these bytes as they are ordered in memory.

The opcode is shown first, as a two byte hexadecimal number.

Padding bytes are shown as __.

In addition to standard hex characters and underscores, we utilize operand encoding symbology, such as Rx, indicating the first register operand to use. Symbolic operand character sequences will begin with a capital letter, and will be the appropriate width for the operand’s bytes if they were shown in hex form.

Nybbles displayed with . continue the value to the left of them.

Some instructions take up multiple words. We display word boundaries as line breaks within the tables’ Encoding columns, with subsequent instruction address representations arranged lower within these lines. Where the number of words used is dynamic, a trailing line containing ... will be shown.

Example

An instruction with a u16 immediate operand will use the notation I. .., because it is 2 bytes.

Similarly, Register operands are simply R. or Rx, Ry, etc because they are 1-byte identifiers.

As a concrete example, store64c, an instruction which stores a 64-bit immediate value (encoded as Iy) to memory at the address in a designated register (encoded as R), offset by another 32-bit immediate value (encoded as Ix), has an encoding column entry like this:

Encoding
`2d` `00` `R.` `Ix` `..` `..` `..` `__` `Iy` `..` `..` `..` `..` `..` `..` `..`

Immediate Operands

Immediate operands are formatted with I; immediate in this context means that the value is literally encoded into the byte stream, rather than encoding a reference to the value. We allow up to 64-bit immediates for all operations that are binary or greater in arity; in all cases the bit size of the immediate operand and the bit size of the operation must match. (I.e. there is no ‘add 8 bit imm to 32 bit reg’ instruction.)

Where instructions utilizing immediate operands are commutative, the version of the instruction taking a constant will be suffixed with c.

For instructions that do not commute, the two constant versions will be suffixed with a and b respectively, indicating whether the constant is used on the left or right side.

Example

Name	Description Excerpt
`mem_set`	… up to an offset of `Rz`, is set to … `Ry`
`mem_set_a`	… up to an offset of `I`, is set to `Ry`
`mem_set_b`	… up to an offset of `Ry`, is set to `I`
…
`mem_swap`	… up to an offset of `Rz` …
`mem_swap_c`	… up to an offset of `I` …

Operand Types

Type	Shortcode	Size
`Register`	`R`	8 bits
`UpvalueId`	`U`	8 bits
`GlobalId`	`G`	32 bits
`FunctionId`	`F`	32 bits
`BuiltinId`	`B`	32 bits
`ForeignAddressId`	`X`	32 bits
`EffectId`	`E`	32 bits
`HandlerSetId`	`H`	32 bits
`ConstantId`	`C`	32 bits
`u8`	`I`	8 bits
`u16`	`I`	16 bits
`u32`	`I`	32 bits
`u64`	`I`	64 bits

Instructions

There are 8 categories. Separated into those categories, there are a total of 57 mnemonics. With an average of 7.87719298245614 instructions per mnemonic, we have a grand total of 449 unique instructions.

Miscellaneous
- nop
- breakpoint
Control flow
- halt
- trap
- set
- br
- call
- return
Memory
- mem_set
- mem_copy
- mem_swap
- addr
- load
- store
Bitwise
- bit_swap
- bit_copy
- bit_clz
- bit_pop
- bit_not
- bit_and
- bit_or
- bit_xor
- bit_lshift
- bit_rshift
Comparison
- eq
- ne
- lt
- gt
- le
- ge
Integer arithmetic
- i_neg
- i_abs
- i_add
- i_sub
- i_mul
- i_div
- i_rem
- i_pow
Floating point arithmetic
- f_neg
- f_abs
- f_sqrt
- f_floor
- f_ceil
- f_round
- f_trunc
- f_whole
- f_frac
- f_add
- f_sub
- f_mul
- f_div
- f_rem
- f_pow
Value conversion
- s_ext
- f_to_i
- i_to_f
- f_to_f

Miscellaneous

Items that do not fit into another category

nop

Name	Encoding	Description
`nop`	`00` `00` `__` `__` `__` `__` `__` `__`	No operation

breakpoint

Name	Encoding	Description
`breakpoint`	`01` `00` `__` `__` `__` `__` `__` `__`	Triggers a breakpoint in debuggers; does nothing otherwise

Control flow

Instructions that control the flow of execution

halt

Name	Encoding	Description
`halt`	`02` `00` `__` `__` `__` `__` `__` `__`	Halts execution at this instruction offset

trap

Marks a point in the code as not normally reachable, in two ways

Name	Encoding	Description
`trap`	`03` `00` `__` `__` `__` `__` `__` `__`	Traps execution of the `Rvm.Fiber` at this instruction offset Unlike `unreachable`, this indicates expected behavior; optimizing compilers should not assume it is never reached
`unreachable`	`04` `00` `__` `__` `__` `__` `__` `__`	Marks a point in the code as unreachable; if executed in Rvm, it is the same as `trap` Unlike `trap`, however, this indicates undefined behavior; optimizing compilers should assume it is never reached

set

Effect handler set stack manipulation

Name	Encoding	Description
`push_set`	`05` `00` `H.` `..` `..` `..` `__` `__`	Pushes `H` onto the stack. The handlers in this set will be first in line for their effects’ prompts until a corresponding `pop` operation.
`pop_set`	`06` `00` `__` `__` `__` `__` `__` `__`	Pops the top most `HandlerSetId` from the stack, restoring the previous if present

br

Instruction pointer manipulation

Name	Encoding	Description
`br`	`07` `00` `I.` `..` `__` `__` `__` `__`	Applies a signed integer offset `I` to the instruction pointer
`br_if`	`08` `00` `R.` `Ix` `..` `Iy` `..` `__`	Applies a signed integer offset `Ix` to the instruction pointer, if the value stored in `R` is non-zero; otherwise, applies the signed integer offset in `Iy`

call

Various ways of calling functions, in all cases taking up to max(u8) number of arguments. Arguments are expected to be Register values, encoded in the instruction stream after the call instruction.

Register is not instruction-aligned; padding bytes may need to be added and accounted for following the arguments, to ensure the next instruction is aligned

Name	Encoding	Description
`call`	`09` `00` `Rx` `Ry` `I.` `__` `__` `__` `...`	Calls the bytecode or builtin function in `Ry` using `I` argument registers, placing the result in `Rx`
`call_c`	`0a` `00` `R.` `F.` `..` `..` `..` `I.` `...`	Calls the bytecode or builtin function at `F` using `I` argument registers, placing the result in `R`
`f_call`	`0b` `00` `Rx` `Ry` `I.` `__` `__` `__` `...`	Calls the foreign function in `Ry` using `I` argument registers, placing the result in `Rx`
`f_call_c`	`0c` `00` `R.` `X.` `..` `..` `..` `I.` `...`	Calls the foreign function at `X` using `I` argument registers, placing the result in `R`
`prompt`	`0d` `00` `R.` `E.` `..` `..` `..` `I.` `...`	Calls the bytecode or builtin effect handler designated by `E` using `I` argument registers, placing the result in `R`.

return

End the current function, in one of two ways

Name	Encoding	Description
`return`	`0e` `00` `R.` `__` `__` `__` `__` `__`	Returns flow control to the caller of current function, yielding `R` to the caller
`cancel`	`0f` `00` `R.` `__` `__` `__` `__` `__`	Returns flow control to the offset associated with the current effect handler’s `HandlerSetId`, yielding `R` as the cancellation value

Memory

Instructions that provide memory access

mem_set

Set bytes in memory

Name	Encoding	Description
`mem_set`	`10` `00` `Rx` `Ry` `Rz` `__` `__` `__`	Each byte, starting from the address in `Rx`, up to an offset of `Rz`, is set to the least significant byte of `Ry`
`mem_set_a`	`11` `00` `Rx` `Ry` `I.` `..` `..` `..`	Each byte, starting from the address in `Rx`, up to an offset of `I`, is set to `Ry`
`mem_set_b`	`12` `00` `Rx` `Ry` `I.` `__` `__` `__`	Each byte, starting from the address in `Rx`, up to an offset of `Ry`, is set to `I`

mem_copy

Copy bytes in memory

Name	Encoding	Description
`mem_copy`	`13` `00` `Rx` `Ry` `Rz` `__` `__` `__`	Each byte, starting from the address in `Ry`, up to an offset of `Rz`, is copied to the same offset of the address in `Rx`
`mem_copy_a`	`14` `00` `Rx` `Ry` `I.` `..` `..` `..`	Each byte, starting from the address in `Ry`, up to an offset of `I`, is copied to the same offset from the address in `Rx`
`mem_copy_b`	`15` `00` `Rx` `Ry` `C.` `..` `..` `..`	Each byte, starting from the address of `C`, up to an offset of `Ry`, is copied to the same offset from the address in `Rx`

mem_swap

Swap bytes in memory.

Name	Encoding	Description
`mem_swap`	`16` `00` `Rx` `Ry` `Rz` `__` `__` `__`	Each byte, starting from the addresses in `Rx` and `Ry`, up to an offset of `Rz`, are swapped with each-other
`mem_swap_c`	`17` `00` `Rx` `Ry` `I.` `..` `..` `..`	Each byte, starting from the addresses in `Rx` and `Ry`, up to an offset of `I`, are swapped with each-other

addr

Get addresses from special values.

Name	Encoding	Description
`addr_l`	`18` `00` `R.` `I.` `..` `__` `__` `__`	Get the address of an unsigned integer current-frame-relative operand stack offset `I`, placing it in `R`. An operand stack offset of 1 is equivalent to 8 bytes down from the base of the stack frame. `R` = stack_base(current_function) + `I`
`addr_u`	`19` `00` `R.` `I.` `..` `__` `__` `__`	Get the address of an unsigned integer parent-frame-relative operand stack offset `I`, placing it in `R`. An operand stack offset of 1 is equivalent to 8 bytes down from the base of the parent frame. ”Parent” frame here refers to the frame of the function that bound the current function as an effect handler. `R` = stack_base(current_function.parent) + `I`
`addr_g`	`1a` `00` `R.` `G.` `..` `..` `..` `__`	Get the address of `G`, placing it in `R`; `R` = &`G`
`addr_f`	`1b` `00` `R.` `F.` `..` `..` `..` `__`	Get the address of `F`, placing it in `R`; `R` = &`F`
`addr_b`	`1c` `00` `R.` `B.` `..` `..` `..` `__`	Get the address of `B`, placing it in `R`; `R` = &`B`
`addr_x`	`1d` `00` `R.` `X.` `..` `..` `..` `__`	Get the address of `X`, placing it in `R`; `R` = &`X`
`addr_c`	`1e` `00` `R.` `C.` `..` `..` `..` `__`	Get the address of `C`, placing it in `R`; `R` = &`C`

load

Loads a value from memory

Name	Encoding	Description
`load8`	`1f` `00` `Rx` `Ry` `I.` `..` `..` `..`	Loads an 8-bit value from memory at the address in `Ry` offset by `I`, placing the result in `Rx`; `Rx` = *(`Ry` + `I`)
`load16`	`20` `00` `Rx` `Ry` `I.` `..` `..` `..`	Loads a 16-bit value from memory at the address in `Ry` offset by `I`, placing the result in `Rx`; `Rx` = *(`Ry` + `I`)
`load32`	`21` `00` `Rx` `Ry` `I.` `..` `..` `..`	Loads a 32-bit value from memory at the address in `Ry` offset by `I`, placing the result in `Rx`; `Rx` = *(`Ry` + `I`)
`load64`	`22` `00` `Rx` `Ry` `I.` `..` `..` `..`	Loads a 64-bit value from memory at the address in `Ry` offset by `I`, placing the result in `Rx`; `Rx` = *(`Ry` + `I`)

store

Stores a value to memory

Name	Encoding	Description
`store8`	`23` `00` `Rx` `Ry` `I.` `..` `..` `..`	Stores an 8-bit value from `Ry` to memory at the address in `Rx` offset by `I`; *(`Rx` + `I`) = `Ry`
`store16`	`24` `00` `Rx` `Ry` `I.` `..` `..` `..`	Stores a 16-bit value from `Ry` to memory at the address in `Rx` offset by `I`; *(`Rx` + `I`) = `Ry`
`store32`	`25` `00` `Rx` `Ry` `I.` `..` `..` `..`	Stores a 32-bit value from `Ry` to memory at the address in `Rx` offset by `I`; *(`Rx` + `I`) = `Ry`
`store64`	`26` `00` `Rx` `Ry` `I.` `..` `..` `..`	Stores a 64-bit value from `Ry` to memory at the address in `Rx` offset by `I`; *(`Rx` + `I`) = `Ry`
`store8c`	`27` `00` `R.` `Ix` `Iy` `..` `..` `..`	Stores an 8-bit value (`Ix`) to memory at the address in `R` offset by `Iy`; *(`R` + `Iy`) = `Ix`
`store16c`	`28` `00` `R.` `Ix` `..` `__` `__` `__` `Iy` `..` `..` `..` `__` `__` `__` `__`	Stores a 16-bit value (`Ix`) to memory at the address in `R` offset by `Iy`; *(`R` + `Iy`) = `Ix`
`store32c`	`29` `00` `R.` `Ix` `..` `..` `..` `__` `Iy` `..` `..` `..` `__` `__` `__` `__`	Stores a 32-bit value (`Ix`) to memory at the address in `R` offset by `Iy`; *(`R` + `Iy`) = `Ix`
`store64c`	`2a` `00` `R.` `Ix` `..` `..` `..` `__` `Iy` `..` `..` `..` `..` `..` `..` `..`	Stores a 64-bit value (encoded as `Iy`) to memory at the address in `R` offset by `Ix`; *(`R` + `Ix`) = `Iy`

Bitwise

Instructions that manipulate values at the bit level.

Where the size is < 64-bits, the least significant bits of the input value(s) are used, and the remainder of the output value is zeroed

bit_swap

Swaps bits of two registers

Name	Encoding	Description
`bit_swap8`	`2b` `00` `Rx` `Ry` `__` `__` `__` `__`	8-bit `Rx` ⇔ `Ry`
`bit_swap16`	`2c` `00` `Rx` `Ry` `__` `__` `__` `__`	16-bit `Rx` ⇔ `Ry`
`bit_swap32`	`2d` `00` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` ⇔ `Ry`
`bit_swap64`	`2e` `00` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` ⇔ `Ry`

bit_copy

Copies bits from one register into another

Name	Encoding	Description
`bit_copy8`	`2f` `00` `Rx` `Ry` `__` `__` `__` `__`	8-bit `Rx` = `Ry`
`bit_copy16`	`30` `00` `Rx` `Ry` `__` `__` `__` `__`	16-bit `Rx` = `Ry`
`bit_copy32`	`31` `00` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = `Ry`
`bit_copy64`	`32` `00` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = `Ry`
`bit_copy8c`	`33` `00` `R.` `I.` `__` `__` `__` `__`	Copies an 8-bit `I` value into `R`
`bit_copy16c`	`34` `00` `R.` `I.` `..` `__` `__` `__`	Copies a 16-bit `I` value into `R`
`bit_copy32c`	`35` `00` `R.` `I.` `..` `..` `..` `__`	Copies a 32-bit `I` value into `R`
`bit_copy64c`	`36` `00` `R.` `__` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	Copies a 64-bit `I` value into `R`

bit_clz

Counts the number of leading zero bits in the provided value

Name	Encoding	Description
`bit_clz8`	`37` `00` `Rx` `Ry` `__` `__` `__` `__`	Counts the leading zeroes in 8-bits of `Ry`, placing the result in `Rx`
`bit_clz16`	`38` `00` `Rx` `Ry` `__` `__` `__` `__`	Counts the leading zeroes in 16-bits of `Ry`, placing the result in `Rx`
`bit_clz32`	`39` `00` `Rx` `Ry` `__` `__` `__` `__`	Counts the leading zeroes in 32-bits of `Ry`, placing the result in `Rx`
`bit_clz64`	`3a` `00` `Rx` `Ry` `__` `__` `__` `__`	Counts the leading zeroes in 64-bits of `Ry`, placing the result in `Rx`

bit_pop

Counts the number of bits that are set to 1 in the provided value

Name	Encoding	Description
`bit_pop8`	`3b` `00` `Rx` `Ry` `__` `__` `__` `__`	Counts the set bits in 8-bits of `Ry`, placing the result in `Rx`
`bit_pop16`	`3c` `00` `Rx` `Ry` `__` `__` `__` `__`	Counts the set bits in 16-bits of `Ry`, placing the result in `Rx`
`bit_pop32`	`3d` `00` `Rx` `Ry` `__` `__` `__` `__`	Counts the set bits in 32-bits of `Ry`, placing the result in `Rx`
`bit_pop64`	`3e` `00` `Rx` `Ry` `__` `__` `__` `__`	Counts the set bits in 64-bits of `Ry`, placing the result in `Rx`

bit_not

Performs a bitwise NOT operation on the provided value

Name	Encoding	Description
`bit_not8`	`3f` `00` `Rx` `Ry` `__` `__` `__` `__`	8-bit `Rx` = ~`Ry`
`bit_not16`	`40` `00` `Rx` `Ry` `__` `__` `__` `__`	16-bit `Rx` = ~`Ry`
`bit_not32`	`41` `00` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = ~`Ry`
`bit_not64`	`42` `00` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = ~`Ry`

bit_and

Performs a bitwise AND operation on the provided values

Name	Encoding	Description
`bit_and8`	`43` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit `Rx` = `Ry` & `Rz`
`bit_and16`	`44` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit `Rx` = `Ry` & `Rz`
`bit_and32`	`45` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` & `Rz`
`bit_and64`	`46` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` & `Rz`
`bit_and8c`	`47` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit `Rx` = `Ry` & `I`
`bit_and16c`	`48` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit `Rx` = `Ry` & `I`
`bit_and32c`	`49` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` & `I`
`bit_and64c`	`4a` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` & `I`

bit_or

Performs a bitwise OR operation on the provided values

Name	Encoding	Description
`bit_or8`	`4b` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit `Rx` = `Ry` \| `Rz`
`bit_or16`	`4c` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit `Rx` = `Ry` \| `Rz`
`bit_or32`	`4d` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` \| `Rz`
`bit_or64`	`4e` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` \| `Rz`
`bit_or8c`	`4f` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit `Rx` = `Ry` \| `I`
`bit_or16c`	`50` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit `Rx` = `Ry` \| `I`
`bit_or32c`	`51` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` \| `I`
`bit_or64c`	`52` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` \| `I`

bit_xor

Performs a bitwise XOR operation on the provided values

Name	Encoding	Description
`bit_xor8`	`53` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit `Rx` = `Ry` ^ `Rz`
`bit_xor16`	`54` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit `Rx` = `Ry` ^ `Rz`
`bit_xor32`	`55` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` ^ `Rz`
`bit_xor64`	`56` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` ^ `Rz`
`bit_xor8c`	`57` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit `Rx` = `Ry` ^ `I`
`bit_xor16c`	`58` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit `Rx` = `Ry` ^ `I`
`bit_xor32c`	`59` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` ^ `I`
`bit_xor64c`	`5a` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` ^ `I`

bit_lshift

Performs a bitwise left shift operation on the provided values

Name	Encoding	Description
`bit_lshift8`	`5b` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit `Rx` = `Ry` << `Rz`
`bit_lshift16`	`5c` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit `Rx` = `Ry` << `Rz`
`bit_lshift32`	`5d` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` << `Rz`
`bit_lshift64`	`5e` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` << `Rz`
`bit_lshift8a`	`5f` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit `Rx` = `I` << `Ry`
`bit_lshift16a`	`60` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit `Rx` = `I` << `Ry`
`bit_lshift32a`	`61` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `I` << `Ry`
`bit_lshift64a`	`62` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `I` << `Ry`
`bit_lshift8b`	`63` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit `Rx` = `Ry` << `I`
`bit_lshift16b`	`64` `00` `Rx` `Ry` `I.` `__` `__` `__`	16-bit `Rx` = `Ry` << `I`
`bit_lshift32b`	`65` `00` `Rx` `Ry` `I.` `__` `__` `__`	32-bit `Rx` = `Ry` << `I`
`bit_lshift64b`	`66` `00` `Rx` `Ry` `I.` `__` `__` `__`	64-bit `Rx` = `Ry` << `I`

bit_rshift

Performs a bitwise right shift operation on the provided values

Name	Encoding	Description
`u_rshift8`	`67` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit unsigned/logical `Rx` = `Ry` >> `Rz`
`u_rshift16`	`68` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit unsigned/logical `Rx` = `Ry` >> `Rz`
`u_rshift32`	`69` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit unsigned/logical `Rx` = `Ry` >> `Rz`
`u_rshift64`	`6a` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit unsigned/logical `Rx` = `Ry` >> `Rz`
`u_rshift8a`	`6b` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned/logical `Rx` = `I` >> `Ry`
`u_rshift16a`	`6c` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned/logical `Rx` = `I` >> `Ry`
`u_rshift32a`	`6d` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned/logical `Rx` = `I` >> `Ry`
`u_rshift64a`	`6e` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned/logical `Rx` = `I` >> `Ry`
`u_rshift8b`	`6f` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned/logical `Rx` = `Ry` >> `I`
`u_rshift16b`	`70` `00` `Rx` `Ry` `I.` `__` `__` `__`	16-bit unsigned/logical `Rx` = `Ry` >> `I`
`u_rshift32b`	`71` `00` `Rx` `Ry` `I.` `__` `__` `__`	32-bit unsigned/logical `Rx` = `Ry` >> `I`
`u_rshift64b`	`72` `00` `Rx` `Ry` `I.` `__` `__` `__`	64-bit unsigned/logical `Rx` = `Ry` >> `I`
`s_rshift8`	`73` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit signed/arithmetic `Rx` = `Ry` >> `Rz`
`s_rshift16`	`74` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit signed/arithmetic `Rx` = `Ry` >> `Rz`
`s_rshift32`	`75` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit signed/arithmetic `Rx` = `Ry` >> `Rz`
`s_rshift64`	`76` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit signed/arithmetic `Rx` = `Ry` >> `Rz`
`s_rshift8a`	`77` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed/arithmetic `Rx` = `I` >> `Ry`
`s_rshift16a`	`78` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed/arithmetic `Rx` = `I` >> `Ry`
`s_rshift32a`	`79` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed/arithmetic `Rx` = `I` >> `Ry`
`s_rshift64a`	`7a` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed/arithmetic `Rx` = `I` >> `Ry`
`s_rshift8b`	`7b` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed/arithmetic `Rx` = `Ry` >> `I`
`s_rshift16b`	`7c` `00` `Rx` `Ry` `I.` `__` `__` `__`	16-bit signed/arithmetic `Rx` = `Ry` >> `I`
`s_rshift32b`	`7d` `00` `Rx` `Ry` `I.` `__` `__` `__`	32-bit signed/arithmetic `Rx` = `Ry` >> `I`
`s_rshift64b`	`7e` `00` `Rx` `Ry` `I.` `__` `__` `__`	64-bit signed/arithmetic `Rx` = `Ry` >> `I`

Comparison

Instructions that compare values

eq

Performs an equality comparison on the provided values

Name	Encoding	Description
`i_eq8`	`7f` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit integer `Rx` = `Ry` == `Rz`
`i_eq16`	`80` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit integer `Rx` = `Ry` == `Rz`
`i_eq32`	`81` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit integer `Rx` = `Ry` == `Rz`
`i_eq64`	`82` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit integer `Rx` = `Ry` == `Rz`
`i_eq8c`	`83` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit integer `Rx` = `Ry` == `I`
`i_eq16c`	`84` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit integer `Rx` = `Ry` == `I`
`i_eq32c`	`85` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit integer `Rx` = `Ry` == `I`
`i_eq64c`	`86` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit integer `Rx` = `Ry` == `I`
`f_eq32`	`87` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit floating point `Rx` = `Ry` == `Rz`
`f_eq64`	`88` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit floating point `Rx` = `Ry` == `Rz`
`f_eq32c`	`89` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit floating point `Rx` = `Ry` == `I`
`f_eq64c`	`8a` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit floating point `Rx` = `Ry` == `I`

ne

Performs an inequality comparison on the provided values

Name	Encoding	Description
`i_ne8`	`8b` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit integer `Rx` = `Ry` != `Rz`
`i_ne16`	`8c` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit integer `Rx` = `Ry` != `Rz`
`i_ne32`	`8d` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit integer `Rx` = `Ry` != `Rz`
`i_ne64`	`8e` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit integer `Rx` = `Ry` != `Rz`
`i_ne8c`	`8f` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit integer `Rx` = `Ry` != `I`
`i_ne16c`	`90` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit integer `Rx` = `Ry` != `I`
`i_ne32c`	`91` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit integer `Rx` = `Ry` != `I`
`i_ne64c`	`92` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit integer `Rx` = `Ry` != `I`
`f_ne32`	`93` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit floating point `Rx` = `Ry` != `Rz`
`f_ne64`	`94` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit floating point `Rx` = `Ry` != `Rz`
`f_ne32c`	`95` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit floating point `Rx` = `Ry` != `I`
`f_ne64c`	`96` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit floating point `Rx` = `Ry` != `I`

lt

Performs a less-than comparison on the provided values

Name	Encoding	Description
`u_lt8`	`97` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit unsigned integer `Rx` = `Ry` < `Rz`
`u_lt16`	`98` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit unsigned integer `Rx` = `Ry` < `Rz`
`u_lt32`	`99` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit unsigned integer `Rx` = `Ry` < `Rz`
`u_lt64`	`9a` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit unsigned integer `Rx` = `Ry` < `Rz`
`u_lt8a`	`9b` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned integer `Rx` = `I` < `Ry`
`u_lt16a`	`9c` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned integer `Rx` = `I` < `Ry`
`u_lt32a`	`9d` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned integer `Rx` = `I` < `Ry`
`u_lt64a`	`9e` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned integer `Rx` = `I` < `Ry`
`u_lt8b`	`9f` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned integer `Rx` = `Ry` < `I`
`u_lt16b`	`a0` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned integer `Rx` = `Ry` < `I`
`u_lt32b`	`a1` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned integer `Rx` = `Ry` < `I`
`u_lt64b`	`a2` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned integer `Rx` = `Ry` < `I`
`s_lt8`	`a3` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit signed integer `Rx` = `Ry` < `Rz`
`s_lt16`	`a4` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit signed integer `Rx` = `Ry` < `Rz`
`s_lt32`	`a5` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit signed integer `Rx` = `Ry` < `Rz`
`s_lt64`	`a6` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit signed integer `Rx` = `Ry` < `Rz`
`s_lt8a`	`a7` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed integer `Rx` = `I` < `Ry`
`s_lt16a`	`a8` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed integer `Rx` = `I` < `Ry`
`s_lt32a`	`a9` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed integer `Rx` = `I` < `Ry`
`s_lt64a`	`aa` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed integer `Rx` = `I` < `Ry`
`s_lt8b`	`ab` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed integer `Rx` = `Ry` < `I`
`s_lt16b`	`ac` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed integer `Rx` = `Ry` < `I`
`s_lt32b`	`ad` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed integer `Rx` = `Ry` < `I`
`s_lt64b`	`ae` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed integer `Rx` = `Ry` < `I`
`f_lt32`	`af` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit floating point `Rx` = `Ry` < `Rz`
`f_lt32a`	`b0` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit floating point `Rx` = `I` < `Ry`
`f_lt32b`	`b1` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit floating point `Rx` = `Ry` < `I`
`f_lt64`	`b2` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit floating point `Rx` = `Ry` < `Rz`
`f_lt64a`	`b3` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit floating point `Rx` = `I` < `Ry`
`f_lt64b`	`b4` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit floating point `Rx` = `Ry` < `I`

gt

Performs a greater-than comparison on the provided values

Name	Encoding	Description
`u_gt8`	`b5` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit unsigned integer `Rx` = `Ry` > `Rz`
`u_gt16`	`b6` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit unsigned integer `Rx` = `Ry` > `Rz`
`u_gt32`	`b7` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit unsigned integer `Rx` = `Ry` > `Rz`
`u_gt64`	`b8` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit unsigned integer `Rx` = `Ry` > `Rz`
`u_gt8a`	`b9` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned integer `Rx` = `I` > `Ry`
`u_gt16a`	`ba` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned integer `Rx` = `I` > `Ry`
`u_gt32a`	`bb` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned integer `Rx` = `I` > `Ry`
`u_gt64a`	`bc` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned integer `Rx` = `I` > `Ry`
`u_gt8b`	`bd` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned integer `Rx` = `Ry` > `I`
`u_gt16b`	`be` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned integer `Rx` = `Ry` > `I`
`u_gt32b`	`bf` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned integer `Rx` = `Ry` > `I`
`u_gt64b`	`c0` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned integer `Rx` = `Ry` > `I`
`s_gt8`	`c1` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit signed integer `Rx` = `Ry` > `Rz`
`s_gt16`	`c2` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit signed integer `Rx` = `Ry` > `Rz`
`s_gt32`	`c3` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit signed integer `Rx` = `Ry` > `Rz`
`s_gt64`	`c4` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit signed integer `Rx` = `Ry` > `Rz`
`s_gt8a`	`c5` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed integer `Rx` = `I` > `Ry`
`s_gt16a`	`c6` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed integer `Rx` = `I` > `Ry`
`s_gt32a`	`c7` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed integer `Rx` = `I` > `Ry`
`s_gt64a`	`c8` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed integer `Rx` = `I` > `Ry`
`s_gt8b`	`c9` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed integer `Rx` = `Ry` > `I`
`s_gt16b`	`ca` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed integer `Rx` = `Ry` > `I`
`s_gt32b`	`cb` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed integer `Rx` = `Ry` > `I`
`s_gt64b`	`cc` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed integer `Rx` = `Ry` > `I`
`f_gt32`	`cd` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit floating point `Rx` = `Ry` > `Rz`
`f_gt32a`	`ce` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit floating point `Rx` = `I` > `Ry`
`f_gt32b`	`cf` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit floating point `Rx` = `Ry` > `I`
`f_gt64`	`d0` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit floating point `Rx` = `Ry` > `Rz`
`f_gt64a`	`d1` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit floating point `Rx` = `I` > `Ry`
`f_gt64b`	`d2` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit floating point `Rx` = `Ry` > `I`

le

Performs a less-than-or-equal comparison on the provided values

Name	Encoding	Description
`u_le8`	`d3` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit unsigned integer `Rx` = `Ry` <= `Rz`
`u_le16`	`d4` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit unsigned integer `Rx` = `Ry` <= `Rz`
`u_le32`	`d5` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit unsigned integer `Rx` = `Ry` <= `Rz`
`u_le64`	`d6` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit unsigned integer `Rx` = `Ry` <= `Rz`
`u_le8a`	`d7` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned integer `Rx` = `I` <= `Ry`
`u_le16a`	`d8` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned integer `Rx` = `I` <= `Ry`
`u_le32a`	`d9` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned integer `Rx` = `I` <= `Ry`
`u_le64a`	`da` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned integer `Rx` = `I` <= `Ry`
`u_le8b`	`db` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned integer `Rx` = `Ry` <= `I`
`u_le16b`	`dc` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned integer `Rx` = `Ry` <= `I`
`u_le32b`	`dd` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned integer `Rx` = `Ry` <= `I`
`u_le64b`	`de` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned integer `Rx` = `Ry` <= `I`
`s_le8`	`df` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit signed integer `Rx` = `Ry` <= `Rz`
`s_le16`	`e0` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit signed integer `Rx` = `Ry` <= `Rz`
`s_le32`	`e1` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit signed integer `Rx` = `Ry` <= `Rz`
`s_le64`	`e2` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit signed integer `Rx` = `Ry` <= `Rz`
`s_le8a`	`e3` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed integer `Rx` = `I` <= `Ry`
`s_le16a`	`e4` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed integer `Rx` = `I` <= `Ry`
`s_le32a`	`e5` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed integer `Rx` = `I` <= `Ry`
`s_le64a`	`e6` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed integer `Rx` = `I` <= `Ry`
`s_le8b`	`e7` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed integer `Rx` = `Ry` <= `I`
`s_le16b`	`e8` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed integer `Rx` = `Ry` <= `I`
`s_le32b`	`e9` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed integer `Rx` = `Ry` <= `I`
`s_le64b`	`ea` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed integer `Rx` = `Ry` <= `I`
`f_le32`	`eb` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit floating point `Rx` = `Ry` <= `Rz`
`f_le32a`	`ec` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit floating point `Rx` = `I` <= `Ry`
`f_le32b`	`ed` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit floating point `Rx` = `Ry` <= `I`
`f_le64`	`ee` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit floating point `Rx` = `Ry` <= `Rz`
`f_le64a`	`ef` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit floating point `Rx` = `I` <= `Ry`
`f_le64b`	`f0` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit floating point `Rx` = `Ry` <= `I`

ge

Performs a greater-than-or-equal comparison on the provided values

Name	Encoding	Description
`u_ge8`	`f1` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit unsigned integer `Rx` = `Ry` >= `Rz`
`u_ge16`	`f2` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit unsigned integer `Rx` = `Ry` >= `Rz`
`u_ge32`	`f3` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit unsigned integer `Rx` = `Ry` >= `Rz`
`u_ge64`	`f4` `00` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit unsigned integer `Rx` = `Ry` >= `Rz`
`u_ge8a`	`f5` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned integer `Rx` = `I` >= `Ry`
`u_ge16a`	`f6` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned integer `Rx` = `I` >= `Ry`
`u_ge32a`	`f7` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned integer `Rx` = `I` >= `Ry`
`u_ge64a`	`f8` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned integer `Rx` = `I` >= `Ry`
`u_ge8b`	`f9` `00` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned integer `Rx` = `Ry` >= `I`
`u_ge16b`	`fa` `00` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned integer `Rx` = `Ry` >= `I`
`u_ge32b`	`fb` `00` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned integer `Rx` = `Ry` >= `I`
`u_ge64b`	`fc` `00` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned integer `Rx` = `Ry` >= `I`
`s_ge8`	`fd` `00` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit signed integer `Rx` = `Ry` >= `Rz`
`s_ge16`	`fe` `00` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit signed integer `Rx` = `Ry` >= `Rz`
`s_ge32`	`ff` `00` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit signed integer `Rx` = `Ry` >= `Rz`
`s_ge64`	`00` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit signed integer `Rx` = `Ry` >= `Rz`
`s_ge8a`	`01` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed integer `Rx` = `I` >= `Ry`
`s_ge16a`	`02` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed integer `Rx` = `I` >= `Ry`
`s_ge32a`	`03` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed integer `Rx` = `I` >= `Ry`
`s_ge64a`	`04` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed integer `Rx` = `I` >= `Ry`
`s_ge8b`	`05` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed integer `Rx` = `Ry` >= `I`
`s_ge16b`	`06` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed integer `Rx` = `Ry` >= `I`
`s_ge32b`	`07` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed integer `Rx` = `Ry` >= `I`
`s_ge64b`	`08` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed integer `Rx` = `Ry` >= `I`
`f_ge32`	`09` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit floating point `Rx` = `Ry` >= `Rz`
`f_ge32a`	`0a` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit floating point `Rx` = `I` >= `Ry`
`f_ge32b`	`0b` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit floating point `Rx` = `Ry` >= `I`
`f_ge64`	`0c` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit floating point `Rx` = `Ry` >= `Rz`
`f_ge64a`	`0d` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit floating point `Rx` = `I` >= `Ry`
`f_ge64b`	`0e` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit floating point `Rx` = `Ry` >= `I`

Integer arithmetic

Instructions that perform integer arithmetic operations on values. Because we use two’s compliment integers, the signedness of the operands does not affect all operations. Where it does, the mnemonic will be prefixed with “u” or “s”, otherwise with “i”.

Where the size is < 64-bits, the least significant bits of the input value(s) are used, and the remainder of the output value is zeroed

i_neg

Performs integer negation on the provided value.

Name	Encoding	Description
`s_neg8`	`0f` `01` `Rx` `Ry` `__` `__` `__` `__`	8-bit `Rx` = -`Ry`
`s_neg16`	`10` `01` `Rx` `Ry` `__` `__` `__` `__`	16-bit `Rx` = -`Ry`
`s_neg32`	`11` `01` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = -`Ry`
`s_neg64`	`12` `01` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = -`Ry`

i_abs

Finds the absolute value of the provided value

Name	Encoding	Description
`s_abs8`	`13` `01` `Rx` `Ry` `__` `__` `__` `__`	8-bit `Rx` = \|`Ry`\|
`s_abs16`	`14` `01` `Rx` `Ry` `__` `__` `__` `__`	16-bit `Rx` = \|`Ry`\|
`s_abs32`	`15` `01` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = \|`Ry`\|
`s_abs64`	`16` `01` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = \|`Ry`\|

i_add

Performs integer addition on the provided values.

Name	Encoding	Description
`i_add8`	`17` `01` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit `Rx` = `Ry` + `Rz`
`i_add16`	`18` `01` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit `Rx` = `Ry` + `Rz`
`i_add32`	`19` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` + `Rz`
`i_add64`	`1a` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` + `Rz`
`i_add8c`	`1b` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit `Rx` = `Ry` + `I`
`i_add16c`	`1c` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit `Rx` = `Ry` + `I`
`i_add32c`	`1d` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` + `I`
`i_add64c`	`1e` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` + `I`

i_sub

Performs integer subtraction on the provided values.

Name	Encoding	Description
`i_sub8`	`1f` `01` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit `Rx` = `Ry` - `Rz`
`i_sub16`	`20` `01` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit `Rx` = `Ry` - `Rz`
`i_sub32`	`21` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` - `Rz`
`i_sub64`	`22` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` - `Rz`
`i_sub8a`	`23` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit `Rx` = `I` - `Ry`
`i_sub16a`	`24` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit `Rx` = `I` - `Ry`
`i_sub32a`	`25` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `I` - `Ry`
`i_sub64a`	`26` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `I` - `Ry`
`i_sub8b`	`27` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit `Rx` = `Ry` - `I`
`i_sub16b`	`28` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit `Rx` = `Ry` - `I`
`i_sub32b`	`29` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` - `I`
`i_sub64b`	`2a` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` - `I`

i_mul

Performs integer multiplication on the provided values.

Name	Encoding	Description
`i_mul8`	`2b` `01` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit `Rx` = `Ry` * `Rz`
`i_mul16`	`2c` `01` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit `Rx` = `Ry` * `Rz`
`i_mul32`	`2d` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` * `Rz`
`i_mul64`	`2e` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` * `Rz`
`i_mul8c`	`2f` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit `Rx` = `Ry` * `I`
`i_mul16c`	`30` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit `Rx` = `Ry` * `I`
`i_mul32c`	`31` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` * `I`
`i_mul64c`	`32` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` * `I`

i_div

Performs integer division on the provided values.

Name	Encoding	Description
`u_div8`	`33` `01` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit unsigned `Rx` = `Ry` / `Rz`
`u_div16`	`34` `01` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit unsigned `Rx` = `Ry` / `Rz`
`u_div32`	`35` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit unsigned `Rx` = `Ry` / `Rz`
`u_div64`	`36` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit unsigned `Rx` = `Ry` / `Rz`
`u_div8a`	`37` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned `Rx` = `I` / `Ry`
`u_div16a`	`38` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned `Rx` = `I` / `Ry`
`u_div32a`	`39` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned `Rx` = `I` / `Ry`
`u_div64a`	`3a` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned `Rx` = `I` / `Ry`
`u_div8b`	`3b` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned `Rx` = `Ry` / `I`
`u_div16b`	`3c` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned `Rx` = `Ry` / `I`
`u_div32b`	`3d` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned `Rx` = `Ry` / `I`
`u_div64b`	`3e` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned `Rx` = `Ry` / `I`
`s_div8`	`3f` `01` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit signed `Rx` = `Ry` / `Rz`
`s_div16`	`40` `01` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit signed `Rx` = `Ry` / `Rz`
`s_div32`	`41` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit signed `Rx` = `Ry` / `Rz`
`s_div64`	`42` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit signed `Rx` = `Ry` / `Rz`
`s_div8a`	`43` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed `Rx` = `I` / `Ry`
`s_div16a`	`44` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed `Rx` = `I` / `Ry`
`s_div32a`	`45` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed `Rx` = `I` / `Ry`
`s_div64a`	`46` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed `Rx` = `I` / `Ry`
`s_div8b`	`47` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed `Rx` = `Ry` / `I`
`s_div16b`	`48` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed `Rx` = `Ry` / `I`
`s_div32b`	`49` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed `Rx` = `Ry` / `I`
`s_div64b`	`4a` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed `Rx` = `Ry` / `I`

i_rem

Gets the remainder of integer division on the provided values.

Name	Encoding	Description
`u_rem8`	`4b` `01` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit unsigned `Rx` = `Ry` % `Rz`
`u_rem16`	`4c` `01` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit unsigned `Rx` = `Ry` % `Rz`
`u_rem32`	`4d` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit unsigned `Rx` = `Ry` % `Rz`
`u_rem64`	`4e` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit unsigned `Rx` = `Ry` % `Rz`
`u_rem8a`	`4f` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned `Rx` = `I` % `Ry`
`u_rem16a`	`50` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned `Rx` = `I` % `Ry`
`u_rem32a`	`51` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned `Rx` = `I` % `Ry`
`u_rem64a`	`52` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned `Rx` = `I` % `Ry`
`u_rem8b`	`53` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit unsigned `Rx` = `Ry` % `I`
`u_rem16b`	`54` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit unsigned `Rx` = `Ry` % `I`
`u_rem32b`	`55` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit unsigned `Rx` = `Ry` % `I`
`u_rem64b`	`56` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit unsigned `Rx` = `Ry` % `I`
`s_rem8`	`57` `01` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit signed `Rx` = `Ry` % `Rz`
`s_rem16`	`58` `01` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit signed `Rx` = `Ry` % `Rz`
`s_rem32`	`59` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit signed `Rx` = `Ry` % `Rz`
`s_rem64`	`5a` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit signed `Rx` = `Ry` % `Rz`
`s_rem8a`	`5b` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed `Rx` = `I` % `Ry`
`s_rem16a`	`5c` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed `Rx` = `I` % `Ry`
`s_rem32a`	`5d` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed `Rx` = `I` % `Ry`
`s_rem64a`	`5e` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed `Rx` = `I` % `Ry`
`s_rem8b`	`5f` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit signed `Rx` = `Ry` % `I`
`s_rem16b`	`60` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit signed `Rx` = `Ry` % `I`
`s_rem32b`	`61` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit signed `Rx` = `Ry` % `I`
`s_rem64b`	`62` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit signed `Rx` = `Ry` % `I`

i_pow

Raises a provided value to the power of the other provided value.

Name	Encoding	Description
`i_pow8`	`63` `01` `Rx` `Ry` `Rz` `__` `__` `__`	8-bit `Rx` = `Ry` ** `Rz`
`i_pow16`	`64` `01` `Rx` `Ry` `Rz` `__` `__` `__`	16-bit `Rx` = `Ry` ** `Rz`
`i_pow32`	`65` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` ** `Rz`
`i_pow64`	`66` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` ** `Rz`
`i_pow8a`	`67` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit `Rx` = `I` ** `Ry`
`i_pow16a`	`68` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit `Rx` = `I` ** `Ry`
`i_pow32a`	`69` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `I` ** `Ry`
`i_pow64a`	`6a` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `I` ** `Ry`
`i_pow8b`	`6b` `01` `Rx` `Ry` `I.` `__` `__` `__`	8-bit `Rx` = `Ry` ** `I`
`i_pow16b`	`6c` `01` `Rx` `Ry` `I.` `..` `__` `__`	16-bit `Rx` = `Ry` ** `I`
`i_pow32b`	`6d` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` ** `I`
`i_pow64b`	`6e` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` ** `I`

Floating point arithmetic

Instructions that perform floating point arithmetic operations on values.

Where the size is < 64-bits, the least significant bits of the input value(s) are used and the remainder of the output value is zeroed

f_neg

Performs floating point negation on the provided value

Name	Encoding	Description
`f_neg32`	`6f` `01` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = -`Ry`
`f_neg64`	`70` `01` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = -`Ry`

f_abs

Performs a floating point absolute value operation on the provided value

Name	Encoding	Description
`f_abs32`	`71` `01` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = \|`Ry`\|
`f_abs64`	`72` `01` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = \|`Ry`\|

f_sqrt

Performs a square root operation on the provided value

Name	Encoding	Description
`f_sqrt32`	`73` `01` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = sqrt(`Ry`)
`f_sqrt64`	`74` `01` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = sqrt(`Ry`)

f_floor

Performs a flooring operation on the provided value

Name	Encoding	Description
`f_floor32`	`75` `01` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = floor(`Ry`)
`f_floor64`	`76` `01` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = floor(`Ry`)

f_ceil

Performs a ceiling operation on the provided value

Name	Encoding	Description
`f_ceil32`	`77` `01` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = ceil(`Ry`)
`f_ceil64`	`78` `01` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = ceil(`Ry`)

f_round

Performs a rounding operation on the provided value

Name	Encoding	Description
`f_round32`	`79` `01` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = round(`Ry`)
`f_round64`	`7a` `01` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = round(`Ry`)

f_trunc

Performs a truncation operation on the provided value

Name	Encoding	Description
`f_trunc32`	`7b` `01` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = truncate(`Ry`)
`f_trunc64`	`7c` `01` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = truncate(`Ry`)

f_whole

Extracts the whole number part of the provided value

Name	Encoding	Description
`f_whole32`	`7d` `01` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = whole(`Ry`)
`f_whole64`	`7e` `01` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = whole(`Ry`)

f_frac

Extracts the fractional part of the provided value

Name	Encoding	Description
`f_frac32`	`7f` `01` `Rx` `Ry` `__` `__` `__` `__`	32-bit `Rx` = frac(`Ry`)
`f_frac64`	`80` `01` `Rx` `Ry` `__` `__` `__` `__`	64-bit `Rx` = frac(`Ry`)

f_add

Performs floating point addition on the provided values

Name	Encoding	Description
`f_add32`	`81` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` + `Rz`
`f_add32c`	`82` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` + `I`
`f_add64`	`83` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` + `Rz`
`f_add64c`	`84` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` + `I`

f_sub

Performs floating point subtraction on the provided values

Name	Encoding	Description
`f_sub32`	`85` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` - `Rz`
`f_sub32a`	`86` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `I` - `Ry`
`f_sub32b`	`87` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` - `I`
`f_sub64`	`88` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` - `Rz`
`f_sub64a`	`89` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `I` - `Ry`
`f_sub64b`	`8a` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` - `I`

f_mul

Performs floating point multiplication on the provided values

Name	Encoding	Description
`f_mul32`	`8b` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` * `Rz`
`f_mul32c`	`8c` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` * `I`
`f_mul64`	`8d` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` * `Rz`
`f_mul64c`	`8e` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` * `I`

f_div

Performs floating point division on the provided values

Name	Encoding	Description
`f_div32`	`8f` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` / `Rz`
`f_div32a`	`90` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `I` / `Ry`
`f_div32b`	`91` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` / `I`
`f_div64`	`92` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` / `Rz`
`f_div64a`	`93` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `I` / `Ry`
`f_div64b`	`94` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` / `I`

f_rem

Gets the remainder of floating point division on the provided values

Name	Encoding	Description
`f_rem32`	`95` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` % `Rz`
`f_rem32a`	`96` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `I` % `Ry`
`f_rem32b`	`97` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` % `I`
`f_rem64`	`98` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` % `Rz`
`f_rem64a`	`99` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `I` % `Ry`
`f_rem64b`	`9a` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` % `I`

f_pow

Raises a provided value to the power of the other provided value

Name	Encoding	Description
`f_pow32`	`9b` `01` `Rx` `Ry` `Rz` `__` `__` `__`	32-bit `Rx` = `Ry` ** `Rz`
`f_pow32a`	`9c` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `I` ** `Ry`
`f_pow32b`	`9d` `01` `Rx` `Ry` `I.` `..` `..` `..`	32-bit `Rx` = `Ry` ** `I`
`f_pow64`	`9e` `01` `Rx` `Ry` `Rz` `__` `__` `__`	64-bit `Rx` = `Ry` ** `Rz`
`f_pow64a`	`9f` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `I` ** `Ry`
`f_pow64b`	`a0` `01` `Rx` `Ry` `__` `__` `__` `__` `I.` `..` `..` `..` `..` `..` `..` `..`	64-bit `Rx` = `Ry` ** `I`

Value conversion

Instructions that convert values between different bit representations

s_ext

Signed bit extension

Name	Encoding	Description
`s_ext8_16`	`a1` `01` `Rx` `Ry` `__` `__` `__` `__`	Sign extend 8-bits of `Ry` to 16-bits, placing the result in `Rx`
`s_ext8_32`	`a2` `01` `Rx` `Ry` `__` `__` `__` `__`	Sign extend 8-bits of `Ry` to 32-bits, placing the result in `Rx`
`s_ext8_64`	`a3` `01` `Rx` `Ry` `__` `__` `__` `__`	Sign extend 8-bits of `Ry` to 64-bits, placing the result in `Rx`
`s_ext16_32`	`a4` `01` `Rx` `Ry` `__` `__` `__` `__`	Sign extend 16-bits of `Ry` to 32-bits, placing the result in `Rx`
`s_ext16_64`	`a5` `01` `Rx` `Ry` `__` `__` `__` `__`	Sign extend 16-bits of `Ry` to 64-bits, placing the result in `Rx`
`s_ext32_64`	`a6` `01` `Rx` `Ry` `__` `__` `__` `__`	Sign extend 32-bits of `Ry` to 64-bits, placing the result in `Rx`

f_to_i

Convert floats to various integer representations.

Name	Encoding	Description
`f32_to_u8`	`a7` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert of 32-bit float in `Ry` to 8-bit integer; discards sign, places the result in `Rx`
`f32_to_u16`	`a8` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert of 32-bit float in `Ry` to 16-bit integer; discards sign, places the result in `Rx`
`f32_to_u32`	`a9` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert of 32-bit float in `Ry` to 32-bit integer; discards sign, places the result in `Rx`
`f32_to_u64`	`aa` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert of 32-bit float in `Ry` to 64-bit integer; discards sign, places the result in `Rx`
`f32_to_s8`	`ab` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert of 32-bit float in `Ry` to 8-bit integer; keeps sign, places the result in `Rx`
`f32_to_s16`	`ac` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert of 32-bit float in `Ry` to 16-bit integer; keeps sign, places the result in `Rx`
`f32_to_s32`	`ad` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert of 32-bit float in `Ry` to 32-bit integer; keeps sign, places the result in `Rx`
`f32_to_s64`	`ae` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert of 32-bit float in `Ry` to 64-bit integer; keeps sign, places the result in `Rx`

i_to_f

Convert various integers to float representations.

Information loss is possible if the integer’s most significant bit index is larger than the float’s mantissa bit size

Name	Encoding	Description
`u8_to_f32`	`af` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 8-bits in `Ry` to 32-bit float; discards sign, places result in `Rx`
`u16_to_f32`	`b0` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 16-bits in `Ry` to 32-bit float; discards sign, places result in `Rx`
`u32_to_f32`	`b1` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 32-bits in `Ry` to 32-bit float; discards sign, places result in `Rx`
`u64_to_f32`	`b2` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 64-bits in `Ry` to 32-bit float; discards sign, places result in `Rx`
`s8_to_f32`	`b3` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 8-bits in `Ry` to 32-bit float; keeps sign, places result in `Rx`
`s16_to_f32`	`b4` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 16-bits in `Ry` to 32-bit float; keeps sign, places result in `Rx`
`s32_to_f32`	`b5` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 32-bits in `Ry` to 32-bit float; keeps sign, places result in `Rx`
`s64_to_f32`	`b6` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 64-bits in `Ry` to 32-bit float; keeps sign, places result in `Rx`
`u8_to_f64`	`b7` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 8-bits in `Ry` to 64-bit float; discards sign, places result in `Rx`
`u16_to_f64`	`b8` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 16-bits in `Ry` to 64-bit float; discards sign, places result in `Rx`
`u32_to_f64`	`b9` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 32-bits in `Ry` to 64-bit float; discards sign, places result in `Rx`
`u64_to_f64`	`ba` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 64-bits in `Ry` to 64-bit float; discards sign, places result in `Rx`
`s8_to_f64`	`bb` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 8-bits in `Ry` to 64-bit float; keeps sign, places result in `Rx`
`s16_to_f64`	`bc` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 16-bits in `Ry` to 64-bit float; keeps sign, places result in `Rx`
`s32_to_f64`	`bd` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 32-bits in `Ry` to 64-bit float; keeps sign, places result in `Rx`
`s64_to_f64`	`be` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 64-bits in `Ry` to 64-bit float; keeps sign, places result in `Rx`

f_to_f

Floating point to floating point conversion

Name	Encoding	Description
`f32_to_f64`	`bf` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 32-bit float in `Ry` to 64-bit float; places the result in `Rx`
`f64_to_f32`	`c0` `01` `Rx` `Ry` `__` `__` `__` `__`	Convert 64-bit float in `Ry` to 32-bit float; places the result in `Rx`

Ribbon ISA v0.1.0 draft

Overview

Basic layout

Example

JIT-only Instructions

Encoding

Example

Immediate Operands

Example

Operand Types

Instructions

Miscellaneous

nop

breakpoint

Control flow

halt

trap

set

br

call

return

Memory

mem_set

mem_copy

mem_swap

addr

load

store

Bitwise

bit_swap

bit_copy

bit_clz

bit_pop

bit_not

bit_and

bit_or

bit_xor

bit_lshift

bit_rshift

Comparison

eq

ne

lt

gt

le

ge

Integer arithmetic

i_neg

i_abs

i_add

i_sub

i_mul

i_div

i_rem

i_pow

Floating point arithmetic

f_neg

f_abs

f_sqrt

f_floor

f_ceil

f_round

f_trunc

f_whole

f_frac

f_add

f_sub

f_mul

f_div

f_rem

f_pow

Value conversion

s_ext

f_to_i

i_to_f

f_to_f

Ribbon ISA v0.1.0 _draft