# Instruction Set

a b c d e f g h i j k l m n o p q r s t u v w x y z

The operations of the full instruction set.Instruction Set Table, sortable, filterable, Instruction Set by Category, Cores, Registers

abortAtomic - principal op code: abort an in-progress atomic extent; operation encoding group
selector: flow-side operations;

activeRead - principal op code: read from an address having hardware side effects; arithmetic
domain: logical; operation encoding group selector: flow-side operations; operation
signature kind: belt operand from opsWindow, data width and vector length
(flo

add - This is the basic overflowing integer addition. With 32bit values it defines the Cycle on the Mill architecture.

addd - Decimal floating point add in current rounding mode.

addde - Decimal floating point add in current rounding to even.

adddfz - Decimal floating point add in current rounding away from zero.

adddn - Decimal floating point add in current rounding to nearest.

adddp - Decimal floating point add in current rounding towards positive infinity.

adddz - Decimal floating point add in current rounding towards zero.

addf - Floating point add in current rounding mode.

addfe - Floating point add in current rounding to even.

addffz - Floating point add in current rounding away from zero.

addfn - Floating point add in current rounding to nearest.

addfp - Floating point add in current rounding towards positive infinity.

addfz - Floating point add in current rounding towards zero.

addp - Pointer addition. Protects the upper 4 reserved bits, can be scaled for indexing.

adds - Alias for add.

adds2 - Alias for add.

addss - Saturating signed integer addition.

addss2 - Alias for addss.

addsw - Widening signed integer addition.

addsw2 - principal op code: addition; arithmetic domain: signed integer; overflow policy:
widening; single vs dual vector result: dual; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

addsx - Excepting signed integer add.

addsx2 - Alias for addsx.

addu - Alias for add.

addu2 - Alias for add.

addus - Saturating unsigned integer addition.

addus2 - Alias for addus.

adduw - Widening unsigned integer addition.

adduw2 - principal op code: addition; arithmetic domain: unsigned integer; overflow policy:
widening; single vs dual vector result: dual; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

addux - Excepting unsigned integer add.

addux2 - Alias for addux.

advance - principal op code: advance the scratchpad rotator; arithmetic domain: logical;
operation encoding group selector: exu-side readers;

all - Returns true if the lowest bit in all vector elements is set.

allocStack - principal op code: allocate more memory in the current stack frame; operation
encoding group selector: flow-side operations;

alternate - Interlace two Vectors.

andl - Bitwise and.

andls - Alias for andl.

andlu - Alias for andl.

any - Returns true if the lowest bit in any of the vector elements is set.

argf - principal op code: reserve space for args passed in memory; operation encoding group
selector: flow-side operations; possible manifest sizes in bytes: zero, one, two, or
four constant bytes;

argSize - principal op code: set size of memory argument block for following dynCall;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

back - principal op code: branch to head of loop, "leave"ing if not taken; sense
of condition: taken unconditionally; operation encoding group selector: flow-side
operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;

backfl - principal op code: branch to head of loop, "leave"ing if not taken; sense
of condition: taken if false; operation encoding group selector: flow-side operations;
possible manifest sizes in bytes: zero, one, two, or four constant bytes; operation
signature kind: late-evaluated 1-bit predicate from belt, manifest constant,
morsel-sized count of polyadic arg

backtr - principal op code: branch to head of loop, "leave"ing if not taken; sense
of condition: taken if true; operation encoding group selector: flow-side operations;
possible manifest sizes in bytes: zero, one, two, or four constant bytes; operation
signature kind: late-evaluated 1-bit predicate from belt, manifest constant,
morsel-sized count of polyadic args, morsel-sized manifest constant, morsel-sized
manifest constan

BID2d - principal op code: decimal format conversion; arithmetic domain: decimal floating
point; operation encoding group selector: exu-side operations; operation signature
kind: belt operand from ops windo

br - Conditionless branch.

brfl - Branch on false predicate.

brfls - principal op code: branch; sense of condition: taken if false; suppress or permit
in-flights across branches: discard in flight operations when taking branch; operation
encoding group selector: flow-side operations; possible manifest sizes in bytes: zero,
one, two, or four constant bytes;

brs - principal op code: branch; sense of condition: taken unconditionally; suppress or
permit in-flights across branches: discard in flight operations when taking branch;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

brtr - Branch on true predicate.

brtrs - principal op code: branch; sense of condition: taken if true; suppress or permit
in-flights across branches: discard in flight operations when taking branch; operation
encoding group selector: flow-side operations; possible manifest sizes in bytes: zero,
one, two, or four constant bytes;

bswap - principal op code: big<->little endian conversion; arithmetic domain: logical;
operation encoding group selector: exu-side operations;

cachepbcl - principal op code: cache control operation; arithmetic domain: pointer; memory
sub-operation: Load entire code range to lowest on-chip cache; operation encoding group
selector: flow-side operations;

cachepbdl - principal op code: cache control operation; arithmetic domain: pointer; memory
sub-operation: Load entire data range to lowest on-chip cache; operation encoding group
selector: flow-side operations;

cachepd - principal op code: cache control operation; arithmetic domain: pointer; memory
sub-operation: duplicate cache line to new address; operation encoding group selector:
flow-side operations;

cachepe - principal op code: cache control operation; arithmetic domain: pointer; memory
sub-operation: evict cache line to memory; operation encoding group selector: flow-side
operations;

cachepx - principal op code: cache control operation; arithmetic domain: pointer; memory
sub-operation: discard cache line without flush; operation encoding group selector:
flow-side operations;

call0 - Call function with no return values.

call1 - Call function with one return value.

callfl0 - Call predicated function with no return values on false.

callfl1 - Call predicated function with one return value on false.

calln - Call function with defined number of return values.

calltr0 - Call predicated function with no return values on true.

calltr1 - Call predicated function with one return value on true.

carry - Gets the carry/borrow flag or condition code of the ganged operation and puts it on the belt.

carryb - principal op code: carry/borrow gang predicate; arithmetic domain: logical; retain
argument width or narrow to bool: result has "b" (bool) width; operation
encoding group selector: exu-side operations;

classifyd - Produce an enum value to classify binary floating points into normal values, subnormals, infinities and NaNs etc.

classifyf - Produce an enum value to classify binary floating points into normal values, subnormals, infinities and NaNs etc.

clear - Clear a single indexed bit.

con - principal op code: immediate constant; operation encoding group selector: flow-side
operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;

countlfl - Count the zero bits from the left.

countltr - Count the one bits from the left.

countrfl - Count the zero bits from the right.

countrtr - Count the one bits from the right.

d2BID - principal op code: decimal format conversion; arithmetic domain: logical; operation
encoding group selector: exu-side operations;

d2DPD - principal op code: decimal format conversion; arithmetic domain: logical; operation
encoding group selector: exu-side operations;

delta - The delta or distance between two pointers. |x - y|

divd - Decimal floating point division in current rounding mode.

divde - Decimal floating point division in current rounding to even.

divdfz - Decimal floating point division in current rounding away from zero.

divdn - Decimal floating point division in current rounding to nearest.

divdp - Decimal floating point division in current rounding towards positive infinity.

divdz - Decimal floating point division in current rounding towards zero.

divf - Floating point division in current rounding mode.

divfe - Floating point division in current rounding to even.

divffz - Floating point division in current rounding away from zero.

divfn - Floating point division in current rounding to nearest.

divfp - Floating point division in current rounding towards positive infinity.

divfz - Floating point division in current rounding towards zero.

divRems - Signed integer division for quotient and remainder.

divRemu - Unsigned integer division for quotient and remainder.

divs - Signed integer division for quotient.

divu - Unsigned integer division for quotient.

DPD2d - principal op code: decimal format conversion; arithmetic domain: decimal floating
point; operation encoding group selector: exu-side operations; operation signature
kind: belt operand from ops windo

enterAtomic - principal op code: begin a new optimistic atomic extent; operation encoding group
selector: flow-side operations;

eql - Integer equality comparison.

eqlb - principal op code: equal; arithmetic domain: logical; retain argument width or
narrow to bool: result has "b" (bool) width; operation encoding group
selector: exu-side operations;

eqld - Decimal float equality comparison.

eqldb - principal op code: equal; arithmetic domain: decimal floating point; NaN-awareness:
NaN-unaware; retain argument width or narrow to bool: result has "b" (bool)
width; operation encoding group selector: exu-side operations; operation signature
kind: belt operand from ops window, belt operand from ops windo

eqldx - Decimal float equality comparison. NaN-Aware.

eqldxb - principal op code: equal; arithmetic domain: decimal floating point; NaN-awareness:
NaN-aware; retain argument width or narrow to bool: result has "b" (bool)
width; operation encoding group selector: exu-side operations; operation signature
kind: belt operand from ops window, belt operand from ops windo

eqlf - Binary float equality comparison.

eqlfb - principal op code: equal; arithmetic domain: binary floating point; NaN-awareness:
NaN-unaware; retain argument width or narrow to bool: result has "b" (bool)
width; operation encoding group selector: exu-side operations; operation signature
kind: belt operand from ops window, belt operand from ops windo

eqlfx - Binary float equality comparison. NaN-Aware.

eqlfxb - principal op code: equal; arithmetic domain: binary floating point; NaN-awareness:
NaN-aware; retain argument width or narrow to bool: result has "b" (bool)
width; operation encoding group selector: exu-side operations; operation signature
kind: belt operand from ops window, belt operand from ops windo

eqlp - Pointer equality.

eqlpb - principal op code: equal; arithmetic domain: pointer; retain argument width or
narrow to bool: result has "b" (bool) width; operation encoding group
selector: exu-side operations;

eqls - Alias for eql.

eqlsb - Alias for eqlb.

eqlu - Alias for eql.

eqlub - Alias for eqlb.

exitAtomic - principal op code: commit an in-progress atomic extent and return status; operation
encoding group selector: flow-side operations;

exscratchf - principal op code: allocate extended scratchpad space in memory; operation encoding
group selector: flow-side operations; possible manifest sizes in bytes: zero, one, two,
or four constant bytes;

extract - Extract a vector element to a scalar value operand.

exuArgs - Additional arguments for Ganged operations.

f2fd - Convert decimal floating point into binary floating point in current rounding mode.

f2fde - Convert decimal floating point into binary floating point, rounding to even.

f2fdfz - Convert decimal floating point into binary floating point, rounding away from zero.

f2fdn - Convert decimal floating point into binary floating point, rounding to nearest.

f2fdp - Convert decimal floating point into binary floating point, rounding towards positive infinity.

f2fdz - Convert decimal floating point into binary floating point, rounding towards zero.

f2ff - Convert binary floating point into decimal floating point in current rounding mode.

f2ffe - Convert binary floating point into decimal floating point, rounding to even.

f2fffz - Convert binary floating point into decimal floating point, rounding away from zero.

f2ffn - Convert binary floating point into decimal floating point, rounding to nearest.

f2ffp - Convert binary floating point into decimal floating point, rounding towards positive infinity.

f2ffz - Convert binary floating point into decimal floating point, rounding towards zero.

f2sde - Inexactly convert a decimal floating point value to a signed integer, rounding toward even and normal modulo overflow.

f2sdee - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sdefz - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sden - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward negative infinity; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

f2sdep - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward positive infinity; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

f2sdes - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdese - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sdesfz - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdesn - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdesp - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdesz - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2sdex - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdexe - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sdexfz - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdexn - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdexp - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdexz - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2sdez - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward zero; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

f2sdi - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdie - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sdifz - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdin - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdip - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdis - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdise - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sdisfz - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdisn - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdisp - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdisz - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2sdix - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdixe - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sdixfz - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdixn - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdixp - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sdixz - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2sdiz - principal op code: convert float to signed integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2sfe - Inexactly convert a binary floating point value to a signed integer, rounding toward even and normal modulo overflow.

f2sfee - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sfefz - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfen - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward negative infinity; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

f2sfep - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward positive infinity; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

f2sfes - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfese - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sfesfz - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfesn - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfesp - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfesz - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2sfex - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfexe - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sfexfz - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfexn - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfexp - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfexz - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2sfez - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward zero; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

f2sfi - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfie - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sfifz - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfin - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfip - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfis - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfise - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sfisfz - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfisn - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfisp - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfisz - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2sfix - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfixe - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2sfixfz - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfixn - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfixp - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2sfixz - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2sfiz - principal op code: convert float to signed integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2ude - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward even and normal modulo overflow.

f2udee - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2udefz - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2uden - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward negative infinity; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

f2udep - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward positive infinity; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

f2udes - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udese - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2udesfz - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udesn - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udesp - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udesz - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2udex - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udexe - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2udexfz - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udexn - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udexp - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udexz - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2udez - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward zero; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

f2udi - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udie - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2udifz - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udin - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udip - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udis - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udise - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2udisfz - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udisn - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udisp - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udisz - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2udix - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udixe - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2udixfz - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udixn - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udixp - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2udixz - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2udiz - principal op code: convert float to unsigned integer; arithmetic domain: decimal
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2ufe - Inexactly convert a binary floating point value to a unsigned integer, rounding toward even and normal modulo overflow.

f2ufee - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2ufefz - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufen - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward negative infinity; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

f2ufep - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward positive infinity; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

f2ufes - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufese - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2ufesfz - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufesn - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufesp - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufesz - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: saturating; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2ufex - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufexe - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2ufexfz - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufexn - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufexp - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufexz - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: excepting; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2ufez - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: exact; overflow policy: modulo; rounding policy:
toward zero; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

f2ufi - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufie - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2ufifz - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufin - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufip - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufis - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufise - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2ufisfz - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufisn - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufisp - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufisz - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: saturating; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2ufix - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: use current dynamic rounding mode; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufixe - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: to nearest, ties toward even adjacent value; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

f2ufixfz - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: to nearest, ties away from zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufixn - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufixp - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

f2ufixz - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: excepting; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

f2ufiz - principal op code: convert float to unsigned integer; arithmetic domain: binary
floating point; exact result required: inexact; overflow policy: modulo; rounding
policy: toward zero; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

face - principal op code: fetch-ahead count extension; operation encoding group selector:
flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
constant bytes;

fault - Raise an application fault event.

faultfl - principal op code: force an application fault; arithmetic domain: logical; sense of
condition: taken if false; operation encoding group selector: exu-side writers;

faulttr - principal op code: force an application fault; arithmetic domain: logical; sense of
condition: taken if true; operation encoding group selector: exu-side writers;

fill - principal op code: restore spilled operand from extended scratchpad; operation
encoding group selector: flow-side operations; possible manifest sizes in bytes: zero,
one, two, or four constant bytes;

flags - principal op code: access floating-point status metadata; arithmetic domain:
logical; operation encoding group selector: exu-side operations; operation signature
kind: belt operand from ops window, belt operand from ops windo

flip - Bit complement.

flips - Alias for flip.

flipu - Alias for flip.

floatArgs - principal op code: mode control for ganged floating point operation; arithmetic
domain: logical; operation encoding group selector: exu-side operations; operation
signature kind: belt operand from ops window, belt operand from ops windo

floatArgse - principal op code: mode control for ganged floating point operation; arithmetic
domain: logical; rounding policy: to nearest, ties toward even adjacent value;
operation encoding group selector: exu-side operations;

floatArgsfz - principal op code: mode control for ganged floating point operation; arithmetic
domain: logical; rounding policy: to nearest, ties away from zero; operation encoding
group selector: exu-side operations;

floatArgsn - principal op code: mode control for ganged floating point operation; arithmetic
domain: logical; rounding policy: toward negative infinity; operation encoding group
selector: exu-side operations;

floatArgsp - principal op code: mode control for ganged floating point operation; arithmetic
domain: logical; rounding policy: toward positive infinity; operation encoding group
selector: exu-side operations;

floatArgsz - principal op code: mode control for ganged floating point operation; arithmetic
domain: logical; rounding policy: toward zero; operation encoding group selector:
exu-side operations;

flowArgs - principal op code: four-byte constant continuation, conditional predicate, or other
ganged argument; operation encoding group selector: flow-side operations; possible
manifest sizes in bytes: zero, one, two, or four constant bytes; operation signature
kind: manifest constant, morsel-sized manifest constant, morsel-sized manifest
constant, morsel-sized manifest constan

fma - principal op code: fused multiply-add or -add/subtract; arithmetic domain: logical;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes by comparing result with zero;

fmad - Decimal floating point fused multiply-add.

fmade - Decimal floating point fused multiply-add.

fmadfz - Decimal floating point fused multiply-add.

fmadn - Decimal floating point fused multiply-add.

fmadp - Decimal floating point fused multiply-add.

fmadz - Decimal floating point fused multiply-add.

fmaf - Binary floating point fused multiply-add.

fmafe - Binary floating point fused multiply-add.

fmaffz - Binary floating point fused multiply-add.

fmafn - Binary floating point fused multiply-add.

fmafp - Binary floating point fused multiply-add.

fmafz - Binary floating point fused multiply-add.

fmas - Alias for fma.

fmas2 - Alias for fmas.

fmass - principal op code: fused multiply-add or -add/subtract; arithmetic domain: signed
integer; overflow policy: saturating; single vs dual vector result: single; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

fmass2 - Alias for fmass.

fmasw - principal op code: fused multiply-add or -add/subtract; arithmetic domain: signed
integer; overflow policy: widening; single vs dual vector result: single; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

fmasw2 - principal op code: fused multiply-add or -add/subtract; arithmetic domain: signed
integer; overflow policy: widening; single vs dual vector result: dual; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

fmasx - principal op code: fused multiply-add or -add/subtract; arithmetic domain: signed
integer; overflow policy: excepting; single vs dual vector result: single; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

fmasx2 - Alias for fmasx.

fmau - Alias for fma.

fmau2 - Alias for fmau.

fmaus - principal op code: fused multiply-add or -add/subtract; arithmetic domain: unsigned
integer; overflow policy: saturating; single vs dual vector result: single; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

fmaus2 - Alias for fmaus.

fmauw - principal op code: fused multiply-add or -add/subtract; arithmetic domain: unsigned
integer; overflow policy: widening; single vs dual vector result: single; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

fmauw2 - principal op code: fused multiply-add or -add/subtract; arithmetic domain: unsigned
integer; overflow policy: widening; single vs dual vector result: dual; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

fmaux - principal op code: fused multiply-add or -add/subtract; arithmetic domain: unsigned
integer; overflow policy: excepting; single vs dual vector result: single; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

fmaux2 - Alias for fmaux.

geqd - Decimal float greater than or equal comparison.

geqdb - principal op code: greater than or equal; arithmetic domain: decimal floating point;
NaN-awareness: NaN-unaware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

geqdx - Decimal float greater than or equal comparison. NaN-Aware.

geqdxb - principal op code: greater than or equal; arithmetic domain: decimal floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

geqf - Binary float greater than or equal comparison.

geqfb - principal op code: greater than or equal; arithmetic domain: binary floating point;
NaN-awareness: NaN-unaware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

geqfx - Binary float greater than or equal comparison. NaN-Aware.

geqfxb - principal op code: greater than or equal; arithmetic domain: binary floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

geqp - principal op code: greater than or equal; arithmetic domain: pointer; retain
argument width or narrow to bool: result has same width as arguments; operation
encoding group selector: exu-side operations;

geqpb - principal op code: greater than or equal; arithmetic domain: pointer; retain
argument width or narrow to bool: result has "b" (bool) width; operation
encoding group selector: exu-side operations;

geqs - principal op code: greater than or equal; arithmetic domain: signed integer; retain
argument width or narrow to bool: result has same width as arguments; operation
encoding group selector: exu-side operations;

geqsb - principal op code: greater than or equal; arithmetic domain: signed integer; retain
argument width or narrow to bool: result has "b" (bool) width; operation
encoding group selector: exu-side operations;

gequ - principal op code: greater than or equal; arithmetic domain: unsigned integer;
retain argument width or narrow to bool: result has same width as arguments; operation
encoding group selector: exu-side operations;

gequb - principal op code: greater than or equal; arithmetic domain: unsigned integer;
retain argument width or narrow to bool: result has "b" (bool) width;
operation encoding group selector: exu-side operations;

globalize - principal op code: make pointer global; operation encoding group selector: flow-side
operations;

gtrd - Decimal float greater than comparison.

gtrdb - principal op code: greater than; arithmetic domain: decimal floating point;
NaN-awareness: NaN-unaware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

gtrdx - Decimal float greater than comparison. NaN-Aware.

gtrdxb - principal op code: greater than; arithmetic domain: decimal floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

gtrf - Binary float greater than comparison.

gtrfb - principal op code: greater than; arithmetic domain: binary floating point;
NaN-awareness: NaN-unaware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

gtrfx - Binary float greater than comparison. NaN-Aware.

gtrfxb - principal op code: greater than; arithmetic domain: binary floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

gtrp - principal op code: greater than; arithmetic domain: pointer; retain argument width
or narrow to bool: result has same width as arguments; operation encoding group
selector: exu-side operations;

gtrpb - principal op code: greater than; arithmetic domain: pointer; retain argument width
or narrow to bool: result has "b" (bool) width; operation encoding group
selector: exu-side operations;

gtrs - Signed integer greater than comparison.

gtrsb - principal op code: greater than; arithmetic domain: signed integer; retain argument
width or narrow to bool: result has "b" (bool) width; operation encoding
group selector: exu-side operations;

gtru - Unsigned integer greater than comparison.

gtrub - principal op code: greater than; arithmetic domain: unsigned integer; retain
argument width or narrow to bool: result has "b" (bool) width; operation
encoding group selector: exu-side operations;

imp - Bitwise implication.

imps - Alias for imp.

impu - Alias for imp.

incs2post - Alias for incspost.

incs2pre - Alias for incspre.

incspost - principal op code: increment and compare with second argument; arithmetic domain:
signed integer; overflow policy: modulo; single vs dual vector result: single; whether
side-effect uses pre- or post-action state: side effect uses post-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incspre - principal op code: increment and compare with second argument; arithmetic domain:
signed integer; overflow policy: modulo; single vs dual vector result: single; whether
side-effect uses pre- or post-action state: side effect uses pre-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incss2post - Alias for incsspost.

incss2pre - Alias for incsspre.

incsspost - principal op code: increment and compare with second argument; arithmetic domain:
signed integer; overflow policy: saturating; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses post-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incsspre - principal op code: increment and compare with second argument; arithmetic domain:
signed integer; overflow policy: saturating; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses pre-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incsw2post - principal op code: increment and compare with second argument; arithmetic domain:
signed integer; overflow policy: widening; single vs dual vector result: dual; whether
side-effect uses pre- or post-action state: side effect uses post-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incsw2pre - principal op code: increment and compare with second argument; arithmetic domain:
signed integer; overflow policy: widening; single vs dual vector result: dual; whether
side-effect uses pre- or post-action state: side effect uses pre-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incswpost - principal op code: increment and compare with second argument; arithmetic domain:
signed integer; overflow policy: widening; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses post-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incswpre - principal op code: increment and compare with second argument; arithmetic domain:
signed integer; overflow policy: widening; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses pre-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incsx2post - Alias for incsxpost.

incsx2pre - Alias for incsxpre.

incsxpost - principal op code: increment and compare with second argument; arithmetic domain:
signed integer; overflow policy: excepting; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses post-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incsxpre - principal op code: increment and compare with second argument; arithmetic domain:
signed integer; overflow policy: excepting; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses pre-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incu2post - Alias for incupost.

incu2pre - Alias for incupre.

incupost - principal op code: increment and compare with second argument; arithmetic domain:
unsigned integer; overflow policy: modulo; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses post-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incupre - principal op code: increment and compare with second argument; arithmetic domain:
unsigned integer; overflow policy: modulo; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses pre-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incus2post - Alias for incuspost.

incus2pre - Alias for incuspre.

incuspost - principal op code: increment and compare with second argument; arithmetic domain:
unsigned integer; overflow policy: saturating; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses post-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incuspre - principal op code: increment and compare with second argument; arithmetic domain:
unsigned integer; overflow policy: saturating; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses pre-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incuw2post - principal op code: increment and compare with second argument; arithmetic domain:
unsigned integer; overflow policy: widening; single vs dual vector result: dual;
whether side-effect uses pre- or post-action state: side effect uses post-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incuw2pre - principal op code: increment and compare with second argument; arithmetic domain:
unsigned integer; overflow policy: widening; single vs dual vector result: dual;
whether side-effect uses pre- or post-action state: side effect uses pre-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incuwpost - principal op code: increment and compare with second argument; arithmetic domain:
unsigned integer; overflow policy: widening; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses post-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incuwpre - principal op code: increment and compare with second argument; arithmetic domain:
unsigned integer; overflow policy: widening; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses pre-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incux2post - Alias for incuxpost.

incux2pre - Alias for incuxpre.

incuxpost - principal op code: increment and compare with second argument; arithmetic domain:
unsigned integer; overflow policy: excepting; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses post-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

incuxpre - principal op code: increment and compare with second argument; arithmetic domain:
unsigned integer; overflow policy: excepting; single vs dual vector result: single;
whether side-effect uses pre- or post-action state: side effect uses pre-action state;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes explicitly;

inject - Replace a vector element with a different scalar value.

inner - Unconditional loop.

innerfl - Predicated loop on false condition.

innerfls - principal op code: enter a loop; sense of condition: taken if false; suppress or
permit in-flights across branches: discard in flight operations when taking branch;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

inners - principal op code: enter a loop; sense of condition: taken unconditionally; suppress
or permit in-flights across branches: discard in flight operations when taking branch;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

innertr - Predicated loop on true condition.

innertrs - principal op code: enter a loop; sense of condition: taken if true; suppress or
permit in-flights across branches: discard in flight operations when taking branch;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

integerde - Inexactly round a decimal float to an integer valued float. Rounds towards nearest even.

integerdee - principal op code: round to integral-valued float; arithmetic domain: decimal
floating point; exact result required: exact; rounding policy: to nearest, ties toward
even adjacent value; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

integerdefz - principal op code: round to integral-valued float; arithmetic domain: decimal
floating point; exact result required: exact; rounding policy: to nearest, ties away
from zero; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerden - principal op code: round to integral-valued float; arithmetic domain: decimal
floating point; exact result required: exact; rounding policy: toward negative
infinity; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerdep - principal op code: round to integral-valued float; arithmetic domain: decimal
floating point; exact result required: exact; rounding policy: toward positive
infinity; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerdez - principal op code: round to integral-valued float; arithmetic domain: decimal
floating point; exact result required: exact; rounding policy: toward zero; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

integerdi - principal op code: round to integral-valued float; arithmetic domain: decimal
floating point; exact result required: inexact; rounding policy: use current dynamic
rounding mode; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerdie - principal op code: round to integral-valued float; arithmetic domain: decimal
floating point; exact result required: inexact; rounding policy: to nearest, ties
toward even adjacent value; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

integerdifz - principal op code: round to integral-valued float; arithmetic domain: decimal
floating point; exact result required: inexact; rounding policy: to nearest, ties away
from zero; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerdin - principal op code: round to integral-valued float; arithmetic domain: decimal
floating point; exact result required: inexact; rounding policy: toward negative
infinity; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerdip - principal op code: round to integral-valued float; arithmetic domain: decimal
floating point; exact result required: inexact; rounding policy: toward positive
infinity; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerdiz - principal op code: round to integral-valued float; arithmetic domain: decimal
floating point; exact result required: inexact; rounding policy: toward zero; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

integerfe - Inexactly round a binary float to an integer valued float. Rounds towards nearest even.

integerfee - principal op code: round to integral-valued float; arithmetic domain: binary
floating point; exact result required: exact; rounding policy: to nearest, ties toward
even adjacent value; operation encoding group selector: exu-side operations; condition
code generator: generate condition codes by comparing result with zero; operation
signature kind: belt operand from ops windo

integerfefz - principal op code: round to integral-valued float; arithmetic domain: binary
floating point; exact result required: exact; rounding policy: to nearest, ties away
from zero; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerfen - principal op code: round to integral-valued float; arithmetic domain: binary
floating point; exact result required: exact; rounding policy: toward negative
infinity; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerfep - principal op code: round to integral-valued float; arithmetic domain: binary
floating point; exact result required: exact; rounding policy: toward positive
infinity; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerfez - principal op code: round to integral-valued float; arithmetic domain: binary
floating point; exact result required: exact; rounding policy: toward zero; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

integerfi - principal op code: round to integral-valued float; arithmetic domain: binary
floating point; exact result required: inexact; rounding policy: use current dynamic
rounding mode; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerfie - principal op code: round to integral-valued float; arithmetic domain: binary
floating point; exact result required: inexact; rounding policy: to nearest, ties
toward even adjacent value; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

integerfifz - principal op code: round to integral-valued float; arithmetic domain: binary
floating point; exact result required: inexact; rounding policy: to nearest, ties away
from zero; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerfin - principal op code: round to integral-valued float; arithmetic domain: binary
floating point; exact result required: inexact; rounding policy: toward negative
infinity; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerfip - principal op code: round to integral-valued float; arithmetic domain: binary
floating point; exact result required: inexact; rounding policy: toward positive
infinity; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

integerfiz - principal op code: round to integral-valued float; arithmetic domain: binary
floating point; exact result required: inexact; rounding policy: toward zero; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

isNaR - principal op code: test for NaR-hood; arithmetic domain: logical; retain argument
width or narrow to bool: result has same width as arguments; operation encoding group
selector: exu-side operations;

isNaRb - principal op code: test for NaR-hood; arithmetic domain: logical; retain argument
width or narrow to bool: result has "b" (bool) width; operation encoding
group selector: exu-side operations;

isNilp - principal op code: test for nil pointer; arithmetic domain: pointer; retain argument
width or narrow to bool: result has same width as arguments; operation encoding group
selector: exu-side operations;

isNilpb - principal op code: test for nil pointer; arithmetic domain: pointer; retain argument
width or narrow to bool: result has "b" (bool) width; operation encoding
group selector: exu-side operations;

isNone - principal op code: test for None-hood; arithmetic domain: logical; retain argument
width or narrow to bool: result has same width as arguments; operation encoding group
selector: exu-side operations;

isNoneb - principal op code: test for None-hood; arithmetic domain: logical; retain argument
width or narrow to bool: result has "b" (bool) width; operation encoding
group selector: exu-side operations;

isntNilp - principal op code: test for non-nil pointer; arithmetic domain: pointer; retain
argument width or narrow to bool: result has same width as arguments; operation
encoding group selector: exu-side operations;

isntNilpb - principal op code: test for non-nil pointer; arithmetic domain: pointer; retain
argument width or narrow to bool: result has "b" (bool) width; operation
encoding group selector: exu-side operations;

join - principal op code: bitwise concatenate; arithmetic domain: logical; single vs dual
vector result: single; operation encoding group selector: exu-side operations;

join2 - principal op code: bitwise concatenate; arithmetic domain: logical; single vs dual
vector result: dual; operation encoding group selector: exu-side operations; operation
signature kind: belt operand from ops window, belt operand from ops windo

lea - Load Effective Address.

leas - principal op code: load effective address; addressing base: register; whether index
in a memory reference is signed or unsigned: index is signed; index scale factor: index
is in byte units; operation encoding group selector: flow-side operations; possible
manifest sizes in bytes: zero, one, two, or four constant bytes; operation signature
kind: base special register, manifest constant, belt operand from opsWindo

leass - principal op code: load effective address; addressing base: register; whether index
in a memory reference is signed or unsigned: index is signed; index scale factor: index
is in scalar width units; operation encoding group selector: flow-side operations;
possible manifest sizes in bytes: zero, one, two, or four constant bytes; operation
signature kind: base special register, manifest constant, belt operand from opsWindow,
data width and vector length (flo

leau - principal op code: load effective address; addressing base: register; whether index
in a memory reference is signed or unsigned: index is unsigned; index scale factor:
index is in byte units; operation encoding group selector: flow-side operations;
possible manifest sizes in bytes: zero, one, two, or four constant bytes; operation
signature kind: base special register, manifest constant, belt operand from
opsWindo

leaus - principal op code: load effective address; addressing base: register; whether index
in a memory reference is signed or unsigned: index is unsigned; index scale factor:
index is in scalar width units; operation encoding group selector: flow-side
operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;

leave - principal op code: exit a loop; sense of condition: taken unconditionally; suppress
or permit in-flights across branches: preserve in flight operations when taking branch;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

leavefl - principal op code: exit a loop; sense of condition: taken if false; suppress or
permit in-flights across branches: preserve in flight operations when taking branch;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

leavefls - principal op code: exit a loop; sense of condition: taken if false; suppress or
permit in-flights across branches: discard in flight operations when taking branch;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

leaves - principal op code: exit a loop; sense of condition: taken unconditionally; suppress
or permit in-flights across branches: discard in flight operations when taking branch;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

leavetr - principal op code: exit a loop; sense of condition: taken if true; suppress or
permit in-flights across branches: preserve in flight operations when taking branch;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

leavetrs - principal op code: exit a loop; sense of condition: taken if true; suppress or
permit in-flights across branches: discard in flight operations when taking branch;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

left - Count leading false in or construct bool vector with leading false.

leqd - Decimal float lesser than or equal comparison.

leqdb - principal op code: less than or equal; arithmetic domain: decimal floating point;
NaN-awareness: NaN-unaware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

leqdx - Decimal float lesser than or equal comparison. NaN-Aware.

leqdxb - principal op code: less than or equal; arithmetic domain: decimal floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

leqf - Binary float lesser than or equal comparison.

leqfb - principal op code: less than or equal; arithmetic domain: binary floating point;
NaN-awareness: NaN-unaware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

leqfx - Binary float lesser than or equal comparison. NaN-Aware.

leqfxb - principal op code: less than or equal; arithmetic domain: binary floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

leqp - principal op code: less than or equal; arithmetic domain: pointer; retain argument
width or narrow to bool: result has same width as arguments; operation encoding group
selector: exu-side operations;

leqpb - principal op code: less than or equal; arithmetic domain: pointer; retain argument
width or narrow to bool: result has "b" (bool) width; operation encoding
group selector: exu-side operations;

leqs - Signed integer lesser than or equal comparison.

leqsb - principal op code: less than or equal; arithmetic domain: signed integer; retain
argument width or narrow to bool: result has "b" (bool) width; operation
encoding group selector: exu-side operations;

lequ - Unsigned integer lesser than or equal comparison.

lequb - principal op code: less than or equal; arithmetic domain: unsigned integer; retain
argument width or narrow to bool: result has "b" (bool) width; operation
encoding group selector: exu-side operations;

load - Schedule data load from memory address into belt.

loadfl - principal op code: load from memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken if false; operation encoding group selector:
flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
constant bytes;

loadfls - principal op code: load from memory; arithmetic domain: logical; addressing base:
register; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

loadflss - principal op code: load from memory; arithmetic domain: logical; addressing base:
register; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

loadflu - principal op code: load from memory; arithmetic domain: logical; addressing base:
register; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

loadflus - principal op code: load from memory; arithmetic domain: logical; addressing base:
register; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

loadRefresh - principal op code: reporting pseudo operation for refreshing loads that lost their
station to interrupts or calls; operation encoding group selector: retire station
retire paths;

loads - principal op code: load from memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken unconditionally; whether index in a memory reference
is signed or unsigned: index is signed; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

loadss - principal op code: load from memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken unconditionally; whether index in a memory reference
is signed or unsigned: index is signed; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

loadtr - principal op code: load from memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken if true; operation encoding group selector:
flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
constant bytes;

loadtrs - principal op code: load from memory; arithmetic domain: logical; addressing base:
register; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

loadtrss - principal op code: load from memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

loadtru - principal op code: load from memory; arithmetic domain: logical; addressing base:
register; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

loadtrus - principal op code: load from memory; arithmetic domain: logical; addressing base:
register; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

loadu - principal op code: load from memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken unconditionally; whether index in a memory reference
is signed or unsigned: index is unsigned; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

loadus - principal op code: load from memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken unconditionally; whether index in a memory reference
is signed or unsigned: index is unsigned; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

localize - principal op code: make pointer local; operation encoding group selector: flow-side
operations;

logBd - principal op code: extract exponent; arithmetic domain: decimal floating point;
operation encoding group selector: exu-side operations;

logBf - principal op code: extract exponent; arithmetic domain: binary floating point;
operation encoding group selector: exu-side operations;

longjmpl - target:p

lssd - Decimal float lesser than comparison.

lssdb - principal op code: less than; arithmetic domain: decimal floating point;
NaN-awareness: NaN-unaware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

lssdx - Decimal float lesser than comparison. NaN-Aware.

lssdxb - principal op code: less than; arithmetic domain: decimal floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

lssf - Binary float lesser than comparison.

lssfb - principal op code: less than; arithmetic domain: binary floating point;
NaN-awareness: NaN-unaware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

lssfx - Binary float lesser than comparison. NaN-Aware.

lssfxb - principal op code: less than; arithmetic domain: binary floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

lssp - Pointer lesser than.

lsspb - principal op code: less than; arithmetic domain: pointer; retain argument width or
narrow to bool: result has "b" (bool) width; operation encoding group
selector: exu-side operations;

lsss - Signed integer lesser than comparison.

lsssb - principal op code: less than; arithmetic domain: signed integer; retain argument
width or narrow to bool: result has "b" (bool) width; operation encoding
group selector: exu-side operations;

lssu - Unsigned integer lesser than comparison.

lssub - principal op code: less than; arithmetic domain: unsigned integer; retain argument
width or narrow to bool: result has "b" (bool) width; operation encoding
group selector: exu-side operations;

mask - Convert between bitmasks and bool vectors.

maxd - Decimal maximum.

maxf - Binary float maximum.

merge - Bitwise merge.

mind - Decimal minimum.

minf - Binary float minimum.

mul - Integer multiplication.

muld - Decimal floating point multiplication in current rounding mode.

mulde - Decimal floating point multiplication in current rounding to even.

muldfz - Decimal floating point multiplication in current rounding away from zero.

muldn - Decimal floating point multiplication in current rounding to nearest.

muldp - Decimal floating point multiplication in current rounding towards positive infinity.

muldz - Decimal floating point multiplication in current rounding towards zero.

mulf - Floating point multplication in current rounding mode.

mulfe - Floating point multplication in current rounding to even.

mulffz - Floating point multplication in current rounding away from zero.

mulfn - Floating point multplication in current rounding to nearest.

mulfp - Floating point multplication in current rounding towards positive infinity.

mulfz - Floating point multplication in current rounding towards zero.

muls - Alias for mul.

muls2 - Alias for muls.

mulsf - Signed Fixed Point multiply. Uses current dynamic rounding mode.

mulsfe - Signed Fixed Point multiply. Rounds towards nearest even.

mulsffz - Signed Fixed Point multiply. Rounds towards nearest away from zero.

mulsfn - Signed Fixed Point multiply. Rounds towards negative infinity.

mulsfp - Signed Fixed Point multiply. Rounds towards positive infinity.

mulsfs - Signed Fixed Point multiply. Uses current dynamic rounding mode.

mulsfse - Signed Fixed Point multiply. Rounds towards nearest even.

mulsfsfz - Signed Fixed Point multiply. Rounds towards nearest away from zero.

mulsfsn - Signed Fixed Point multiply. Rounds towards negative infinity.

mulsfsp - Signed Fixed Point multiply. Rounds towards positive infinity.

mulsfsz - Signed Fixed Point multiply. Rounds towards zero.

mulsfw - Signed Fixed Point multiply. Uses current dynamic rounding mode.

mulsfwe - Signed Fixed Point multiply. Rounds towards nearest even.

mulsfwfz - Signed Fixed Point multiply. Rounds towards nearest away from zero.

mulsfwn - Signed Fixed Point multiply. Rounds towards negative infinity.

mulsfwp - Signed Fixed Point multiply. Rounds towards positive infinity.

mulsfwz - Signed Fixed Point multiply. Rounds towards zero.

mulsfx - Signed Fixed Point multiply. Uses current dynamic rounding mode.

mulsfxe - Signed Fixed Point multiply. Rounds towards nearest even.

mulsfxfz - Signed Fixed Point multiply. Rounds towards nearest away from zero.

mulsfxn - Signed Fixed Point multiply. Rounds towards negative infinity.

mulsfxp - Signed Fixed Point multiply. Rounds towards positive infinity.

mulsfxz - Signed Fixed Point multiply. Rounds towards zero.

mulsfz - Signed Fixed Point multiply. Rounds towards zero.

mulss - Signed Integer multiply. Saturating.

mulss2 - Alias for mulss.

mulsw - Signed Integer multiply. Widening.

mulsw2 - principal op code: multiplication; arithmetic domain: signed integer; overflow
policy: widening; single vs dual vector result: dual; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

mulsx - Signed Integer multiply. Excepting.

mulsx2 - Alias for mulsx.

mulu - Alias for mul.

mulu2 - Alias for mulu.

muluf - Unsigned Fixed Point multiply. Uses current dynamic rounding mode.

mulufe - Unsigned Fixed Point multiply. Rounds towards nearest even.

muluffz - Unsigned Fixed Point multiply. Rounds towards nearest away from zero.

mulufn - Unsigned Fixed Point multiply. Rounds towards negative infinity.

mulufp - Unsigned Fixed Point multiply. Rounds towards positive infinity.

mulufs - Unsigned Fixed Point multiply. Uses current dynamic rounding mode.

mulufse - Unsigned Fixed Point multiply. Rounds towards nearest even.

mulufsfz - Unsigned Fixed Point multiply. Rounds towards nearest away from zero.

mulufsn - Unsigned Fixed Point multiply. Rounds towards negative infinity.

mulufsp - Unsigned Fixed Point multiply. Rounds towards positive infinity.

mulufsz - Unsigned Fixed Point multiply. Rounds towards zero.

mulufw - Unsigned Fixed Point multiply. Uses current dynamic rounding mode.

mulufwe - Unsigned Fixed Point multiply. Rounds towards nearest even.

mulufwfz - Unsigned Fixed Point multiply. Rounds towards nearest away from zero.

mulufwn - Unsigned Fixed Point multiply. Rounds towards negative infinity.

mulufwp - Unsigned Fixed Point multiply. Rounds towards positive infinity.

mulufwz - Unsigned Fixed Point multiply. Rounds towards zero.

mulufx - Unsigned Fixed Point multiply. Uses current dynamic rounding mode.

mulufxe - Unsigned Fixed Point multiply. Rounds towards nearest even.

mulufxfz - Unsigned Fixed Point multiply. Rounds towards nearest away from zero.

mulufxn - Unsigned Fixed Point multiply. Rounds towards negative infinity.

mulufxp - Unsigned Fixed Point multiply. Rounds towards positive infinity.

mulufxz - Unsigned Fixed Point multiply. Rounds towards zero.

mulufz - Unsigned Fixed Point multiply. Rounds towards zero.

mulus - Unsigned integer multiply. Saturating.

mulus2 - Alias for mulus.

muluw - Unsigned integer multiply. Widening.

muluw2 - principal op code: multiplication; arithmetic domain: unsigned integer; overflow
policy: widening; single vs dual vector result: dual; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

mulux - Unsigned integer multiply. Excepting.

mulux2 - Alias for mulux.

nand - Bitwise nand.

nands - Alias for nand.

nandu - Alias for nand.

NaR - Produces a NaR of the given width and kind.

narrowd - Half the width of a decimal float value. Current rounding mode.

narrowde - Half the width of a decimal float value. Rounding to nearest even.

narrowdfz - Half the width of a decimal float value. Rounding to nearest away from zero.

narrowdn - Half the width of a decimal float value. Rounding towards negative infinity.

narrowdp - Half the width of a decimal float value. Rounding towards positive infinity.

narrowdz - Half the width of a decimal float value. Rounding towards zero.

narrowf - Half the width of a binary float value. Current rounding mode.

narrowfe - Half the width of a binary float value. Rounding to nearest even.

narrowffz - Half the width of a binary float value. Rounding to nearest away from zero.

narrowfn - Half the width of a binary float value. Rounding towards negative infinity.

narrowfp - Half the width of a binary float value. Rounding towards positive infinity.

narrowfz - Half the width of a binary float value. Rounding towards zero.

narrows - principal op code: narrow scalar to half width; arithmetic domain: signed integer;
overflow policy: modulo; single vs dual vector result: single; operation encoding group
selector: exu-side operations;

narrows2 - principal op code: narrow scalar to half width; arithmetic domain: signed integer;
overflow policy: modulo; single vs dual vector result: dual; operation encoding group
selector: exu-side operations;

narrowss - Half the width of a signed integer value. Saturating on overflow.

narrowss2 - principal op code: narrow scalar to half width; arithmetic domain: signed integer;
overflow policy: saturating; single vs dual vector result: dual; operation encoding
group selector: exu-side operations;

narrowsx - Half the width of a signed integer value. Exception on overflow.

narrowsx2 - principal op code: narrow scalar to half width; arithmetic domain: signed integer;
overflow policy: excepting; single vs dual vector result: dual; operation encoding
group selector: exu-side operations;

narrowu - principal op code: narrow scalar to half width; arithmetic domain: unsigned integer;
overflow policy: modulo; single vs dual vector result: single; operation encoding group
selector: exu-side operations;

narrowu2 - principal op code: narrow scalar to half width; arithmetic domain: unsigned integer;
overflow policy: modulo; single vs dual vector result: dual; operation encoding group
selector: exu-side operations;

narrowus - Half the width of an unsigned integer value. Saturating on overflow.

narrowus2 - principal op code: narrow scalar to half width; arithmetic domain: unsigned integer;
overflow policy: saturating; single vs dual vector result: dual; operation encoding
group selector: exu-side operations;

narrowux - Half the width of an unsigned integer value. Exception on overflow.

narrowux2 - principal op code: narrow scalar to half width; arithmetic domain: unsigned integer;
overflow policy: excepting; single vs dual vector result: dual; operation encoding
group selector: exu-side operations;

negd - Decimal float arithmetic negation.

negf - Binary float arithmetic negation.

neq - Integer inequality comparison.

neqb - principal op code: not equal; arithmetic domain: logical; retain argument width or
narrow to bool: result has "b" (bool) width; operation encoding group
selector: exu-side operations;

neqd - Decimal float inequality comparison.

neqdb - principal op code: not equal; arithmetic domain: decimal floating point;
NaN-awareness: NaN-unaware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

neqdx - Decimal float inequality comparison. NaN-Aware.

neqdxb - principal op code: not equal; arithmetic domain: decimal floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

neqf - Binary float inequality comparison.

neqfb - principal op code: not equal; arithmetic domain: binary floating point;
NaN-awareness: NaN-unaware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

neqfx - Binary float inequality comparison. NaN-Aware.

neqfxb - principal op code: not equal; arithmetic domain: binary floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

neqp - Pointer inequality.

neqpb - principal op code: not equal; arithmetic domain: pointer; retain argument width or
narrow to bool: result has "b" (bool) width; operation encoding group
selector: exu-side operations;

neqs - Alias for neq.

neqsb - Alias for neqb.

nequ - Alias for neq.

nequb - Alias for neqb.

nextDownd - principal op code: next smaller representable value; arithmetic domain: decimal
floating point; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

nextDownf - principal op code: next smaller representable value; arithmetic domain: binary
floating point; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

nextUpd - principal op code: next larger representable value; arithmetic domain: decimal
floating point; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

nextUpf - principal op code: next larger representable value; arithmetic domain: binary
floating point; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops windo

nimp - Bitwise negative implication.

nimps - Alias for nimp.

nimpu - Alias for nimp.

nope - No operation. Exu side.

nopf - No operation. Flow side.

nor - Bitwise nor.

norddx - principal op code: unordered relation; arithmetic domain: decimal floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has same
width as arguments; operation encoding group selector: exu-side operations; operation
signature kind: belt operand from ops window, belt operand from ops windo

norddxb - principal op code: unordered relation; arithmetic domain: decimal floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

nordfx - principal op code: unordered relation; arithmetic domain: binary floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has same
width as arguments; operation encoding group selector: exu-side operations; operation
signature kind: belt operand from ops window, belt operand from ops windo

nordfxb - principal op code: unordered relation; arithmetic domain: binary floating point;
NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
"b" (bool) width; operation encoding group selector: exu-side operations;

nors - Alias for nor.

noru - Alias for nor.

notl - Logical not.

notls - Alias for notl.

notlu - Alias for notl.

nxor - Bitwise nxor.

nxors - Alias for nxor.

nxoru - Alias for nxor.

ones - Count all the one bits in the value.

orddx - principal op code: ordered relation; arithmetic domain: decimal floating point;
NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;

ordfx - principal op code: ordered relation; arithmetic domain: binary floating point;
NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;

orl - Bitwise or.

orls - Alias for orl.

orlu - Alias for orl.

overflow - Gets the overflow condition code of the ganged operation and puts it on the belt.

overflowb - principal op code: overflow gang predicate; arithmetic domain: logical; retain
argument width or narrow to bool: result has "b" (bool) width; operation
encoding group selector: exu-side operations;

p2u - principal op code: convert pointer to unsigned integer; operation encoding group
selector: flow-side operations;

pick - Pick between two values based on a condition.

pickup - principal op code: accept a speculative load; arithmetic domain: logical; sense of
condition: taken unconditionally; operation encoding group selector: exu-side readers;

pickupfl - principal op code: accept a speculative load; arithmetic domain: logical; sense of
condition: taken if false; operation encoding group selector: exu-side readers;

pickuptr - principal op code: accept a speculative load; arithmetic domain: logical; sense of
condition: taken if true; operation encoding group selector: exu-side readers;

quantized - principal op code: left value with right quantum; arithmetic domain: decimal
floating point; operation encoding group selector: exu-side operations; operation
signature kind: belt operand from ops window, belt operand from ops windo

rd - principal op code: hardware reader; arithmetic domain: logical; operation encoding
group selector: exu-side readers;

recur - Pick between two values based on a condition value being a NaR or not.

refuse - principal op code: reject a speculative load; arithmetic domain: logical; operation
encoding group selector: exu-side readers;

remd - Decimal float modulo.

remf - Binary float modulo.

rems - Signed integer modulo for remainder.

remu - Unsigned integer modulo for remainder.

rescue - Move belt items to the front of the belt.

resf - principal op code: reserve space for results returned in memory; operation encoding
group selector: flow-side operations; possible manifest sizes in bytes: zero, one, two,
or four constant bytes;

resolve - principal op code: resolve a pointer as a data reference; arithmetic domain:
logical; operation encoding group selector: exu-side operations; operation signature
kind: belt operand from ops windo

resolvep - Alias for resolve.

restoreStack - principal op code: restore stack pointer at end of dynamic array scope; arithmetic
domain: logical; operation encoding group selector: flow-side operations; operation
signature kind:

retire - principal op code: minimum retire count pseudo-op, or the widths of the retirees;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

retn - Returns values and control to the caller.

retnfl - Conditionally returns values and control to the caller on false.

retntr - Conditionally returns values and control to the caller on true.

reverse - Reverse the bit order.

rootd - Decimal floating point square root in current rounding mode.

rootde - Decimal floating point square root rounding towards even.

rootdfz - Decimal floating point square root rounding away from zero.

rootdn - Decimal floating point square root rounding towards nearest.

rootdp - Decimal floating point square root rounding towards positive infinity.

rootdz - Decimal floating point square root rounding towards zero.

rootf - Floating point square root in current rounding mode.

rootfe - Floating point square root rounding towards even.

rootffz - Floating point square root rounding away from zero.

rootfn - Floating point square root rounding towards nearest.

rootfp - Floating point square root rounding towards positive infinity.

rootfz - Floating point square root rounding towards zero.

roots - Signed integer square root. Helper operation for software square root implementation.

rootu - Unsigned integer square root. Helper operation for software square root implementation.

rotatel - Bit rotate left.

rotater - Bit rotate right.

rrootd - Decimal float reciprocal square root.

rrootde - principal op code: reciprocal square root; arithmetic domain: decimal floating
point; rounding policy: to nearest, ties toward even adjacent value; operation encoding
group selector: exu-side operations; condition code generator: generate condition codes
by comparing result with zero;

rrootdfz - principal op code: reciprocal square root; arithmetic domain: decimal floating
point; rounding policy: to nearest, ties away from zero; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

rrootdn - principal op code: reciprocal square root; arithmetic domain: decimal floating
point; rounding policy: toward negative infinity; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

rrootdp - principal op code: reciprocal square root; arithmetic domain: decimal floating
point; rounding policy: toward positive infinity; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

rrootdz - principal op code: reciprocal square root; arithmetic domain: decimal floating
point; rounding policy: toward zero; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

rrootf - Binary float reciprocal square root.

rrootfe - principal op code: reciprocal square root; arithmetic domain: binary floating point;
rounding policy: to nearest, ties toward even adjacent value; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

rrootffz - principal op code: reciprocal square root; arithmetic domain: binary floating point;
rounding policy: to nearest, ties away from zero; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

rrootfn - principal op code: reciprocal square root; arithmetic domain: binary floating point;
rounding policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

rrootfp - principal op code: reciprocal square root; arithmetic domain: binary floating point;
rounding policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

rrootfz - principal op code: reciprocal square root; arithmetic domain: binary floating point;
rounding policy: toward zero; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

rroots - principal op code: reciprocal square root; arithmetic domain: signed integer;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes by comparing result with zero;

rrootu - principal op code: reciprocal square root; arithmetic domain: unsigned integer;
operation encoding group selector: exu-side operations; condition code generator:
generate condition codes by comparing result with zero;

rsub - principal op code: reverse subtraction; arithmetic domain: logical; operation
encoding group selector: exu-side operations; condition code generator: generate
condition codes by comparing result with zero;

rsubs - Alias for rsub.

rsubs2 - Alias for rsubs.

rsubss - principal op code: reverse subtraction; arithmetic domain: signed integer; overflow
policy: saturating; single vs dual vector result: single; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

rsubss2 - Alias for rsubss.

rsubsw - principal op code: reverse subtraction; arithmetic domain: signed integer; overflow
policy: widening; single vs dual vector result: single; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

rsubsw2 - principal op code: reverse subtraction; arithmetic domain: signed integer; overflow
policy: widening; single vs dual vector result: dual; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

rsubsx - principal op code: reverse subtraction; arithmetic domain: signed integer; overflow
policy: excepting; single vs dual vector result: single; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

rsubsx2 - Alias for rsubsx.

rsubu - Alias for rsub.

rsubu2 - Alias for rsubu.

rsubus - principal op code: reverse subtraction; arithmetic domain: unsigned integer;
overflow policy: saturating; single vs dual vector result: single; operation encoding
group selector: exu-side operations; condition code generator: generate condition codes
by comparing result with zero;

rsubus2 - Alias for rsubus.

rsubuw - principal op code: reverse subtraction; arithmetic domain: unsigned integer;
overflow policy: widening; single vs dual vector result: single; operation encoding
group selector: exu-side operations; condition code generator: generate condition codes
by comparing result with zero;

rsubuw2 - principal op code: reverse subtraction; arithmetic domain: unsigned integer;
overflow policy: widening; single vs dual vector result: dual; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

rsubux - principal op code: reverse subtraction; arithmetic domain: unsigned integer;
overflow policy: excepting; single vs dual vector result: single; operation encoding
group selector: exu-side operations; condition code generator: generate condition codes
by comparing result with zero;

rsubux2 - Alias for rsubux.

s2fd - Signed integer to decimal float conversion. Current rounding mode.

s2fde - Signed integer to decimal float conversion. Rounding to even.

s2fdfz - Signed integer to decimal float conversion. Rounding away from zero.

s2fdn - Signed integer to decimal float conversion. Rounding towards negative infinity.

s2fdp - Signed integer to decimal float conversion. Rounding towards positive infinity.

s2fdz - Signed integer to decimal float conversion. Rounding towards zero.

s2ff - Signed integer to binary float conversion. Current rounding mode.

s2ffe - Signed integer to binary float conversion. Rounding to even.

s2fffz - Signed integer to binary float conversion. Rounding away from zero.

s2ffn - Signed integer to binary float conversion. Rounding towards negative infinity.

s2ffp - Signed integer to binary float conversion. Rounding towards positive infinity.

s2ffz - Signed integer to binary float conversion. Rounding towards zero.

s2u - Signed integer to unsigned integer.

s2u2 - principal op code: convert signed to unsigned; arithmetic domain: logical; overflow
policy: modulo; single vs dual vector result: dual; operation encoding group selector:
exu-side operations;

s2us - Signed integer to unsigned integer. Saturating.

s2us2 - principal op code: convert signed to unsigned; arithmetic domain: logical; overflow
policy: saturating; single vs dual vector result: dual; operation encoding group
selector: exu-side operations;

s2ux - Signed integer to unsigned integer. Excepting.

s2ux2 - principal op code: convert signed to unsigned; arithmetic domain: logical; overflow
policy: excepting; single vs dual vector result: dual; operation encoding group
selector: exu-side operations;

sameQuantumd - principal op code: same exponent; arithmetic domain: decimal floating point;
operation encoding group selector: exu-side operations;

saveStack - principal op code: save stack pointer at start of dynamic array scope; arithmetic
domain: logical; operation encoding group selector: flow-side operations; operation
signature kind:

scaleBd - principal op code: scale exponent; arithmetic domain: decimal floating point;
rounding policy: use current dynamic rounding mode; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

scaleBde - principal op code: scale exponent; arithmetic domain: decimal floating point;
rounding policy: to nearest, ties toward even adjacent value; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

scaleBdfz - principal op code: scale exponent; arithmetic domain: decimal floating point;
rounding policy: to nearest, ties away from zero; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

scaleBdn - principal op code: scale exponent; arithmetic domain: decimal floating point;
rounding policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

scaleBdp - principal op code: scale exponent; arithmetic domain: decimal floating point;
rounding policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

scaleBdz - principal op code: scale exponent; arithmetic domain: decimal floating point;
rounding policy: toward zero; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

scaleBf - principal op code: scale exponent; arithmetic domain: binary floating point;
rounding policy: use current dynamic rounding mode; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

scaleBfe - principal op code: scale exponent; arithmetic domain: binary floating point;
rounding policy: to nearest, ties toward even adjacent value; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

scaleBffz - principal op code: scale exponent; arithmetic domain: binary floating point;
rounding policy: to nearest, ties away from zero; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

scaleBfn - principal op code: scale exponent; arithmetic domain: binary floating point;
rounding policy: toward negative infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

scaleBfp - principal op code: scale exponent; arithmetic domain: binary floating point;
rounding policy: toward positive infinity; operation encoding group selector: exu-side
operations; condition code generator: generate condition codes by comparing result with
zero;

scaleBfz - principal op code: scale exponent; arithmetic domain: binary floating point;
rounding policy: toward zero; operation encoding group selector: exu-side operations;
condition code generator: generate condition codes by comparing result with zero;

scratchf - principal op code: allocate scratchpad frame; arithmetic domain: logical; operation
encoding group selector: exu-side readers;

set - Set a single indexed bit.

setjmp -

shiftl - Bitwise left shift.

shiftls - Alias for shiftl.

shiftls2 - Alias for shiftl.

shiftlss - Signed bitwise left shift. Saturating.

shiftlss2 - Alias for shiftlss.

shiftlsw - Signed bitwise left shift. Widening.

shiftlsw2 - principal op code: bitwise shift; shift direction: toward greater significance;
arithmetic domain: signed integer; overflow policy: widening; single vs dual vector
result: dual; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops window, belt operand from ops windo

shiftlsx - Signed bitwise left shift. Excepting.

shiftlsx2 - Alias for shiftlsx.

shiftlu - Alias for shiftl.

shiftlu2 - Alias for shiftlu.

shiftlus - Unsigned bitwise left shift. Saturating.

shiftlus2 - Alias for shiftlus.

shiftluw - Unsigned bitwise left shift. Widening.

shiftluw2 - principal op code: bitwise shift; shift direction: toward greater significance;
arithmetic domain: unsigned integer; overflow policy: widening; single vs dual vector
result: dual; operation encoding group selector: exu-side operations; condition code
generator: generate condition codes by comparing result with zero; operation signature
kind: belt operand from ops window, bit numbe

shiftlux - Unsigned bitwise left shift. Excepting.

shiftlux2 - Alias for shiftlux.

shiftrs - Signed bit shift right.

shiftrsf - Signed fixed point shift right. Current dynamic rounding.

shiftrsfe - Signed fixed point shift right. Rounds towards nearest even.

shiftrsffz - Signed fixed point shift right. Rounds towards nearest away from zero.

shiftrsfn - Signed fixed point shift right. Rounds towards negative infinity.

shiftrsfp - Signed fixed point shift right. Rounds towards positive infinity.

shiftrsfz - Signed fixed point shift right. Rounds towards zero.

shiftru - Unsigned bit shift right.

shiftruf - Unsigned fixed point shift right. Current dynamic rounding.

shiftrufe - Unsigned fixed point shift right. Rounds towards nearest even.

shiftruffz - Unsigned fixed point shift right. Rounds towards nearest away from zero.

shiftrufn - Unsigned fixed point shift right. Rounds towards negative infinity.

shiftrufp - Unsigned fixed point shift right. Rounds towards positive infinity.

shiftrufz - Unsigned fixed point shift right. Rounds towards zero.

shuffle - Create a new vector where the elements are the values of the first operand vector and their respective positions in the second operand vector.

sig - principal op code: assert width of belt operand; arithmetic domain: logical;
operation encoding group selector: exu-side writers;

smeari - Find the first one in a bool vector and set all remaining elments to one too.

smearx - Find the first one in a bool vector, shift it one to the right and set all remaining elments to one too.

spill - principal op code: spill operand to extended scratchpad; arithmetic domain: logical;
sense of condition: taken unconditionally; operation encoding group selector: exu-side
writers;

spillfl - principal op code: spill operand to extended scratchpad; arithmetic domain: logical;
sense of condition: taken if false; operation encoding group selector: exu-side
writers;

spilltr - principal op code: spill operand to extended scratchpad; arithmetic domain: logical;
sense of condition: taken if true; operation encoding group selector: exu-side writers;

splat - Duplicate a scalar value into a vector.

stackf - principal op code: allocate stack frame; operation encoding group selector:
flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
constant bytes;

store - Take a value from the belt and store it to the computed address.

storefl - principal op code: store to memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken if false; operation encoding group selector:
flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
constant bytes;

storefls - principal op code: store to memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

storeflss - principal op code: store to memory; arithmetic domain: logical; addressing base:
register; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

storeflu - principal op code: store to memory; arithmetic domain: logical; addressing base:
register; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

storeflus - principal op code: store to memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

storep - principal op code: store to memory; arithmetic domain: pointer; addressing base:
register; sense of condition: taken unconditionally; operation encoding group selector:
flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
constant bytes;

storepfl - principal op code: store to memory; arithmetic domain: pointer; addressing base:
register; sense of condition: taken if false; operation encoding group selector:
flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
constant bytes;

storepfls - principal op code: store to memory; arithmetic domain: pointer; addressing base:
register; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

storepflss - principal op code: store to memory; arithmetic domain: pointer; addressing base:
pointer; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

storepflu - principal op code: store to memory; arithmetic domain: pointer; addressing base:
pointer; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

storepflus - principal op code: store to memory; arithmetic domain: pointer; addressing base:
pointer; sense of condition: taken if false; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

storeps - principal op code: store to memory; arithmetic domain: pointer; addressing base:
register; sense of condition: taken unconditionally; whether index in a memory
reference is signed or unsigned: index is signed; index scale factor: index is in byte
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

storepss - principal op code: store to memory; arithmetic domain: pointer; addressing base:
pointer; sense of condition: taken unconditionally; whether index in a memory reference
is signed or unsigned: index is signed; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

storeptr - principal op code: store to memory; arithmetic domain: pointer; addressing base:
register; sense of condition: taken if true; operation encoding group selector:
flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
constant bytes;

storeptrs - principal op code: store to memory; arithmetic domain: pointer; addressing base:
pointer; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

storeptrss - principal op code: store to memory; arithmetic domain: pointer; addressing base:
register; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

storeptru - principal op code: store to memory; arithmetic domain: pointer; addressing base:
pointer; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

storeptrus - principal op code: store to memory; arithmetic domain: pointer; addressing base:
register; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

storepu - principal op code: store to memory; arithmetic domain: pointer; addressing base:
register; sense of condition: taken unconditionally; whether index in a memory
reference is signed or unsigned: index is unsigned; index scale factor: index is in
byte units; operation encoding group selector: flow-side operations; possible manifest
sizes in bytes: zero, one, two, or four constant bytes;

storepus - principal op code: store to memory; arithmetic domain: pointer; addressing base:
register; sense of condition: taken unconditionally; whether index in a memory
reference is signed or unsigned: index is unsigned; index scale factor: index is in
scalar width units; operation encoding group selector: flow-side operations; possible
manifest sizes in bytes: zero, one, two, or four constant bytes; operation signature
kind: late-evaluated operand from belt, base special register, manifest constant, belt
operand from opsWindo

stores - principal op code: store to memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken unconditionally; whether index in a memory reference
is signed or unsigned: index is signed; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

storess - principal op code: store to memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken unconditionally; whether index in a memory reference
is signed or unsigned: index is signed; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

storetr - principal op code: store to memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken if true; operation encoding group selector:
flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
constant bytes;

storetrs - principal op code: store to memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

storetrss - principal op code: store to memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is signed; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

storetru - principal op code: store to memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in byte units;
operation encoding group selector: flow-side operations; possible manifest sizes in
bytes: zero, one, two, or four constant bytes;

storetrus - principal op code: store to memory; arithmetic domain: logical; addressing base:
pointer; sense of condition: taken if true; whether index in a memory reference is
signed or unsigned: index is unsigned; index scale factor: index is in scalar width
units; operation encoding group selector: flow-side operations; possible manifest sizes
in bytes: zero, one, two, or four constant bytes;

storeu - principal op code: store to memory; arithmetic domain: logical; addressing base:
register; sense of condition: taken unconditionally; whether index in a memory
reference is signed or unsigned: index is unsigned; index scale factor: index is in
byte units; operation encoding group selector: flow-side operations; possible manifest
sizes in bytes: zero, one, two, or four constant bytes;

storeus - principal op code: store to memory; arithmetic domain: logical; addressing base:
register; sense of condition: taken unconditionally; whether index in a memory
reference is signed or unsigned: index is unsigned; index scale factor: index is in
scalar width units; operation encoding group selector: flow-side operations; possible
manifest sizes in bytes: zero, one, two, or four constant bytes; operation signature
kind: late-evaluated operand from belt, base special register, manifest constant, belt
operand from opsWindo

streamf - principal op code: allocate streamer frame; operation encoding group selector:
flow-side operations;

sub - Normal unsigned substraction.

subd - Decimal floating point subtraction in current rounding mode.

subde - Decimal floating point subtraction in current rounding to even.

subdfz - Decimal floating point subtraction in current rounding away from zero.

subdn - Decimal floating point subtraction in current rounding to nearest.

subdp - Decimal floating point subtraction in current rounding towards positive infinity.

subdz - Decimal floating point subtraction in current rounding towards zero.

subf - Floating point subtraction in current rounding mode.

subfe - Floating point subtraction in current rounding to even.

subffz - Floating point subtraction in current rounding away from zero.

subfn - Floating point subtraction in current rounding to nearest.

subfp - Floating point subtraction in current rounding towards positive infinity.

subfz - Floating point subtraction in current rounding towards zero.

subp - Pointer subtraction. Protects the upper 4 reserved bits, can be scaled for indexing.

subs - Alias for sub.

subs2 - Alias for subs.

subss - Saturating signed integer subtraction.

subss2 - Alias for subss.

subsw - Widening signed integer subtraction.

subsw2 - principal op code: subtraction; arithmetic domain: signed integer; overflow policy:
widening; single vs dual vector result: dual; operation encoding group selector:
exu-side operations; condition code generator: generate condition codes by comparing
result with zero;

subsx - Excepting signed integer subtraction.

subsx2 - Alias for subsx.

subu - Alias for sub.

subu2 - Alias for subu.

subus - Saturating unsigned integer subtraction.

subus2 - Alias for subus.

subuw - Widening unsigned integer subtraction.

subuw2 - principal op code: subtraction; arithmetic domain: unsigned integer; overflow
policy: widening; single vs dual vector result: dual; operation encoding group
selector: exu-side operations; condition code generator: generate condition codes by
comparing result with zero;

subux - Excepting unsigned integer subtraction.

subux2 - Alias for subux.

test - Test if a single indexed bit is set.

trap - principal op code: trigger a trap to a handler; arithmetic domain: logical; sense of
condition: taken unconditionally; operation encoding group selector: exu-side writers;

trapfl - principal op code: trigger a trap to a handler; arithmetic domain: logical; sense of
condition: taken if false; operation encoding group selector: exu-side writers;

traptr - principal op code: trigger a trap to a handler; arithmetic domain: logical; sense of
condition: taken if true; operation encoding group selector: exu-side writers;

u2fd - Unsigned integer to decimal float conversion. Current rounding mode.

u2fde - Unsigned integer to decimal float conversion. Rounding to even.

u2fdfz - Unsigned integer to decimal float conversion. Rounding away from zero.

u2fdn - Unsigned integer to decimal float conversion. Rounding towards negative infinity.

u2fdp - Unsigned integer to decimal float conversion. Rounding towards positive infinity.

u2fdz - Unsigned integer to decimal float conversion. Rounding towards zero.

u2ff - Unsigned integer to binary float conversion. Current rounding mode.

u2ffe - Unsigned integer to binary float conversion. Rounding to even.

u2fffz - Unsigned integer to binary float conversion. Rounding away from zero.

u2ffn - Unsigned integer to binary float conversion. Rounding towards negative infinity.

u2ffp - Unsigned integer to binary float conversion. Rounding towards positive infinity.

u2ffz - Unsigned integer to binary float conversion. Rounding towards zero.

u2p - principal op code: convert unsigned integer to pointer; operation encoding group
selector: flow-side operations;

u2s - Unsigned integer to signed integer.

u2s2 - Alias for u2s.

u2ss - Unsigned integer to signed integer. Saturating.

u2ss2 - Alias for u2ss.

u2sw - Unsigned integer to signed integer. Widening.

u2sw2 - principal op code: convert unsigned to signed; arithmetic domain: logical; overflow
policy: widening; single vs dual vector result: dual; operation encoding group
selector: exu-side operations;

u2sx - Unsigned integer to signed integer. Excepting.

u2sx2 - Alias for u2sx.

vec - Create a new vector from the scalar operand list.

widend - Double the scalar width of a decimal float.

widend2 - principal op code: widen to double width; arithmetic domain: decimal floating point;
single vs dual vector result: dual; operation encoding group selector: exu-side
operations;

widenf - Double the scalar width of a binary float.

widenf2 - principal op code: widen to double width; arithmetic domain: binary floating point;
single vs dual vector result: dual; operation encoding group selector: exu-side
operations;

widens - Double the scalar width of a signed integer.

widens2 - principal op code: widen to double width; arithmetic domain: signed integer; single
vs dual vector result: dual; operation encoding group selector: exu-side operations;

widensf - Double the scalar width of a signed fixed point value.

widensf2 - principal op code: widen to double width; arithmetic domain: signed fixed point;
single vs dual vector result: dual; operation encoding group selector: exu-side
operations;

widenu - principal op code: widen to double width; arithmetic domain: unsigned integer;
single vs dual vector result: single; operation encoding group selector: exu-side
operations;

widenu2 - principal op code: widen to double width; arithmetic domain: unsigned integer;
single vs dual vector result: dual; operation encoding group selector: exu-side
operations;

widenuf - Double the scalar width of an unsigned fixed point value.

widenuf2 - principal op code: widen to double width; arithmetic domain: unsigned fixed point;
single vs dual vector result: dual; operation encoding group selector: exu-side
operations;

wr - principal op code: hardware writer; arithmetic domain: logical; operation encoding
group selector: exu-side writers;

xorl - Bitwise xor.

xorls - Alias for xorl.

xorlu - Alias for xorl.