The Mill architecture is a wide issue architecure. This means each instruction contains multiple unique operations. On Gold Cores possibly more than 30.

When writing abstract assembly for the Mill architecture this doesn't really matter though. It is the specializer that determines the possible width from the abstract code and fits it into the available width of the concrete specific core.

The abstract view presents the operations that are available in unspecialized abstract assembly.

The generic view presents the operations available in specialized machine code.

In either case, the information is not specific to any particular Mill Core.

The whole table is generously supplied with tool tips.

The full operation names are anchors and can be directly linked.

The table can be sorted by operation, result, block and phase by clicking on the headers.

It is also possible to filter the rows by ctrl-double clicking on the cells in the block, phase, operation and variant columns.

Undo the filters on a value set by double clicking on another value of the set.

The last 5 columns can be collapsed and expanded again by ctrl-clicking the header.

And finally, jump over this introduction and go directly to the table with the #ops anchor.

all
abstract
generic
view link
| ||||||||||

! | operation | variant | parameters | ↲ | ? | operands | block | phase | description | native on |
---|---|---|---|---|---|---|---|---|---|---|

! | operation | variant | parameters | ↲ | ? | operands | block | phase | description | native on |

abortAtomic | 0 | : | flow | compute | abort an in-progress atomic extent | all | ||||

add1 | u | u x, u y | 1 | ? | [xx:x] | exu | compute | addition plus 1 , unsigned integer | all | |

add | de | d x, d y | 1 | ? | [dd:d] | exu | compute | addition , decimal floating point, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

add | dfz | d x, d y | 1 | ? | [dd:d] | exu | compute | addition , decimal floating point, to nearest, ties away from zero | Decimal8 Decimal16 | |

add | dn | d x, d y | 1 | ? | [dd:d] | exu | compute | addition , decimal floating point, toward negative infinity | Decimal8 Decimal16 | |

add | dp | d x, d y | 1 | ? | [dd:d] | exu | compute | addition , decimal floating point, toward positive infinity | Decimal8 Decimal16 | |

add | dz | d x, d y | 1 | ? | [dd:d] | exu | compute | addition , decimal floating point, toward zero | Decimal8 Decimal16 | |

add | d | d x, d y | 1 | ? | [dd:d] | exu | compute | addition , decimal floating point, use current dynamic rounding mode | Decimal8 Decimal16 | |

add | fe | f x, f y | 1 | ? | [ff:f] | exu | compute | addition , binary floating point, to nearest, ties toward even adjacent value | Gold Silver | |

add | ffz | f x, f y | 1 | ? | [ff:f] | exu | compute | addition , binary floating point, to nearest, ties away from zero | Gold Silver | |

add | fn | f x, f y | 1 | ? | [ff:f] | exu | compute | addition , binary floating point, toward negative infinity | Gold Silver | |

add | fp | f x, f y | 1 | ? | [ff:f] | exu | compute | addition , binary floating point, toward positive infinity | Gold Silver | |

add | fz | f x, f y | 1 | ? | [ff:f] | exu | compute | addition , binary floating point, toward zero | Gold Silver | |

add | f | f x, f y | 1 | ? | [ff:f] | exu | compute | addition , binary floating point, use current dynamic rounding mode | Gold Silver | |

add | p | p x, p y, scale s | 1 | [px:p] | exu | compute | addition , pointers | all | ||

add | p | p x, imm y, scale s | 1 | [px:p] | exu | compute | addition , pointers | all | ||

add | ssv | s x, s y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, saturating, vector | all | |

add | ssv | s x, imm y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, saturating, vector | all | |

add | ss | s x, imm y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, saturating, scalar | all | |

add | ss | s x, s y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, saturating, scalar | all | |

add | swv | s x, imm y | 2 | ? | XX:2X2X | exu | compute | addition , signed integer, widening, vector | all | |

add | swv | s x, s y | 2 | ? | XX:2X2X | exu | compute | addition , signed integer, widening, vector | all | |

add | sw | s x, s y | 1 | ? | xx:2x | exu | compute | addition , signed integer, widening, scalar | all | |

add | sw | s x, imm y | 1 | ? | xx:2x | exu | compute | addition , signed integer, widening, scalar | all | |

add | sxv | s x, s y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, excepting, vector | all | |

add | sxv | s x, imm y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, excepting, vector | all | |

add | sx | s x, s y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, excepting, scalar | all | |

add | sx | s x, imm y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, excepting, scalar | all | |

add | s v | s x, s y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, modulo, vector | all | |

add | s v | s x, imm y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, modulo, vector | all | |

add | s | s x, imm y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, modulo, scalar | all | |

add | s | s x, s y | 1 | ? | [xx:x] | exu | compute | addition , signed integer, modulo, scalar | all | |

add | usv | u x, u y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, saturating, vector | all | |

add | usv | u x, imm y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, saturating, vector | all | |

add | us | u x, u y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, saturating, scalar | all | |

add | us | u x, imm y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, saturating, scalar | all | |

add | uwv | u x, imm y | 2 | ? | XX:2X2X | exu | compute | addition , unsigned integer, widening, vector | all | |

add | uwv | u x, u y | 2 | ? | XX:2X2X | exu | compute | addition , unsigned integer, widening, vector | all | |

add | uw | u x, imm y | 1 | ? | xx:2x | exu | compute | addition , unsigned integer, widening, scalar | all | |

add | uw | u x, u y | 1 | ? | xx:2x | exu | compute | addition , unsigned integer, widening, scalar | all | |

add | uxv | u x, imm y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, excepting, vector | all | |

add | uxv | u x, u y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, excepting, vector | all | |

add | ux | u x, imm y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, excepting, scalar | all | |

add | ux | u x, u y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, excepting, scalar | all | |

add | u v | u x, imm y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, modulo, vector | all | |

add | u v | u x, u y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, modulo, vector | all | |

add | u | u x, imm y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, modulo, scalar | all | |

add | u | u x, u y | 1 | ? | [xx:x] | exu | compute | addition , unsigned integer, modulo, scalar | all | |

add | op x, imm y | 1 | ? | [xx:x] | exu | compute | addition , logical | all | ||

add | op x, op y | 1 | ? | [xx:x] | exu | compute | addition , logical | all | ||

! | allocStack | op v | 0 | : | flow | compute | allocate more memory in the current stack frame | none | ||

all | op v | 1 | XX:i | exu | compute | vector AND reduction , logical | all | |||

alternate | op v1, op v2 | 2 | XX:XX | exu | compute | interlace two vectors , logical | all | |||

andl | s | s x, imm y | 1 | ? | [xx:x] | exu | compute | bitwise and , signed integer | all | |

andl | s | s x, s y | 1 | ? | [xx:x] | exu | compute | bitwise and , signed integer | all | |

andl | u | u x, u y | 1 | ? | [xx:x] | exu | compute | bitwise and , unsigned integer | all | |

andl | u | u x, imm y | 1 | ? | [xx:x] | exu | compute | bitwise and , unsigned integer | all | |

andl | op x, imm y | 1 | ? | [xx:x] | exu | compute | bitwise and , logical | all | ||

andl | op x, op y | 1 | ? | [xx:x] | exu | compute | bitwise and , logical | all | ||

any | op v | 1 | XX:i | exu | compute | vector OR reduction , logical | all | |||

argSize | off size | 0 | : | flow | compute | set size of memory argument block for following dynCall | all | |||

BID2 | d | d x | 1 | [dd:d] | exu | compute | decimal format conversion , decimal floating point | Decimal8 Decimal16 | ||

! | br | fl | pred q, lbl target, lit delay | 0 | : | flow | transfer | branch , taken if false | all | |

! | br | fl | pred q, p target | 0 | : | flow | transfer | branch , taken if false | all | |

! | br | fl | pred q, p target, lit delay | 0 | : | flow | transfer | branch , taken if false | all | |

! | br | fl | pred q, lbl target | 0 | : | flow | transfer | branch , taken if false | all | |

! | br | tr | pred q, lbl target | 0 | : | flow | transfer | branch , taken if true | all | |

! | br | tr | pred q, p target, lit delay | 0 | : | flow | transfer | branch , taken if true | all | |

! | br | tr | pred q, lbl target, lit delay | 0 | : | flow | transfer | branch , taken if true | all | |

! | br | tr | pred q, p target | 0 | : | flow | transfer | branch , taken if true | all | |

! | br | lbl target, lit delay | 0 | : | flow | transfer | branch , taken unconditionally | all | ||

! | br | lbl target | 0 | : | flow | transfer | branch , taken unconditionally | all | ||

! | br | p target | 0 | : | flow | transfer | branch , taken unconditionally | all | ||

! | br | p target, lit delay | 0 | : | flow | transfer | branch , taken unconditionally | all | ||

! | cache | bcl | p lower, p upper | 0 | : | flow | compute | cache control operation , Load entire code range to lowest on-chip cache | all | |

! | cache | bdl | p lower, p upper | 0 | : | flow | compute | cache control operation , Load entire data range to lowest on-chip cache | all | |

! | cache | d | p lower, p upper | 0 | : | flow | compute | cache control operation , duplicate cache line to new address | all | |

! | cache | d | p lower, p upper, p base | 0 | : | flow | compute | cache control operation , duplicate cache line to new address | all | |

! | cache | e | p lower, p upper | 0 | : | flow | compute | cache control operation , evict cache line to memory | all | |

! | cache | e | p line | 0 | : | flow | compute | cache control operation , evict cache line to memory | all | |

! | cache | x | p line | 0 | : | flow | compute | cache control operation , discard cache line without flush | all | |

! | cache | x | p lower, p upper | 0 | : | flow | compute | cache control operation , discard cache line without flush | all | |

! | call_{3} | fl0 | op q, off target, count argc, lit argv, lit argv | 0 | : | flow | call | function call , taken if false, no result | all | |

! | call_{2} | fl0 | op q, off target, count argc, lit argv | 0 | : | flow | call | function call , taken if false, no result | all | |

! | call_{1} | fl0 | op q, p target, off argv, count argc | 0 | : | flow | call | function call , taken if false, no result | all | |

! | call_{2} | fl0 | op q, p target, off argv, count argc, lit argv | 0 | : | flow | call | function call , taken if false, no result | all | |

! | call_{1} | fl0 | op q, off target, count argc | 0 | : | flow | call | function call , taken if false, no result | all | |

! | call_{*} | fl0 | op q, p target, args args | 0 | : | flow | call | function call , taken if false, no result | all | |

! | call_{*} | fl0 | op q, lbl target, args args | 0 | : | flow | call | function call , taken if false, no result | all | |

! | call_{1} | fl1 | op q, p target, off argv, count argc | 1 | : | flow | call | function call , taken if false, one result | all | |

! | call_{2} | fl1 | op q, p target, off argv, count argc, lit argv | 1 | : | flow | call | function call , taken if false, one result | all | |

! | call_{1} | fl1 | op q, off target, count argc | 1 | : | flow | call | function call , taken if false, one result | all | |

! | call_{2} | fl1 | op q, off target, count argc, lit argv | 1 | : | flow | call | function call , taken if false, one result | all | |

! | call_{3} | fl1 | op q, off target, count argc, lit argv, lit argv | 1 | : | flow | call | function call , taken if false, one result | all | |

! | call_{*} | fl1 | op q, p target, args args | 1 | : | flow | call | function call , taken if false, one result | all | |

! | call_{*} | fl1 | op q, lbl target, args args | 1 | : | flow | call | function call , taken if false, one result | all | |

! | call | fln | op q, lit n, p target, off argc, count args | n | : | flow | call | function call , taken if false, more than one result | all | |

! | call_{2} | fln | op q, lit n, off target, count argc, lit argv | n | : | flow | call | function call , taken if false, more than one result | all | |

! | call_{1} | fln | op q, lit n, off target, count argc | n | : | flow | call | function call , taken if false, more than one result | all | |

! | call_{*} | fln | op q, lit n, lbl target, args args | n | : | flow | call | function call , taken if false, more than one result | all | |

! | call | fln | op q, lit n, p target, args args | n | : | flow | call | function call , taken if false, more than one result | all | |

! | call | fl | op q, lit n, p target, off argc, count args | * | : | flow | call | function call , taken if false, any number of results | all | |

! | call | fl | op q, lit n, off target, count argc, lit argv | * | : | flow | call | function call , taken if false, any number of results | all | |

! | call | fl | op q, lit n, off target, count argc | * | : | flow | call | function call , taken if false, any number of results | all | |

! | call_{*} | fl | op q, lit n, lbl target, args args | * | : | flow | call | function call , taken if false, any number of results | all | |

! | call_{*} | fl | op q, lit n, p target, args args | * | : | flow | call | function call , taken if false, any number of results | all | |

! | call_{1} | tr0 | op q, off target, count argc | 0 | : | flow | call | function call , taken if true, no result | all | |

! | call_{1} | tr0 | op q, p target, off argv, count argc | 0 | : | flow | call | function call , taken if true, no result | all | |

! | call_{2} | tr0 | op q, p target, off argv, count argc, lit argv | 0 | : | flow | call | function call , taken if true, no result | all | |

! | call_{3} | tr0 | op q, off target, count argc, lit argv, lit argv | 0 | : | flow | call | function call , taken if true, no result | all | |

! | call_{2} | tr0 | op q, off target, count argc, lit argv | 0 | : | flow | call | function call , taken if true, no result | all | |

! | call_{*} | tr0 | op q, lbl target, args args | 0 | : | flow | call | function call , taken if true, no result | all | |

! | call_{*} | tr0 | op q, p target, args args | 0 | : | flow | call | function call , taken if true, no result | all | |

! | call_{2} | tr1 | op q, p target, off argv, count argc, lit argv | 1 | : | flow | call | function call , taken if true, one result | all | |

! | call_{3} | tr1 | op q, off target, count argc, lit argv, lit argv | 1 | : | flow | call | function call , taken if true, one result | all | |

! | call_{2} | tr1 | op q, off target, count argc, lit argv | 1 | : | flow | call | function call , taken if true, one result | all | |

! | call_{1} | tr1 | op q, p target, off argv, count argc | 1 | : | flow | call | function call , taken if true, one result | all | |

! | call_{1} | tr1 | op q, off target, count argc | 1 | : | flow | call | function call , taken if true, one result | all | |

! | call_{*} | tr1 | op q, p target, args args | 1 | : | flow | call | function call , taken if true, one result | all | |

! | call_{*} | tr1 | op q, lbl target, args args | 1 | : | flow | call | function call , taken if true, one result | all | |

! | call | trn | op q, lit n, p target, off argc, count args | n | : | flow | call | function call , taken if true, more than one result | all | |

! | call_{2} | trn | op q, lit n, off target, count argc, lit argv | n | : | flow | call | function call , taken if true, more than one result | all | |

! | call_{1} | trn | op q, lit n, off target, count argc | n | : | flow | call | function call , taken if true, more than one result | all | |

! | call_{*} | trn | op q, lit n, lbl target, args args | n | : | flow | call | function call , taken if true, more than one result | all | |

! | call | trn | op q, lit n, p target, args args | n | : | flow | call | function call , taken if true, more than one result | all | |

! | call | tr | op q, lit n, off target, count argc | * | : | flow | call | function call , taken if true, any number of results | all | |

! | call | tr | op q, lit n, p target, off argc, count args | * | : | flow | call | function call , taken if true, any number of results | all | |

! | call | tr | op q, lit n, off target, count argc, lit argv | * | : | flow | call | function call , taken if true, any number of results | all | |

! | call_{*} | tr | op q, lit n, p target, args args | * | : | flow | call | function call , taken if true, any number of results | all | |

! | call_{*} | tr | op q, lit n, lbl target, args args | * | : | flow | call | function call , taken if true, any number of results | all | |

! | call_{4} | 0 | off target, count argc, lit argv, lit argv, lit argv | 0 | : | flow | call | function call , taken unconditionally, no result | all | |

! | call_{3} | 0 | off target, count argc, lit argv, lit argv | 0 | : | flow | call | function call , taken unconditionally, no result | all | |

! | call_{3} | 0 | op q, off target, count argc, lit argv, lit argv | 0 | : | flow | call | function call , taken unconditionally, no result | all | |

! | call_{2} | 0 | op q, off target, count argc, lit argv | 0 | : | flow | call | function call , taken unconditionally, no result | all | |

! | call_{2} | 0 | off target, count argc, lit argv | 0 | : | flow | call | function call , taken unconditionally, no result | all | |

! | call_{1} | 0 | op q, off target, count argc | 0 | : | flow | call | function call , taken unconditionally, no result | all | |

! | call_{1} | 0 | off target, count argc | 0 | : | flow | call | function call , taken unconditionally, no result | all | |

! | call_{*} | 0 | p target, args args | 0 | : | flow | call | function call , taken unconditionally, no result | all | |

! | call_{*} | 0 | lbl target, args args | 0 | : | flow | call | function call , taken unconditionally, no result | all | |

! | call_{4} | 1 | off target, count argc, lit argv, lit argv, lit argv | 1 | : | flow | call | function call , taken unconditionally, one result | all | |

! | call_{3} | 1 | off target, count argc, lit argv, lit argv | 1 | : | flow | call | function call , taken unconditionally, one result | all | |

! | call_{2} | 1 | off target, count argc, lit argv | 1 | : | flow | call | function call , taken unconditionally, one result | all | |

! | call_{1} | 1 | off target, count argc | 1 | : | flow | call | function call , taken unconditionally, one result | all | |

! | call_{1} | 1 | op q, off target, count argc | 1 | : | flow | call | function call , taken unconditionally, one result | all | |

! | call_{2} | 1 | op q, off target, count argc, lit argv | 1 | : | flow | call | function call , taken unconditionally, one result | all | |

! | call_{3} | 1 | op q, off target, count argc, lit argv, lit argv | 1 | : | flow | call | function call , taken unconditionally, one result | all | |

! | call_{*} | 1 | lbl target, args args | 1 | : | flow | call | function call , taken unconditionally, one result | all | |

! | call_{*} | 1 | p target, args args | 1 | : | flow | call | function call , taken unconditionally, one result | all | |

! | call_{2} | n | lit n, p target, off argv, count argc, lit argv | n | : | flow | call | function call , taken unconditionally, more than one result | all | |

! | call_{1} | n | lit n, p target, off argv, count argc | n | : | flow | call | function call , taken unconditionally, more than one result | all | |

! | call_{1} | n | lit n, off target, count argc | n | : | flow | call | function call , taken unconditionally, more than one result | all | |

! | call_{2} | n | lit n, off target, count argc, lit argv | n | : | flow | call | function call , taken unconditionally, more than one result | all | |

! | call_{3} | n | lit n, off target, count argc, lit argv, lit argv | n | : | flow | call | function call , taken unconditionally, more than one result | all | |

! | call_{*} | n | lit n, p target, args args | n | : | flow | call | function call , taken unconditionally, more than one result | all | |

! | call_{*} | n | lit n, lbl target, args args | n | : | flow | call | function call , taken unconditionally, more than one result | all | |

! | call | lit n, off target, count argc | * | : | flow | call | function call , taken unconditionally, any number of results | all | ||

! | call | lit n, off target, count argc, lit argv | * | : | flow | call | function call , taken unconditionally, any number of results | all | ||

! | call | lit n, p target, off argv, count argc | * | : | flow | call | function call , taken unconditionally, any number of results | all | ||

! | call | lit n, off target, count argc, lit argv, lit argv | * | : | flow | call | function call , taken unconditionally, any number of results | all | ||

! | call | lit n, p target, off argv, count argc, lit argv | * | : | flow | call | function call , taken unconditionally, any number of results | all | ||

! | call_{*} | lit n, p target, args args | * | : | flow | call | function call , taken unconditionally, any number of results | all | ||

! | call_{*} | lit n, lbl target, args args | * | : | flow | call | function call , taken unconditionally, any number of results | all | ||

carry | conditioncode | 1 | [xx:x] | exu | compute | carry/borrow gang predicate , logical | all | |||

classify | d | d x | 1 | [dd:d] | exu | compute | floating point kind , decimal floating point | Decimal8 Decimal16 | ||

classify | f | f x | 1 | [ff:f] | exu | compute | floating point kind , binary floating point | Gold Silver | ||

clear | op x, bit bit | 1 | [xi:x] | exu | compute | bit reset , logical | all | |||

clear | op x, op bit | 1 | [xi:x] | exu | compute | bit reset , logical | all | |||

con_{4} | off v, width w, lit v, lit v, lit v | 1 | xx:x | flow | reader | immediate constant | all | |||

con_{3} | off v, width w, lit v, lit v | 1 | xx:x | flow | reader | immediate constant | all | |||

con_{2} | off v, width w, lit v | 1 | xx:x | flow | reader | immediate constant | all | |||

con_{1} | off v, width w | 1 | xx:x | flow | reader | immediate constant | all | |||

con_{*} | constant v | 1 | xx:x | flow | reader | immediate constant | all | |||

conform_{2} | off ops, count c, lit ops | * | : | flow | conform | normalize belt contents to argument list | all | |||

conform_{3} | off ops, count c, lit ops, lit ops | * | : | flow | conform | normalize belt contents to argument list | all | |||

conform_{1} | off ops, count c | * | : | flow | conform | normalize belt contents to argument list | all | |||

conform_{4} | off ops, count c, lit ops, lit ops, lit ops | * | : | flow | conform | normalize belt contents to argument list | all | |||

conform_{*} | ops args | * | : | flow | conform | normalize belt contents to argument list | all | |||

count | l fl | op x | 1 | [xx:x] | exu | compute | number of bits before condition , toward greater significance, logical, taken if false | all | ||

count | l tr | op x | 1 | [xx:x] | exu | compute | number of bits before condition , toward greater significance, logical, taken if true | all | ||

count | r fl | op x | 1 | [xx:x] | exu | compute | number of bits before condition , toward lesser significance, logical, taken if false | all | ||

count | r tr | op x | 1 | [xx:x] | exu | compute | number of bits before condition , toward lesser significance, logical, taken if true | all | ||

d2BID | op x | 1 | [xx:x] | exu | compute | decimal format conversion , logical | none | |||

d2DPD | op x | 1 | [xx:x] | exu | compute | decimal format conversion , logical | none | |||

delta | op x, op y | 1 | [pp:p] | exu | compute | distance between pointers , logical | all | |||

div | de | d x, d y | 1 | ? | [dd:d] | exu | compute | divide for quotient , decimal floating point, to nearest, ties toward even adjacent value | none | |

div | dfz | d x, d y | 1 | ? | [dd:d] | exu | compute | divide for quotient , decimal floating point, to nearest, ties away from zero | none | |

div | dn | d x, d y | 1 | ? | [dd:d] | exu | compute | divide for quotient , decimal floating point, toward negative infinity | none | |

div | dp | d x, d y | 1 | ? | [dd:d] | exu | compute | divide for quotient , decimal floating point, toward positive infinity | none | |

div | dz | d x, d y | 1 | ? | [dd:d] | exu | compute | divide for quotient , decimal floating point, toward zero | none | |

div | d | d x, d y | 1 | ? | [dd:d] | exu | compute | divide for quotient , decimal floating point, use current dynamic rounding mode | none | |

div | fe | f x, f y | 1 | ? | [ff:f] | exu | compute | divide for quotient , binary floating point, to nearest, ties toward even adjacent value | none | |

div | ffz | f x, f y | 1 | ? | [ff:f] | exu | compute | divide for quotient , binary floating point, to nearest, ties away from zero | none | |

div | fn | f x, f y | 1 | ? | [ff:f] | exu | compute | divide for quotient , binary floating point, toward negative infinity | none | |

div | fp | f x, f y | 1 | ? | [ff:f] | exu | compute | divide for quotient , binary floating point, toward positive infinity | none | |

div | fz | f x, f y | 1 | ? | [ff:f] | exu | compute | divide for quotient , binary floating point, toward zero | none | |

div | f | f x, f y | 1 | ? | [ff:f] | exu | compute | divide for quotient , binary floating point, use current dynamic rounding mode | none | |

divRem | s | s x, imm y | 2 | ? | [xx:xx] | exu | compute | divide for quotient and remainder , signed integer | Silver | |

divRem | s | s x, s y | 2 | ? | [xx:xx] | exu | compute | divide for quotient and remainder , signed integer | Silver | |

divRem | u | u x, imm y | 2 | ? | [xx:xx] | exu | compute | divide for quotient and remainder , unsigned integer | Silver | |

divRem | u | u x, u y | 2 | ? | [xx:xx] | exu | compute | divide for quotient and remainder , unsigned integer | Silver | |

div | s | s x, s y | 1 | ? | [xx:x] | exu | compute | divide for quotient , signed integer | Silver | |

div | s | s x, imm y | 1 | [xx:x] | exu | compute | divide for quotient , signed integer | Silver | ||

div | u | u x, u y | 1 | ? | [xx:x] | exu | compute | divide for quotient , unsigned integer | Silver | |

div | u | u x, imm y | 1 | [xx:x] | exu | compute | divide for quotient , unsigned integer | Silver | ||

DPD2 | d | d x | 1 | [dd:d] | exu | compute | decimal format conversion , decimal floating point | Decimal8 Decimal16 | ||

enterAtomic | 0 | : | flow | compute | begin a new optimistic atomic extent | all | ||||

eql | dx | d x, d y | 1 | [dd:d] | exu | compute | equal , decimal floating point, NaN-aware | Decimal8 Decimal16 | ||

eql | d | d x, d y | 1 | [dd:d] | exu | compute | equal , decimal floating point, NaN-unaware | Decimal8 Decimal16 | ||

eql | fx | f x, f y | 1 | [ff:f] | exu | compute | equal , binary floating point, NaN-aware | Gold Silver | ||

eql | f | f x, f y | 1 | [ff:f] | exu | compute | equal , binary floating point, NaN-unaware | Gold Silver | ||

eql | p | p x, p y | 1 | [pp:p] | exu | compute | equal , pointers | all | ||

eql | p | conditioncode | 1 | [pp:p] | exuSkinny | compute | equal , pointers | all | ||

eql | s | s x, imm y | 1 | [xx:x] | exu | compute | equal , signed integer | all | ||

eql | s | s x, s y | 1 | [xx:x] | exu | compute | equal , signed integer | all | ||

eql | u | u x, u y | 1 | [xx:x] | exu | compute | equal , unsigned integer | all | ||

eql | u | u x, imm y | 1 | [xx:x] | exu | compute | equal , unsigned integer | all | ||

eql | op x, imm y | 1 | [xx:x] | exu | compute | equal , logical | all | |||

eql | op x, op y | 1 | [xx:x] | exu | compute | equal , logical | all | |||

eql | conditioncode | 1 | [xx:x] | exu | compute | equal , logical | all | |||

eql | conditioncode | 1 | [xx:x] | exuSkinny | compute | equal , logical | all | |||

exitAtomic | 0 | : | flow | compute | commit an in-progress atomic extent and return status | all | ||||

exscratchf | off size | 0 | : | flow | compute | allocate extended scratchpad space in memory | all | |||

extract | op v, imm i | 1 | XX:x | exu | compute | extract a scalar element from a vector | all | |||

extract | op v, i i | 1 | Xx:x | exu | compute | extract a scalar element from a vector | all | |||

exuArgs | op arg | 0 | : | exu | compute | additional slot for ganged exu operation | all | |||

exuArgs_{2} | op arg0, op arg1 | 0 | : | exu | compute | additional slot for ganged exu operation | all | |||

f2f | de | d x | 1 | [dd:d] | exu | compute | convert binary float to decimal float and vice versa , decimal floating point, to nearest, ties toward even adjacent value | none | ||

f2f | dfz | d x | 1 | [dd:d] | exu | compute | convert binary float to decimal float and vice versa , decimal floating point, to nearest, ties away from zero | none | ||

f2f | dn | d x | 1 | [dd:d] | exu | compute | convert binary float to decimal float and vice versa , decimal floating point, toward negative infinity | none | ||

f2f | dp | d x | 1 | [dd:d] | exu | compute | convert binary float to decimal float and vice versa , decimal floating point, toward positive infinity | none | ||

f2f | dz | d x | 1 | [dd:d] | exu | compute | convert binary float to decimal float and vice versa , decimal floating point, toward zero | none | ||

f2f | d | d x | 1 | [dd:d] | exu | compute | convert binary float to decimal float and vice versa , decimal floating point, use current dynamic rounding mode | none | ||

f2f | fe | f x | 1 | [ff:f] | exu | compute | convert binary float to decimal float and vice versa , binary floating point, to nearest, ties toward even adjacent value | none | ||

f2f | ffz | f x | 1 | [ff:f] | exu | compute | convert binary float to decimal float and vice versa , binary floating point, to nearest, ties away from zero | none | ||

f2f | fn | f x | 1 | [ff:f] | exu | compute | convert binary float to decimal float and vice versa , binary floating point, toward negative infinity | none | ||

f2f | fp | f x | 1 | [ff:f] | exu | compute | convert binary float to decimal float and vice versa , binary floating point, toward positive infinity | none | ||

f2f | fz | f x | 1 | [ff:f] | exu | compute | convert binary float to decimal float and vice versa , binary floating point, toward zero | none | ||

f2f | f | f x | 1 | [ff:f] | exu | compute | convert binary float to decimal float and vice versa , binary floating point, use current dynamic rounding mode | none | ||

f2s | edse | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, saturating, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2s | edsfz | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, saturating, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2s | edsn | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, saturating, toward negative infinity | Decimal8 Decimal16 | |

f2s | edsp | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, saturating, toward positive infinity | Decimal8 Decimal16 | |

f2s | edsz | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, saturating, toward zero | Decimal8 Decimal16 | |

f2s | eds | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, saturating, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2s | edxe | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, excepting, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2s | edxfz | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, excepting, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2s | edxn | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, excepting, toward negative infinity | Decimal8 Decimal16 | |

f2s | edxp | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, excepting, toward positive infinity | Decimal8 Decimal16 | |

f2s | edxz | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, excepting, toward zero | Decimal8 Decimal16 | |

f2s | edx | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, excepting, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2s | ed e | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, modulo, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2s | ed fz | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, modulo, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2s | ed n | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, modulo, toward negative infinity | Decimal8 Decimal16 | |

f2s | ed p | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, modulo, toward positive infinity | Decimal8 Decimal16 | |

f2s | ed z | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, modulo, toward zero | Decimal8 Decimal16 | |

f2s | ed | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , exact, decimal floating point, modulo, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2s | efse | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, saturating, to nearest, ties toward even adjacent value | Gold Silver | |

f2s | efsfz | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, saturating, to nearest, ties away from zero | Gold Silver | |

f2s | efsn | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, saturating, toward negative infinity | Gold Silver | |

f2s | efsp | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, saturating, toward positive infinity | Gold Silver | |

f2s | efsz | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, saturating, toward zero | Gold Silver | |

f2s | efs | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, saturating, use current dynamic rounding mode | Gold Silver | |

f2s | efxe | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, excepting, to nearest, ties toward even adjacent value | Gold Silver | |

f2s | efxfz | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, excepting, to nearest, ties away from zero | Gold Silver | |

f2s | efxn | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, excepting, toward negative infinity | Gold Silver | |

f2s | efxp | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, excepting, toward positive infinity | Gold Silver | |

f2s | efxz | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, excepting, toward zero | Gold Silver | |

f2s | efx | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, excepting, use current dynamic rounding mode | Gold Silver | |

f2s | ef e | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, modulo, to nearest, ties toward even adjacent value | Gold Silver | |

f2s | ef fz | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, modulo, to nearest, ties away from zero | Gold Silver | |

f2s | ef n | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, modulo, toward negative infinity | Gold Silver | |

f2s | ef p | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, modulo, toward positive infinity | Gold Silver | |

f2s | ef z | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, modulo, toward zero | Gold Silver | |

f2s | ef | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , exact, binary floating point, modulo, use current dynamic rounding mode | Gold Silver | |

f2s | dse | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, saturating, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2s | dsfz | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, saturating, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2s | dsn | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, saturating, toward negative infinity | Decimal8 Decimal16 | |

f2s | dsp | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, saturating, toward positive infinity | Decimal8 Decimal16 | |

f2s | dsz | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, saturating, toward zero | Decimal8 Decimal16 | |

f2s | ds | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, saturating, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2s | dxe | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, excepting, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2s | dxfz | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, excepting, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2s | dxn | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, excepting, toward negative infinity | Decimal8 Decimal16 | |

f2s | dxp | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, excepting, toward positive infinity | Decimal8 Decimal16 | |

f2s | dxz | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, excepting, toward zero | Decimal8 Decimal16 | |

f2s | dx | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, excepting, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2s | d e | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, modulo, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2s | d fz | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, modulo, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2s | d n | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, modulo, toward negative infinity | Decimal8 Decimal16 | |

f2s | d p | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, modulo, toward positive infinity | Decimal8 Decimal16 | |

f2s | d z | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, modulo, toward zero | Decimal8 Decimal16 | |

f2s | d | d x | 1 | ? | [dd:d] | exu | compute | convert float to signed integer , inexact, decimal floating point, modulo, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2s | fse | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, saturating, to nearest, ties toward even adjacent value | Gold Silver | |

f2s | fsfz | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, saturating, to nearest, ties away from zero | Gold Silver | |

f2s | fsn | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, saturating, toward negative infinity | Gold Silver | |

f2s | fsp | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, saturating, toward positive infinity | Gold Silver | |

f2s | fsz | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, saturating, toward zero | Gold Silver | |

f2s | fs | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, saturating, use current dynamic rounding mode | Gold Silver | |

f2s | fxe | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, excepting, to nearest, ties toward even adjacent value | Gold Silver | |

f2s | fxfz | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, excepting, to nearest, ties away from zero | Gold Silver | |

f2s | fxn | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, excepting, toward negative infinity | Gold Silver | |

f2s | fxp | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, excepting, toward positive infinity | Gold Silver | |

f2s | fxz | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, excepting, toward zero | Gold Silver | |

f2s | fx | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, excepting, use current dynamic rounding mode | Gold Silver | |

f2s | f e | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, modulo, to nearest, ties toward even adjacent value | Gold Silver | |

f2s | f fz | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, modulo, to nearest, ties away from zero | Gold Silver | |

f2s | f n | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, modulo, toward negative infinity | Gold Silver | |

f2s | f p | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, modulo, toward positive infinity | Gold Silver | |

f2s | f z | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, modulo, toward zero | Gold Silver | |

f2s | f | f x | 1 | ? | [ff:f] | exu | compute | convert float to signed integer , inexact, binary floating point, modulo, use current dynamic rounding mode | Gold Silver | |

f2u | edse | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, saturating, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2u | edsfz | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, saturating, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2u | edsn | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, saturating, toward negative infinity | Decimal8 Decimal16 | |

f2u | edsp | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, saturating, toward positive infinity | Decimal8 Decimal16 | |

f2u | edsz | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, saturating, toward zero | Decimal8 Decimal16 | |

f2u | eds | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, saturating, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2u | edxe | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, excepting, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2u | edxfz | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, excepting, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2u | edxn | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, excepting, toward negative infinity | Decimal8 Decimal16 | |

f2u | edxp | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, excepting, toward positive infinity | Decimal8 Decimal16 | |

f2u | edxz | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, excepting, toward zero | Decimal8 Decimal16 | |

f2u | edx | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, excepting, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2u | ed e | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, modulo, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2u | ed fz | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, modulo, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2u | ed n | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, modulo, toward negative infinity | Decimal8 Decimal16 | |

f2u | ed p | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, modulo, toward positive infinity | Decimal8 Decimal16 | |

f2u | ed z | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, modulo, toward zero | Decimal8 Decimal16 | |

f2u | ed | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , exact, decimal floating point, modulo, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2u | efse | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, saturating, to nearest, ties toward even adjacent value | Gold Silver | |

f2u | efsfz | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, saturating, to nearest, ties away from zero | Gold Silver | |

f2u | efsn | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, saturating, toward negative infinity | Gold Silver | |

f2u | efsp | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, saturating, toward positive infinity | Gold Silver | |

f2u | efsz | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, saturating, toward zero | Gold Silver | |

f2u | efs | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, saturating, use current dynamic rounding mode | Gold Silver | |

f2u | efxe | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, excepting, to nearest, ties toward even adjacent value | Gold Silver | |

f2u | efxfz | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, excepting, to nearest, ties away from zero | Gold Silver | |

f2u | efxn | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, excepting, toward negative infinity | Gold Silver | |

f2u | efxp | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, excepting, toward positive infinity | Gold Silver | |

f2u | efxz | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, excepting, toward zero | Gold Silver | |

f2u | efx | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, excepting, use current dynamic rounding mode | Gold Silver | |

f2u | ef e | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, modulo, to nearest, ties toward even adjacent value | Gold Silver | |

f2u | ef fz | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, modulo, to nearest, ties away from zero | Gold Silver | |

f2u | ef n | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, modulo, toward negative infinity | Gold Silver | |

f2u | ef p | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, modulo, toward positive infinity | Gold Silver | |

f2u | ef z | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, modulo, toward zero | Gold Silver | |

f2u | ef | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , exact, binary floating point, modulo, use current dynamic rounding mode | Gold Silver | |

f2u | dse | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, saturating, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2u | dsfz | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, saturating, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2u | dsn | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, saturating, toward negative infinity | Decimal8 Decimal16 | |

f2u | dsp | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, saturating, toward positive infinity | Decimal8 Decimal16 | |

f2u | dsz | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, saturating, toward zero | Decimal8 Decimal16 | |

f2u | ds | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, saturating, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2u | dxe | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, excepting, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2u | dxfz | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, excepting, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2u | dxn | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, excepting, toward negative infinity | Decimal8 Decimal16 | |

f2u | dxp | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, excepting, toward positive infinity | Decimal8 Decimal16 | |

f2u | dxz | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, excepting, toward zero | Decimal8 Decimal16 | |

f2u | dx | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, excepting, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2u | d e | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, modulo, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

f2u | d fz | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, modulo, to nearest, ties away from zero | Decimal8 Decimal16 | |

f2u | d n | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, modulo, toward negative infinity | Decimal8 Decimal16 | |

f2u | d p | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, modulo, toward positive infinity | Decimal8 Decimal16 | |

f2u | d z | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, modulo, toward zero | Decimal8 Decimal16 | |

f2u | d | d x | 1 | ? | [dd:d] | exu | compute | convert float to unsigned integer , inexact, decimal floating point, modulo, use current dynamic rounding mode | Decimal8 Decimal16 | |

f2u | fse | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, saturating, to nearest, ties toward even adjacent value | Gold Silver | |

f2u | fsfz | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, saturating, to nearest, ties away from zero | Gold Silver | |

f2u | fsn | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, saturating, toward negative infinity | Gold Silver | |

f2u | fsp | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, saturating, toward positive infinity | Gold Silver | |

f2u | fsz | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, saturating, toward zero | Gold Silver | |

f2u | fs | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, saturating, use current dynamic rounding mode | Gold Silver | |

f2u | fxe | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, excepting, to nearest, ties toward even adjacent value | Gold Silver | |

f2u | fxfz | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, excepting, to nearest, ties away from zero | Gold Silver | |

f2u | fxn | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, excepting, toward negative infinity | Gold Silver | |

f2u | fxp | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, excepting, toward positive infinity | Gold Silver | |

f2u | fxz | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, excepting, toward zero | Gold Silver | |

f2u | fx | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, excepting, use current dynamic rounding mode | Gold Silver | |

f2u | f e | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, modulo, to nearest, ties toward even adjacent value | Gold Silver | |

f2u | f fz | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, modulo, to nearest, ties away from zero | Gold Silver | |

f2u | f n | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, modulo, toward negative infinity | Gold Silver | |

f2u | f p | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, modulo, toward positive infinity | Gold Silver | |

f2u | f z | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, modulo, toward zero | Gold Silver | |

f2u | f | f x | 1 | ? | [ff:f] | exu | compute | convert float to unsigned integer , inexact, binary floating point, modulo, use current dynamic rounding mode | Gold Silver | |

! | face | off count | 0 | : | flow | compute | fetch-ahead count extension | all | ||

fault | op x | 1 | [xx:x] | exu | compute | force an application fault , logical | all | |||

fault | conditioncode | 1 | [xx:x] | exu | compute | force an application fault , logical | all | |||

fill | off off0 | 1 | xx:x | flow | compute | retore spilled operand from extended scratchpad | all | |||

fill | off lit0, lit off0 | 1 | xx:x | flow | compute | retore spilled operand from extended scratchpad | all | |||

flip | s | s x | 1 | [xx:x] | exu | compute | bit complement , signed integer | all | ||

flip | u | u x | 1 | [xx:x] | exu | compute | bit complement , unsigned integer | all | ||

flip | op x, bit bit | 1 | [xi:x] | exu | compute | bit complement , logical | all | |||

flip | op x, n bit | 1 | [xi:x] | exu | compute | bit complement , logical | all | |||

flip | op x | 1 | [xx:x] | exu | compute | bit complement , logical | all | |||

flowArgs_{4} | off arg, lit arg, lit arg, lit arg | 0 | : | flow | compute | four-byte constant continuation, conditional predicate, or other ganged argument | all | |||

flowArgs_{3} | off arg, lit arg, lit arg | 0 | : | flow | compute | four-byte constant continuation, conditional predicate, or other ganged argument | all | |||

flowArgs_{2} | off arg, lit arg | 0 | : | flow | compute | four-byte constant continuation, conditional predicate, or other ganged argument | all | |||

flowArgs_{1} | off arg | 0 | : | flow | compute | four-byte constant continuation, conditional predicate, or other ganged argument | all | |||

flowArgs_{*} | ops args | 0 | : | flow | compute | four-byte constant continuation, conditional predicate, or other ganged argument | all | |||

fma_{1} | de | d x | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | ||

fma_{1} | de | d x, d y | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | ||

fma_{*} | de | d x, d y, d z, d w | 2 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | ||

fma_{*} | de | d x, d y, d z | 1 | [dd:d] | exu | compute | Decimal8 Decimal16 | |||

fma_{1} | dfz | d x | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, to nearest, ties away from zero | Decimal8 Decimal16 | ||

fma_{1} | dfz | d x, d y | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, to nearest, ties away from zero | Decimal8 Decimal16 | ||

fma_{*} | dfz | d x, d y, d z, d w | 2 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, to nearest, ties away from zero | Decimal8 Decimal16 | ||

fma_{*} | dfz | d x, d y, d z | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, to nearest, ties away from zero | Decimal8 Decimal16 | ||

fma_{1} | dn | d x, d y | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward negative infinity | Decimal8 Decimal16 | ||

fma_{1} | dn | d x | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward negative infinity | Decimal8 Decimal16 | ||

fma_{*} | dn | d x, d y, d z | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward negative infinity | Decimal8 Decimal16 | ||

fma_{*} | dn | d x, d y, d z, d w | 2 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward negative infinity | Decimal8 Decimal16 | ||

fma_{1} | dp | d x, d y | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward positive infinity | Decimal8 Decimal16 | ||

fma_{1} | dp | d x | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward positive infinity | Decimal8 Decimal16 | ||

fma_{*} | dp | d x, d y, d z | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward positive infinity | Decimal8 Decimal16 | ||

fma_{*} | dp | d x, d y, d z, d w | 2 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward positive infinity | Decimal8 Decimal16 | ||

fma_{1} | dz | d x | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward zero | Decimal8 Decimal16 | ||

fma_{1} | dz | d x, d y | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward zero | Decimal8 Decimal16 | ||

fma_{*} | dz | d x, d y, d z | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward zero | Decimal8 Decimal16 | ||

fma_{*} | dz | d x, d y, d z, d w | 2 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, toward zero | Decimal8 Decimal16 | ||

fma_{1} | d | d x | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, use current dynamic rounding mode | Decimal8 Decimal16 | ||

fma_{1} | d | d x, d y | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, use current dynamic rounding mode | Decimal8 Decimal16 | ||

fma_{*} | d | d x, d y, d z, d w | 2 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, use current dynamic rounding mode | Decimal8 Decimal16 | ||

fma_{*} | d | d x, d y, d z | 1 | [dd:d] | exu | compute | fused multiply-add or -add/subtract , decimal floating point, use current dynamic rounding mode | Decimal8 Decimal16 | ||

fma_{1} | fe | f x | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, to nearest, ties toward even adjacent value | Gold Silver | ||

fma_{1} | fe | f x, f y | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, to nearest, ties toward even adjacent value | Gold Silver | ||

fma_{*} | fe | f x, f y, f z | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, to nearest, ties toward even adjacent value | Gold Silver | ||

fma_{*} | fe | f x, f y, f z, f w | 2 | [ff:f] | exu | compute | Gold Silver | |||

fma_{1} | ffz | f x, f y | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, to nearest, ties away from zero | Gold Silver | ||

fma_{1} | ffz | f x | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, to nearest, ties away from zero | Gold Silver | ||

fma_{*} | ffz | f x, f y, f z | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, to nearest, ties away from zero | Gold Silver | ||

fma_{*} | ffz | f x, f y, f z, f w | 2 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, to nearest, ties away from zero | Gold Silver | ||

fma_{1} | fn | f x | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward negative infinity | Gold Silver | ||

fma_{1} | fn | f x, f y | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward negative infinity | Gold Silver | ||

fma_{*} | fn | f x, f y, f z | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward negative infinity | Gold Silver | ||

fma_{*} | fn | f x, f y, f z, f w | 2 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward negative infinity | Gold Silver | ||

fma_{1} | fp | f x | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward positive infinity | Gold Silver | ||

fma_{1} | fp | f x, f y | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward positive infinity | Gold Silver | ||

fma_{*} | fp | f x, f y, f z | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward positive infinity | Gold Silver | ||

fma_{*} | fp | f x, f y, f z, f w | 2 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward positive infinity | Gold Silver | ||

fma_{1} | fz | f x, f y | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward zero | Gold Silver | ||

fma_{1} | fz | f x | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward zero | Gold Silver | ||

fma_{*} | fz | f x, f y, f z | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward zero | Gold Silver | ||

fma_{*} | fz | f x, f y, f z, f w | 2 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, toward zero | Gold Silver | ||

fma_{1} | f | f x, f y | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, use current dynamic rounding mode | Gold Silver | ||

fma_{1} | f | f x | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, use current dynamic rounding mode | Gold Silver | ||

fma_{*} | f | f x, f y, f z, f w | 2 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, use current dynamic rounding mode | Gold Silver | ||

fma_{*} | f | f x, f y, f z | 1 | [ff:f] | exu | compute | fused multiply-add or -add/subtract , binary floating point, use current dynamic rounding mode | Gold Silver | ||

geq | dx | d x, d y | 1 | [dd:d] | exu | compute | greater than or equal , decimal floating point, NaN-aware | Decimal8 Decimal16 | ||

geq | d | d x, d y | 1 | [dd:d] | exu | compute | greater than or equal , decimal floating point, NaN-unaware | Decimal8 Decimal16 | ||

geq | fx | f x, f y | 1 | [ff:f] | exu | compute | greater than or equal , binary floating point, NaN-aware | Gold Silver | ||

geq | f | f x, f y | 1 | [ff:f] | exu | compute | greater than or equal , binary floating point, NaN-unaware | Gold Silver | ||

geq | p | p x, p y | 1 | [pp:p] | exu | compute | greater than or equal , pointers | all | ||

geq | s | s x, imm y | 1 | [xx:x] | exu | compute | greater than or equal , signed integer | all | ||

geq | s | s x, s y | 1 | [xx:x] | exu | compute | greater than or equal , signed integer | all | ||

geq | u | u x, imm y | 1 | [xx:x] | exu | compute | greater than or equal , unsigned integer | all | ||

geq | u | u x, u y | 1 | [xx:x] | exu | compute | greater than or equal , unsigned integer | all | ||

geq | conditioncode | 1 | [xx:x] | exu | compute | greater than or equal , logical | all | |||

gtr | dx | d x, d y | 1 | [dd:d] | exu | compute | greater than , decimal floating point, NaN-aware | Decimal8 Decimal16 | ||

gtr | d | d x, d y | 1 | [dd:d] | exu | compute | greater than , decimal floating point, NaN-unaware | Decimal8 Decimal16 | ||

gtr | fx | f x, f y | 1 | [ff:f] | exu | compute | greater than , binary floating point, NaN-aware | Gold Silver | ||

gtr | f | f x, f y | 1 | [ff:f] | exu | compute | greater than , binary floating point, NaN-unaware | Gold Silver | ||

gtr | p | p x, p y | 1 | [pp:p] | exu | compute | greater than , pointers | all | ||

gtr | s | s x, imm y | 1 | [xx:x] | exu | compute | greater than , signed integer | all | ||

gtr | s | s x, s y | 1 | [xx:x] | exu | compute | greater than , signed integer | all | ||

gtr | u | u x, imm y | 1 | [xx:x] | exu | compute | greater than , unsigned integer | all | ||

gtr | u | u x, u y | 1 | [xx:x] | exu | compute | greater than , unsigned integer | all | ||

gtr | conditioncode | 1 | [xx:x] | exu | compute | greater than , logical | all | |||

gtr | op x, op y | 1 | [xx:x] | exuSkinny | compute | greater than , logical | all | |||

imp | s | s x, imm y | 1 | [xx:x] | exu | compute | implies , signed integer | all | ||

imp | s | s x, s y | 1 | [xx:x] | exu | compute | implies , signed integer | all | ||

imp | u | u x, imm y | 1 | [xx:x] | exu | compute | implies , unsigned integer | all | ||

imp | u | u x, u y | 1 | [xx:x] | exu | compute | implies , unsigned integer | all | ||

imp | op x, imm y | 1 | [xx:x] | exu | compute | implies , logical | all | |||

imp | op x, op y | 1 | [xx:x] | exu | compute | implies , logical | all | |||

inject_{1} | i i | 1 | [xn:x] | exu | compute | replace a vector element with a scalar | all | |||

inject | op v, op x, imm i | 1 | Xx:X | exu | compute | replace a vector element with a scalar | all | |||

inject_{*} | op v, op x, i i | 1 | XX:X | exu | compute | replace a vector element with a scalar | all | |||

! | inner_{1} | fl0 | op q, off target, count argc | 0 | : | flow | call | enter a loop , taken if false, no result | all | |

! | inner_{2} | fl0 | op q, off target, count argc, lit argv | 0 | : | flow | call | enter a loop , taken if false, no result | all | |

! | inner_{1} | fl0 | op q, p target, off argv, count argc | 0 | : | flow | call | enter a loop , taken if false, no result | all | |

! | inner_{3} | fl0 | op q, off target, count argc, lit argv, lit argv | 0 | : | flow | call | enter a loop , taken if false, no result | all | |

! | inner_{2} | fl0 | op q, p target, off argv, count argc, lit argv | 0 | : | flow | call | enter a loop , taken if false, no result | all | |

! | inner_{*} | fl0 | op q, p target, args args | 0 | : | flow | call | enter a loop , taken if false, no result | all | |

! | inner_{*} | fl0 | op q, lbl target, args args | 0 | : | flow | call | enter a loop , taken if false, no result | all | |

! | inner_{1} | fl1 | op q, p target, off argv, count argc | 1 | : | flow | call | enter a loop , taken if false, one result | all | |

! | inner_{2} | fl1 | op q, p target, off argv, count argc, lit argv | 1 | : | flow | call | enter a loop , taken if false, one result | all | |

! | inner_{3} | fl1 | op q, off target, count argc, lit argv, lit argv | 1 | : | flow | call | enter a loop , taken if false, one result | all | |

! | inner_{1} | fl1 | op q, off target, count argc | 1 | : | flow | call | enter a loop , taken if false, one result | all | |

! | inner_{2} | fl1 | op q, off target, count argc, lit argv | 1 | : | flow | call | enter a loop , taken if false, one result | all | |

! | inner_{*} | fl1 | op q, p target, args args | 1 | : | flow | call | enter a loop , taken if false, one result | all | |

! | inner_{*} | fl1 | op q, lbl target, args args | 1 | : | flow | call | enter a loop , taken if false, one result | all | |

! | inner | fln | op q, lit n, p target, off argc, count args | n | : | flow | call | enter a loop , taken if false, more than one result | all | |

! | inner_{2} | fln | op q, lit n, off target, count argc, lit argv | n | : | flow | call | enter a loop , taken if false, more than one result | all | |

! | inner_{1} | fln | op q, lit n, off target, count argc | n | : | flow | call | enter a loop , taken if false, more than one result | all | |

! | inner | fln | op q, lit n, p target, args args | n | : | flow | call | enter a loop , taken if false, more than one result | all | |

! | inner_{*} | fln | op q, lit n, lbl target, args args | n | : | flow | call | enter a loop , taken if false, more than one result | all | |

! | inner | fl | op q, lit n, off target, count argc, lit argv | * | : | flow | call | enter a loop , taken if false, any number of results | all | |

! | inner | fl | op q, lit n, off target, count argc | * | : | flow | call | enter a loop , taken if false, any number of results | all | |

! | inner | fl | op q, lit n, p target, off argc, count args | * | : | flow | call | enter a loop , taken if false, any number of results | all | |

! | inner_{*} | fl | op q, lit n, lbl target, args args | * | : | flow | call | enter a loop , taken if false, any number of results | all | |

! | inner_{*} | fl | op q, lit n, p target, args args | * | : | flow | call | enter a loop , taken if false, any number of results | all | |

! | inner_{3} | tr0 | op q, off target, count argc, lit argv, lit argv | 0 | : | flow | call | enter a loop , taken if true, no result | all | |

! | inner_{1} | tr0 | op q, off target, count argc | 0 | : | flow | call | enter a loop , taken if true, no result | all | |

! | inner_{2} | tr0 | op q, p target, off argv, count argc, lit argv | 0 | : | flow | call | enter a loop , taken if true, no result | all | |

! | inner_{2} | tr0 | op q, off target, count argc, lit argv | 0 | : | flow | call | enter a loop , taken if true, no result | all | |

! | inner_{1} | tr0 | op q, p target, off argv, count argc | 0 | : | flow | call | enter a loop , taken if true, no result | all | |

! | inner_{*} | tr0 | op q, lbl target, args args | 0 | : | flow | call | enter a loop , taken if true, no result | all | |

! | inner_{*} | tr0 | op q, p target, args args | 0 | : | flow | call | enter a loop , taken if true, no result | all | |

! | inner_{2} | tr1 | op q, p target, off argv, count argc, lit argv | 1 | : | flow | call | enter a loop , taken if true, one result | all | |

! | inner_{2} | tr1 | op q, off target, count argc, lit argv | 1 | : | flow | call | enter a loop , taken if true, one result | all | |

! | inner_{1} | tr1 | op q, off target, count argc | 1 | : | flow | call | enter a loop , taken if true, one result | all | |

! | inner_{1} | tr1 | op q, p target, off argv, count argc | 1 | : | flow | call | enter a loop , taken if true, one result | all | |

! | inner_{3} | tr1 | op q, off target, count argc, lit argv, lit argv | 1 | : | flow | call | enter a loop , taken if true, one result | all | |

! | inner_{*} | tr1 | op q, p target, args args | 1 | : | flow | call | enter a loop , taken if true, one result | all | |

! | inner_{*} | tr1 | op q, lbl target, args args | 1 | : | flow | call | enter a loop , taken if true, one result | all | |

! | inner_{1} | trn | op q, lit n, off target, count argc | n | : | flow | call | enter a loop , taken if true, more than one result | all | |

! | inner_{2} | trn | op q, lit n, off target, count argc, lit argv | n | : | flow | call | enter a loop , taken if true, more than one result | all | |

! | inner | trn | op q, lit n, p target, off argc, count args | n | : | flow | call | enter a loop , taken if true, more than one result | all | |

! | inner_{*} | trn | op q, lit n, lbl target, args args | n | : | flow | call | enter a loop , taken if true, more than one result | all | |

! | inner | trn | op q, lit n, p target, args args | n | : | flow | call | enter a loop , taken if true, more than one result | all | |

! | inner | tr | op q, lit n, off target, count argc | * | : | flow | call | enter a loop , taken if true, any number of results | all | |

! | inner | tr | op q, lit n, off target, count argc, lit argv | * | : | flow | call | enter a loop , taken if true, any number of results | all | |

! | inner | tr | op q, lit n, p target, off argc, count args | * | : | flow | call | enter a loop , taken if true, any number of results | all | |

! | inner_{*} | tr | op q, lit n, p target, args args | * | : | flow | call | enter a loop , taken if true, any number of results | all | |

! | inner_{*} | tr | op q, lit n, lbl target, args args | * | : | flow | call | enter a loop , taken if true, any number of results | all | |

! | inner_{3} | 0 | op q, off target, count argc, lit argv, lit argv | 0 | : | flow | call | enter a loop , taken unconditionally, no result | all | |

! | inner_{3} | 0 | off target, count argc, lit argv, lit argv | 0 | : | flow | call | enter a loop , taken unconditionally, no result | all | |

! | inner_{4} | 0 | off target, count argc, lit argv, lit argv, lit argv | 0 | : | flow | call | enter a loop , taken unconditionally, no result | all | |

! | inner_{2} | 0 | off target, count argc, lit argv | 0 | : | flow | call | enter a loop , taken unconditionally, no result | all | |

! | inner_{2} | 0 | op q, off target, count argc, lit argv | 0 | : | flow | call | enter a loop , taken unconditionally, no result | all | |

! | inner_{1} | 0 | op q, off target, count argc | 0 | : | flow | call | enter a loop , taken unconditionally, no result | all | |

! | inner_{1} | 0 | off target, count argc | 0 | : | flow | call | enter a loop , taken unconditionally, no result | all | |

! | inner_{*} | 0 | lbl target, args args | 0 | : | flow | call | enter a loop , taken unconditionally, no result | all | |

! | inner_{*} | 0 | p target, args args | 0 | : | flow | call | enter a loop , taken unconditionally, no result | all | |

! | inner_{3} | 1 | op q, off target, count argc, lit argv, lit argv | 1 | : | flow | call | enter a loop , taken unconditionally, one result | all | |

! | inner_{2} | 1 | op q, off target, count argc, lit argv | 1 | : | flow | call | enter a loop , taken unconditionally, one result | all | |

! | inner_{4} | 1 | off target, count argc, lit argv, lit argv, lit argv | 1 | : | flow | call | enter a loop , taken unconditionally, one result | all | |

! | inner_{3} | 1 | off target, count argc, lit argv, lit argv | 1 | : | flow | call | enter a loop , taken unconditionally, one result | all | |

! | inner_{2} | 1 | off target, count argc, lit argv | 1 | : | flow | call | enter a loop , taken unconditionally, one result | all | |

! | inner_{1} | 1 | off target, count argc | 1 | : | flow | call | enter a loop , taken unconditionally, one result | all | |

! | inner_{1} | 1 | op q, off target, count argc | 1 | : | flow | call | enter a loop , taken unconditionally, one result | all | |

! | inner_{*} | 1 | lbl target, args args | 1 | : | flow | call | enter a loop , taken unconditionally, one result | all | |

! | inner_{*} | 1 | p target, args args | 1 | : | flow | call | enter a loop , taken unconditionally, one result | all | |

! | inner_{2} | n | lit n, off target, count argc, lit argv | n | : | flow | call | enter a loop , taken unconditionally, more than one result | all | |

! | inner_{3} | n | lit n, off target, count argc, lit argv, lit argv | n | : | flow | call | enter a loop , taken unconditionally, more than one result | all | |

! | inner_{1} | n | lit n, p target, off argv, count argc | n | : | flow | call | enter a loop , taken unconditionally, more than one result | all | |

! | inner_{1} | n | lit n, off target, count argc | n | : | flow | call | enter a loop , taken unconditionally, more than one result | all | |

! | inner_{2} | n | lit n, p target, off argv, count argc, lit argv | n | : | flow | call | enter a loop , taken unconditionally, more than one result | all | |

! | inner_{*} | n | lit n, p target, args args | n | : | flow | call | enter a loop , taken unconditionally, more than one result | all | |

! | inner_{*} | n | lit n, lbl target, args args | n | : | flow | call | enter a loop , taken unconditionally, more than one result | all | |

! | inner | lit n, p target, off argv, count argc | * | : | flow | call | enter a loop , taken unconditionally, any number of results | all | ||

! | inner | lit n, off target, count argc, lit argv, lit argv | * | : | flow | call | enter a loop , taken unconditionally, any number of results | all | ||

! | inner | lit n, p target, off argv, count argc, lit argv | * | : | flow | call | enter a loop , taken unconditionally, any number of results | all | ||

! | inner | lit n, off target, count argc | * | : | flow | call | enter a loop , taken unconditionally, any number of results | all | ||

! | inner | lit n, off target, count argc, lit argv | * | : | flow | call | enter a loop , taken unconditionally, any number of results | all | ||

! | inner_{*} | lit n, p target, args args | * | : | flow | call | enter a loop , taken unconditionally, any number of results | all | ||

! | inner_{*} | lit n, lbl target, args args | * | : | flow | call | enter a loop , taken unconditionally, any number of results | all | ||

integer | ede | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , exact, decimal floating point, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

integer | edfz | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , exact, decimal floating point, to nearest, ties away from zero | Decimal8 Decimal16 | |

integer | edn | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , exact, decimal floating point, toward negative infinity | Decimal8 Decimal16 | |

integer | edp | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , exact, decimal floating point, toward positive infinity | Decimal8 Decimal16 | |

integer | edz | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , exact, decimal floating point, toward zero | Decimal8 Decimal16 | |

integer | ed | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , exact, decimal floating point, use current dynamic rounding mode | Decimal8 Decimal16 | |

integer | efe | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , exact, binary floating point, to nearest, ties toward even adjacent value | Gold Silver | |

integer | effz | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , exact, binary floating point, to nearest, ties away from zero | Gold Silver | |

integer | efn | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , exact, binary floating point, toward negative infinity | Gold Silver | |

integer | efp | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , exact, binary floating point, toward positive infinity | Gold Silver | |

integer | efz | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , exact, binary floating point, toward zero | Gold Silver | |

integer | ef | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , exact, binary floating point, use current dynamic rounding mode | Gold Silver | |

integer | de | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , inexact, decimal floating point, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

integer | dfz | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , inexact, decimal floating point, to nearest, ties away from zero | Decimal8 Decimal16 | |

integer | dn | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , inexact, decimal floating point, toward negative infinity | Decimal8 Decimal16 | |

integer | dp | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , inexact, decimal floating point, toward positive infinity | Decimal8 Decimal16 | |

integer | dz | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , inexact, decimal floating point, toward zero | Decimal8 Decimal16 | |

integer | d | d x | 1 | ? | [dd:d] | exu | compute | round to integral-valued float , inexact, decimal floating point, use current dynamic rounding mode | Decimal8 Decimal16 | |

integer | fe | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , inexact, binary floating point, to nearest, ties toward even adjacent value | Gold Silver | |

integer | ffz | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , inexact, binary floating point, to nearest, ties away from zero | Gold Silver | |

integer | fn | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , inexact, binary floating point, toward negative infinity | Gold Silver | |

integer | fp | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , inexact, binary floating point, toward positive infinity | Gold Silver | |

integer | fz | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , inexact, binary floating point, toward zero | Gold Silver | |

integer | f | f x | 1 | ? | [ff:f] | exu | compute | round to integral-valued float , inexact, binary floating point, use current dynamic rounding mode | Gold Silver | |

lea | lbl l | 0 | : | flow | compute | load effective address | all | |||

lea | p b, off o, u i, scale s | 0 | : | flow | compute | load effective address , pointerbased | all | |||

lea | base b, off o, u i, scale s | 0 | : | flow | compute | load effective address , registerbased | all | |||

lea | p b, off o | 1 | xx:p | flow | compute | load effective address , pointerbased | all | |||

lea | base b, off o | 0 | : | flow | compute | load effective address , registerbased | all | |||

left | op v | 1 | XX:i | exu | compute | construct a bool vector with N leading false, or count leading false in a bool vector , logical | all | |||

left | op x, width w | 1 | xx:X | exu | compute | construct a bool vector with N leading false, or count leading false in a bool vector , logical | all | |||

leq | dx | d x, d y | 1 | [dd:d] | exu | compute | less than or equal , decimal floating point, NaN-aware | Decimal8 Decimal16 | ||

leq | d | d x, d y | 1 | [dd:d] | exu | compute | less than or equal , decimal floating point, NaN-unaware | Decimal8 Decimal16 | ||

leq | fx | f x, f y | 1 | [ff:f] | exu | compute | less than or equal , binary floating point, NaN-aware | Gold Silver | ||

leq | f | f x, f y | 1 | [ff:f] | exu | compute | less than or equal , binary floating point, NaN-unaware | Gold Silver | ||

leq | p | p x, p y | 1 | [pp:p] | exu | compute | less than or equal , pointers | all | ||

leq | s | s x, s y | 1 | [xx:x] | exu | compute | less than or equal , signed integer | all | ||

leq | s | s x, imm y | 1 | [xx:x] | exu | compute | less than or equal , signed integer | all | ||

leq | u | u x, u y | 1 | [xx:x] | exu | compute | less than or equal , unsigned integer | all | ||

leq | u | u x, imm y | 1 | [xx:x] | exu | compute | less than or equal , unsigned integer | all | ||

leq | conditioncode | 1 | [xx:x] | exu | compute | less than or equal , logical | all | |||

load | p b, off o, width w, lit delay | 1 | xx:x | flow | compute | load from memory , pointerbased, logical | all | |||

load | p b, width w, memAttr m | 1 | xx:x | flow | compute | load from memory , pointerbased, logical | all | |||

load | p b, off o, s i, scale s, width w, tag tag | 1 | xx:x | flow | compute | load from memory , pointerbased, logical | all | |||

load | p b, width w, memAttr m, lit delay | 1 | xx:x | flow | compute | load from memory , pointerbased, logical | all | |||

load | p b, width w, memAttr m, tag tag | 1 | xx:x | flow | compute | load from memory , pointerbased, logical | all | |||

load | p b, off o, s i, scale s, width w, lit delay | 1 | xx:x | flow | compute | load from memory , pointerbased, logical | all | |||

load | p b, off o, s i, scale s, width w | 1 | xx:x | flow | compute | load from memory , pointerbased, logical | all | |||

load | p b, off o, width w, tag tag | 1 | xx:x | flow | compute | load from memory , pointerbased, logical | all | |||

load | base b, off o, s i, scale s, width w, tag tag | 1 | xx:x | flow | compute | load from memory , registerbased, logical | all | |||

load | base b, off o, s i, scale s, width w, lit delay | 1 | xx:x | flow | compute | load from memory , registerbased, logical | all | |||

load | base b, off o, s i, scale s, width w | 1 | xx:x | flow | compute | load from memory , registerbased, logical | all | |||

load | p b, off o, width w | 1 | xx:x | flow | compute | load from memory , pointerbased, logical | all | |||

load | base b, off o, width w, tag tag | 1 | xx:x | flow | compute | load from memory , registerbased, logical | all | |||

load | base b, off o, width w, lit delay | 1 | xx:x | flow | compute | load from memory , registerbased, logical | all | |||

load | base b, off o, width w | 1 | xx:x | flow | compute | load from memory , registerbased, logical | all | |||

logB | d | d x | 1 | [dd:d] | exu | compute | extract exponent , decimal floating point | Decimal8 Decimal16 | ||

logB | f | f x | 1 | [ff:f] | exu | compute | extract exponent , binary floating point | Gold Silver | ||

longjmpl | op op0 | 1 | pp:p | flow | compute | restore to a point place by setjmp | all | |||

lss | dx | d x, d y | 1 | [dd:d] | exu | compute | less than , decimal floating point, NaN-aware | Decimal8 Decimal16 | ||

lss | d | d x, d y | 1 | [dd:d] | exu | compute | less than , decimal floating point, NaN-unaware | Decimal8 Decimal16 | ||

lss | fx | f x, f y | 1 | [ff:f] | exu | compute | less than , binary floating point, NaN-aware | Gold Silver | ||

lss | f | f x, f y | 1 | [ff:f] | exu | compute | less than , binary floating point, NaN-unaware | Gold Silver | ||

lss | p | p x, p y | 1 | [pp:p] | exu | compute | less than , pointers | all | ||

lss | s | s x, imm y | 1 | [xx:x] | exu | compute | less than , signed integer | all | ||

lss | s | s x, s y | 1 | [xx:x] | exu | compute | less than , signed integer | all | ||

lss | u | u x, u y | 1 | [xx:x] | exu | compute | less than , unsigned integer | all | ||

lss | u | u x, imm y | 1 | [xx:x] | exu | compute | less than , unsigned integer | all | ||

lss | conditioncode | 1 | [xx:x] | exu | compute | less than , logical | all | |||

mask | op v, width w | 1 | xX:X|Xx:x | exu | compute | bitmask conversion between vector of bool and scalar , logical | all | |||

mask | bit bit0, bit bit1, width w | 1 | [xx:x] | exu | compute | bitmask conversion between vector of bool and scalar , logical | all | |||

max | d | d x, d y | 1 | ? | [dd:d] | exu | compute | maximum , decimal floating point | Decimal8 Decimal16 | |

max | f | f x, f y | 1 | ? | [ff:f] | exu | compute | maximum , binary floating point | Gold Silver | |

merge_{1} | op op0 | 1 | [xx:x] | exu | compute | bitwise merge , logical | all | |||

merge_{*} | u mask, u bits0, u bits1 | 1 | [xx:x] | exu | compute | bitwise merge , logical | all | |||

min | d | d x, d y | 1 | ? | [dd:d] | exu | compute | minimum , decimal floating point | Decimal8 Decimal16 | |

min | f | f x, f y | 1 | ? | [ff:f] | exu | compute | minimum , binary floating point | Gold Silver | |

mul | de | d x, d y | 1 | ? | [dd:d] | exu | compute | multiplication , decimal floating point, to nearest, ties toward even adjacent value | Decimal8 Decimal16 | |

mul | dfz | d x, d y | 1 | ? | [dd:d] | exu | compute | multiplication , decimal floating point, to nearest, ties away from zero | Decimal8 Decimal16 | |

mul | dn | d x, d y | 1 | ? | [dd:d] | exu | compute | multiplication , decimal floating point, toward negative infinity | Decimal8 Decimal16 | |

mul | dp | d x, d y | 1 | ? | [dd:d] | exu | compute | multiplication , decimal floating point, toward positive infinity | Decimal8 Decimal16 | |

mul | dz | d x, d y | 1 | ? | [dd:d] | exu | compute | multiplication , decimal floating point, toward zero | Decimal8 Decimal16 | |

mul | d | d x, d y | 1 | ? | [dd:d] | exu | compute | multiplication , decimal floating point, use current dynamic rounding mode | Decimal8 Decimal16 | |

mul | fe | f x, f y | 1 | ? | [ff:f] | exu | compute | multiplication , binary floating point, to nearest, ties toward even adjacent value | Gold Silver | |

mul | ffz | f x, f y | 1 | ? | [ff:f] | exu | compute | multiplication , binary floating point, to nearest, ties away from zero | Gold Silver | |

mul | fn | f x, f y | 1 | ? | [ff:f] | exu | compute | multiplication , binary floating point, toward negative infinity | Gold Silver | |

mul | fp | f x, f y | 1 | ? | [ff:f] | exu | compute | multiplication , binary floating point, toward positive infinity | Gold Silver | |

mul | fz | f x, f y | 1 | ? | [ff:f] | exu | compute | multiplication , binary floating point, toward zero | Gold Silver | |

mul | f | f x, f y | 1 | ? | [ff:f] | exu | compute | multiplication , binary floating point, use current dynamic rounding mode | Gold Silver | |

mul | sfse | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, saturating, to nearest, ties toward even adjacent value | all | |

mul | sfsfz | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, saturating, to nearest, ties away from zero | all | |

mul | sfsn | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, saturating, toward negative infinity | all | |

mul | sfsp | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, saturating, toward positive infinity | all | |

mul | sfsz | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, saturating, toward zero | all | |

mul | sfs | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, saturating, use current dynamic rounding mode | all | |

mul | sfwe | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, widening, to nearest, ties toward even adjacent value | all | |

mul | sfwfz | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, widening, to nearest, ties away from zero | all | |

mul | sfwn | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, widening, toward negative infinity | all | |

mul | sfwp | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, widening, toward positive infinity | all | |

mul | sfwz | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, widening, toward zero | all | |

mul | sfw | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, widening, use current dynamic rounding mode | all | |

mul | sfxe | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, excepting, to nearest, ties toward even adjacent value | all | |

mul | sfxfz | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, excepting, to nearest, ties away from zero | all | |

mul | sfxn | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, excepting, toward negative infinity | all | |

mul | sfxp | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, excepting, toward positive infinity | all | |

mul | sfxz | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, excepting, toward zero | all | |

mul | sfx | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, excepting, use current dynamic rounding mode | all | |

mul | sf e | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, modulo, to nearest, ties toward even adjacent value | all | |

mul | sf fz | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, modulo, to nearest, ties away from zero | all | |

mul | sf n | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, modulo, toward negative infinity | all | |

mul | sf p | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, modulo, toward positive infinity | all | |

mul | sf z | sf x, sf y, bit dot | 1 | ? | [xx:x] | exu | compute | multiplication , signed fixed point, modulo, toward zero | all | |