Difference between revisions of "Instruction Set"

Latest revision as of 13:24, 23 February 2021

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

a

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;

b

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;

c

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.

d

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

e

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.

f

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.

g

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;

i

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;

j

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

l

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;

m

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.

n

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.

o

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;

p

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;

q

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

r

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.

s

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.

t

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;

u

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.

v

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

w

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;

x

xorl - Bitwise xor.
xorls - Alias for xorl.
xorlu - Alias for xorl.

Difference between revisions of "Instruction Set"

Latest revision as of 13:24, 23 February 2021

Navigation menu

Personal tools

Namespaces

Variants

Views

Actions

Search

Navigation

Tools

@@ Line 9: / Line 9: @@
 [[Instruction_Set/abortAtomic|abortAtomic]] - <nowiki>principal op code: abort an in-progress atomic extent; operation encoding group
              selector: flow-side operations; </nowiki><br />
+[[Instruction_Set/activeRead|activeRead]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/add|add]] - This is the basic overflowing integer addition. With 32bit values it defines the [[Cycle]] on the Mill architecture.<br />
-[[Instruction_Set/add1u|add1u]] - Increment by one.
-<br />
 [[Instruction_Set/addd|addd]] - Decimal floating point add in current rounding mode.
 <br />
@@ Line 39: / Line 41: @@
 <br />
 [[Instruction_Set/adds|adds]] - Alias for [[Instruction_Set/add|add]].<br />
+[[Instruction_Set/adds2|adds2]] - Alias for [[Instruction_Set/add|add]].<br />
 [[Instruction_Set/addss|addss]] - Saturating signed integer addition.
 <br />
-[[Instruction_Set/addssv|addssv]] - Alias for [[Instruction_Set/addss|addss]].<br />
+[[Instruction_Set/addss2|addss2]] - Alias for [[Instruction_Set/addss|addss]].<br />
-[[Instruction_Set/addsv|addsv]] - Alias for [[Instruction_Set/add|add]].<br />
 [[Instruction_Set/addsw|addsw]] - Widening signed integer addition.
 <br />
-[[Instruction_Set/addswv|addswv]] - Widening signed integer vector addition.
+[[Instruction_Set/addsw2|addsw2]] - <nowiki>principal op code: addition; arithmetic domain: signed integer; overflow policy:
-<br />
+            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; </nowiki><br />
 [[Instruction_Set/addsx|addsx]] - Excepting signed integer add.
 <br />
-[[Instruction_Set/addsxv|addsxv]] - Alias for [[Instruction_Set/addsx|addsx]].<br />
+[[Instruction_Set/addsx2|addsx2]] - Alias for [[Instruction_Set/addsx|addsx]].<br />
 [[Instruction_Set/addu|addu]] - Alias for [[Instruction_Set/add|add]].<br />
+[[Instruction_Set/addu2|addu2]] - Alias for [[Instruction_Set/add|add]].<br />
 [[Instruction_Set/addus|addus]] - Saturating unsigned integer addition.
 <br />
-[[Instruction_Set/addusv|addusv]] - Alias for [[Instruction_Set/addus|addus]].<br />
+[[Instruction_Set/addus2|addus2]] - Alias for [[Instruction_Set/addus|addus]].<br />
-[[Instruction_Set/adduv|adduv]] - Alias for [[Instruction_Set/add|add]].<br />
 [[Instruction_Set/adduw|adduw]] - Widening unsigned integer addition.
 <br />
-[[Instruction_Set/adduwv|adduwv]] - Widening unsigned integer vector addition.
+[[Instruction_Set/adduw2|adduw2]] - <nowiki>principal op code: addition; arithmetic domain: unsigned integer; overflow policy:
-<br />
+            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; </nowiki><br />
 [[Instruction_Set/addux|addux]] - Excepting unsigned integer add.
 <br />
-[[Instruction_Set/adduxv|adduxv]] - Alias for [[Instruction_Set/addux|addux]].<br />
+[[Instruction_Set/addux2|addux2]] - Alias for [[Instruction_Set/addux|addux]].<br />
+[[Instruction_Set/advance|advance]] - <nowiki>principal op code: advance the scratchpad rotator; arithmetic domain: logical;
+            operation encoding group selector: exu-side readers; </nowiki><br />
 [[Instruction_Set/all|all]] - Returns true if the lowest bit in all vector elements is set.
 <br />
@@ Line 74: / Line 82: @@
 [[Instruction_Set/any|any]] - Returns true if the lowest bit in any of the vector elements is set.
 <br />
+[[Instruction_Set/argf|argf]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/argSize|argSize]] - <nowiki>principal op code: set size of memory argument block for following dynCall;
              operation encoding group selector: flow-side operations; possible manifest sizes in
@@ Line 79: / Line 90: @@
 <div style="font-size: 10pt; font-weight: bold;" id="b">b</div>
+[[Instruction_Set/back|back]] - <nowiki>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;
+            </nowiki><br />
+[[Instruction_Set/backfl|backfl]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/backtr|backtr]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/BID2d|BID2d]] - <nowiki>principal op code: decimal format conversion; arithmetic domain: decimal floating
              point; operation encoding group selector: exu-side operations; operation signature
@@ Line 86: / Line 112: @@
 [[Instruction_Set/brfl|brfl]] - Branch on false predicate.
 <br />
+[[Instruction_Set/brfls|brfls]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/brs|brs]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/brtr|brtr]] - Branch on true predicate.
 <br />
+[[Instruction_Set/brtrs|brtrs]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/bswap|bswap]] - <nowiki>principal op code: big<->little endian conversion; arithmetic domain: logical;
+            operation encoding group selector: exu-side operations; </nowiki><br />
 <div style="font-size: 10pt; font-weight: bold;" id="c">c</div>
-[[Instruction_Set/cachebcl|cachebcl]] - <nowiki>principal op code: cache control operation; memory sub-operation: Load entire code
+[[Instruction_Set/cachepbcl|cachepbcl]] - <nowiki>principal op code: cache control operation; arithmetic domain: pointer; memory
-            range to lowest on-chip cache; operation encoding group selector: flow-side operations;
+            sub-operation: Load entire code range to lowest on-chip cache; operation encoding group
-            </nowiki><br />
+            selector: flow-side operations; </nowiki><br />
-[[Instruction_Set/cachebdl|cachebdl]] - <nowiki>principal op code: cache control operation; memory sub-operation: Load entire data
+[[Instruction_Set/cachepbdl|cachepbdl]] - <nowiki>principal op code: cache control operation; arithmetic domain: pointer; memory
-            range to lowest on-chip cache; operation encoding group selector: flow-side operations;
+            sub-operation: Load entire data range to lowest on-chip cache; operation encoding group
-            </nowiki><br />
+            selector: flow-side operations; </nowiki><br />
-[[Instruction_Set/cached|cached]] - <nowiki>principal op code: cache control operation; memory sub-operation: duplicate cache
+[[Instruction_Set/cachepd|cachepd]] - <nowiki>principal op code: cache control operation; arithmetic domain: pointer; memory
-            line to new address; operation encoding group selector: flow-side operations; operation
+            sub-operation: duplicate cache line to new address; operation encoding group selector:
-            signature kind: belt operand from opsWindow, belt operand from opsWindo</nowiki><br />
+            flow-side operations; </nowiki><br />
-[[Instruction_Set/cachee|cachee]] - <nowiki>principal op code: cache control operation; memory sub-operation: evict cache line
+[[Instruction_Set/cachepe|cachepe]] - <nowiki>principal op code: cache control operation; arithmetic domain: pointer; memory
-            to memory; operation encoding group selector: flow-side operations; operation signature
+            sub-operation: evict cache line to memory; operation encoding group selector: flow-side
-            kind: belt operand from opsWindow, belt operand from opsWindo</nowiki><br />
+            operations; </nowiki><br />
-[[Instruction_Set/cachex|cachex]] - <nowiki>principal op code: cache control operation; memory sub-operation: discard cache line
+[[Instruction_Set/cachepx|cachepx]] - <nowiki>principal op code: cache control operation; arithmetic domain: pointer; memory
-            without flush; operation encoding group selector: flow-side operations; operation
+            sub-operation: discard cache line without flush; operation encoding group selector:
-            signature kind: belt operand from opsWindow, belt operand from opsWindo</nowiki><br />
+            flow-side operations; </nowiki><br />
-[[Instruction_Set/call|call]] - The general purpose unconditional abstract call operations you will be using when writing [[GenAsm (language)|general assembly code]].
+[[Instruction_Set/call0|call0]] - Call function with no return values.
+<br />
+[[Instruction_Set/call1|call1]] - Call function with one return value.
+<br />
+[[Instruction_Set/callfl0|callfl0]] - Call predicated function with no return values on false.
+<br />
+[[Instruction_Set/callfl1|callfl1]] - Call predicated function with one return value on false.
+<br />
+[[Instruction_Set/calln|calln]] - Call function with defined number of return values.
+<br />
+[[Instruction_Set/calltr0|calltr0]] - Call predicated function with no return values on true.
+<br />
+[[Instruction_Set/calltr1|calltr1]] - Call predicated function with one return value on true.
 <br />
-[[Instruction_Set/call0|call0]] - <nowiki>principal op code: function call; sense of condition: taken unconditionally; number
-            of results from a call: no result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/call1|call1]] - <nowiki>principal op code: function call; sense of condition: taken unconditionally; number
-            of results from a call: one result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/callfl|callfl]] - <nowiki>principal op code: function call; sense of condition: taken if false; number of
-            results from a call: any number of results; operation encoding group selector:
-            flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
-            constant bytes; </nowiki><br />
-[[Instruction_Set/callfl0|callfl0]] - <nowiki>principal op code: function call; sense of condition: taken if false; number of
-            results from a call: no result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/callfl1|callfl1]] - <nowiki>principal op code: function call; sense of condition: taken if false; number of
-            results from a call: one result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/callfln|callfln]] - <nowiki>principal op code: function call; sense of condition: taken if false; number of
-            results from a call: more than one result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/calln|calln]] - <nowiki>principal op code: function call; sense of condition: taken unconditionally; number
-            of results from a call: more than one result; operation encoding group selector:
-            flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
-            constant bytes; </nowiki><br />
-[[Instruction_Set/calltr|calltr]] - <nowiki>principal op code: function call; sense of condition: taken if true; number of
-            results from a call: any number of results; operation encoding group selector:
-            flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
-            constant bytes; </nowiki><br />
-[[Instruction_Set/calltr0|calltr0]] - <nowiki>principal op code: function call; sense of condition: taken if true; number of
-            results from a call: no result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/calltr1|calltr1]] - <nowiki>principal op code: function call; sense of condition: taken if true; number of
-            results from a call: one result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/calltrn|calltrn]] - <nowiki>principal op code: function call; sense of condition: taken if true; number of
-            results from a call: more than one result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
 [[Instruction_Set/carry|carry]] - Gets the carry/borrow flag or condition code of the ganged operation and puts it on the belt.
 <br />
+[[Instruction_Set/carryb|carryb]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/classifyd|classifyd]] - Produce an enum value to classify binary floating points into normal values, subnormals, infinities and NaNs etc.
 <br />
@@ Line 159: / Line 170: @@
 [[Instruction_Set/clear|clear]] - Clear a single indexed bit.
 <br />
-[[Instruction_Set/con|con]] - Drop an immediate constant on the belt.
+[[Instruction_Set/con|con]] - <nowiki>principal op code: immediate constant; operation encoding group selector: flow-side
-<br />
+            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-[[Instruction_Set/conform|conform]] - Reorder belt.
+            </nowiki><br />
-<br />
 [[Instruction_Set/countlfl|countlfl]] - Count the zero bits from the left.
 <br />
@@ Line 220: / Line 230: @@
 [[Instruction_Set/eql|eql]] - Integer equality comparison.
 <br />
+[[Instruction_Set/eqlb|eqlb]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/eqld|eqld]] - Decimal float equality comparison.
 <br />
+[[Instruction_Set/eqldb|eqldb]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/eqldx|eqldx]] - Decimal float equality comparison. NaN-Aware.
 <br />
+[[Instruction_Set/eqldxb|eqldxb]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/eqlf|eqlf]] - Binary float equality comparison.
 <br />
+[[Instruction_Set/eqlfb|eqlfb]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/eqlfx|eqlfx]] - Binary float equality comparison. NaN-Aware.
 <br />
+[[Instruction_Set/eqlfxb|eqlfxb]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/eqlp|eqlp]] - Pointer equality.
 <br />
+[[Instruction_Set/eqlpb|eqlpb]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/eqls|eqls]] - Alias for [[Instruction_Set/eql|eql]].<br />
+[[Instruction_Set/eqlsb|eqlsb]] - Alias for [[Instruction_Set/eqlb|eqlb]].<br />
 [[Instruction_Set/eqlu|eqlu]] - Alias for [[Instruction_Set/eql|eql]].<br />
+[[Instruction_Set/eqlub|eqlub]] - Alias for [[Instruction_Set/eqlb|eqlb]].<br />
 [[Instruction_Set/exitAtomic|exitAtomic]] - <nowiki>principal op code: commit an in-progress atomic extent and return status; operation
              encoding group selector: flow-side operations; </nowiki><br />
@@ Line 237: / Line 271: @@
              group selector: flow-side operations; possible manifest sizes in bytes: zero, one, two,
              or four constant bytes; </nowiki><br />
-[[Instruction_Set/externalized|externalized]] - <nowiki>principal op code: convert a floating-point number from internal to memory format;
-            arithmetic domain: decimal floating point; operation encoding group selector: flow-side
-            operations; </nowiki><br />
-[[Instruction_Set/externalizef|externalizef]] - <nowiki>principal op code: convert a floating-point number from internal to memory format;
-            arithmetic domain: binary floating point; operation encoding group selector: flow-side
-            operations; </nowiki><br />
 [[Instruction_Set/extract|extract]] - Extract a vector element to a scalar value operand.
 <br />
@@ Line 272: / Line 300: @@
 <br />
 [[Instruction_Set/f2ffz|f2ffz]] - Convert binary floating point into decimal floating point, rounding towards zero.
-<br />
-[[Instruction_Set/f2sd|f2sd]] - Inexactly convert a decimal floating point value to a signed integer, in current rounding mode and normal modulo overflow.
 <br />
 [[Instruction_Set/f2sde|f2sde]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward even and normal modulo overflow.
 <br />
-[[Instruction_Set/f2sdfz|f2sdfz]] - Inexactly convert a decimal floating point value to a signed integer, rounding away from zero and normal modulo overflow.
+[[Instruction_Set/f2sdee|f2sdee]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-[[Instruction_Set/f2sdn|f2sdn]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward nearest and normal modulo overflow.
+            to nearest, ties toward even adjacent value; operation encoding group selector:
-<br />
+            exu-side operations; condition code generator: generate condition codes by comparing
-[[Instruction_Set/f2sdp|f2sdp]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward positive infinity and normal modulo overflow.
+            result with zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2sdefz|f2sdefz]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-[[Instruction_Set/f2sds|f2sds]] - Inexactly convert a decimal floating point value to a signed integer, in current rounding mode and producing saturating result values.
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-<br />
+            to nearest, ties away from zero; operation encoding group selector: exu-side
-[[Instruction_Set/f2sdse|f2sdse]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward even and producing saturating result values.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2sdsfz|f2sdsfz]] - Inexactly convert a decimal floating point value to a signed integer, rounding away from zero and producing saturating result values.
+[[Instruction_Set/f2sden|f2sden]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-[[Instruction_Set/f2sdsn|f2sdsn]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward nearest and producing saturating result values.
+            toward negative infinity; operation encoding group selector: exu-side operations;
-<br />
+            condition code generator: generate condition codes by comparing result with zero;
-[[Instruction_Set/f2sdsp|f2sdsp]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward positive infinity and producing saturating result values.
+            </nowiki><br />
-<br />
+[[Instruction_Set/f2sdep|f2sdep]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-[[Instruction_Set/f2sdsz|f2sdsz]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward zero and producing saturating result values.
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-<br />
+            toward positive infinity; operation encoding group selector: exu-side operations;
-[[Instruction_Set/f2sdx|f2sdx]] - Inexactly convert a decimal floating point value to a signed integer, in current rounding mode and producing [[NaR]]s on overflow.
+            condition code generator: generate condition codes by comparing result with zero;
-<br />
+            </nowiki><br />
-[[Instruction_Set/f2sdxe|f2sdxe]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward even and producing [[NaR]]s on overflow.
+[[Instruction_Set/f2sdes|f2sdes]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-[[Instruction_Set/f2sdxfz|f2sdxfz]] - Inexactly convert a decimal floating point value to a signed integer, rounding away from zero and producing [[NaR]]s on overflow.
+            policy: use current dynamic rounding mode; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2sdxn|f2sdxn]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward nearest and producing [[NaR]]s on overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2sdese|f2sdese]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-[[Instruction_Set/f2sdxp|f2sdxp]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward positive infinity and producing [[NaR]]s on overflow.
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-<br />
+            policy: to nearest, ties toward even adjacent value; operation encoding group selector:
-[[Instruction_Set/f2sdxz|f2sdxz]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward zero and producing [[NaR]]s on overflow.
+            exu-side operations; condition code generator: generate condition codes by comparing
-<br />
+            result with zero; </nowiki><br />
-[[Instruction_Set/f2sdz|f2sdz]] - Inexactly convert a decimal floating point value to a signed integer, rounding toward zero and normal modulo overflow.
+[[Instruction_Set/f2sdesfz|f2sdesfz]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-[[Instruction_Set/f2sed|f2sed]] - Exactly convert a decimal floating point value to a signed integer, in current rounding mode and normal modulo overflow.
+            policy: to nearest, ties away from zero; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2sede|f2sede]] - Exactly convert a decimal floating point value to a signed integer, rounding toward even and normal modulo overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2sdesn|f2sdesn]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-[[Instruction_Set/f2sedfz|f2sedfz]] - Exactly convert a decimal floating point value to a signed integer, rounding away from zero and normal modulo overflow.
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-<br />
+            policy: toward negative infinity; operation encoding group selector: exu-side
-[[Instruction_Set/f2sedn|f2sedn]] - Exactly convert a decimal floating point value to a signed integer, rounding toward nearest and normal modulo overflow.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2sedp|f2sedp]] - Exactly convert a decimal floating point value to a signed integer, rounding toward positive infinity and normal modulo overflow.
+[[Instruction_Set/f2sdesp|f2sdesp]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-[[Instruction_Set/f2seds|f2seds]] - Exactly convert a decimal floating point value to a signed integer, in current rounding mode and producing saturating result values.
+            policy: toward positive infinity; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2sedse|f2sedse]] - Exactly convert a decimal floating point value to a signed integer, rounding toward even and producing saturating result values.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2sdesz|f2sdesz]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-[[Instruction_Set/f2sedsfz|f2sedsfz]] - Exactly convert a decimal floating point value to a signed integer, rounding away from zero and producing saturating result values.
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-<br />
+            policy: toward zero; operation encoding group selector: exu-side operations; condition
-[[Instruction_Set/f2sedsn|f2sedsn]] - Exactly convert a decimal floating point value to a signed integer, rounding toward nearest and producing saturating result values.
+            code generator: generate condition codes by comparing result with zero; operation
-<br />
+            signature kind: belt operand from ops windo</nowiki><br />
-[[Instruction_Set/f2sedsp|f2sedsp]] - Exactly convert a decimal floating point value to a signed integer, rounding toward positive infinity and producing saturating result values.
+[[Instruction_Set/f2sdex|f2sdex]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-[[Instruction_Set/f2sedsz|f2sedsz]] - Exactly convert a decimal floating point value to a signed integer, rounding toward zero and producing saturating result values.
+            policy: use current dynamic rounding mode; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2sedx|f2sedx]] - Exactly convert a decimal floating point value to a signed integer, in current rounding mode and producing [[NaR]]s on overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2sdexe|f2sdexe]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-[[Instruction_Set/f2sedxe|f2sedxe]] - Exactly convert a decimal floating point value to a signed integer, rounding toward even and producing [[NaR]]s on overflow.
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-<br />
+            policy: to nearest, ties toward even adjacent value; operation encoding group selector:
-[[Instruction_Set/f2sedxfz|f2sedxfz]] - Exactly convert a decimal floating point value to a signed integer, rounding away from zero and producing [[NaR]]s on overflow.
+            exu-side operations; condition code generator: generate condition codes by comparing
-<br />
+            result with zero; </nowiki><br />
-[[Instruction_Set/f2sedxn|f2sedxn]] - Exactly convert a decimal floating point value to a signed integer, rounding toward nearest and producing [[NaR]]s on overflow.
+[[Instruction_Set/f2sdexfz|f2sdexfz]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-[[Instruction_Set/f2sedxp|f2sedxp]] - Exactly convert a decimal floating point value to a signed integer, rounding toward positive infinity and producing [[NaR]]s on overflow.
+            policy: to nearest, ties away from zero; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2sedxz|f2sedxz]] - Exactly convert a decimal floating point value to a signed integer, rounding toward zero and producing [[NaR]]s on overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2sdexn|f2sdexn]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-[[Instruction_Set/f2sedz|f2sedz]] - Exactly convert a decimal floating point value to a signed integer, rounding toward zero and normal modulo overflow.
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-<br />
+            policy: toward negative infinity; operation encoding group selector: exu-side
-[[Instruction_Set/f2sef|f2sef]] - Exactly convert a binary floating point value to a signed integer, in current rounding mode and normal modulo overflow.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2sefe|f2sefe]] - Exactly convert a binary floating point value to a signed integer, rounding toward even and normal modulo overflow.
+[[Instruction_Set/f2sdexp|f2sdexp]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-[[Instruction_Set/f2seffz|f2seffz]] - Exactly convert a binary floating point value to a signed integer, rounding away from zero and normal modulo overflow.
+            policy: toward positive infinity; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2sefn|f2sefn]] - Exactly convert a binary floating point value to a signed integer, rounding toward nearest and normal modulo overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2sdexz|f2sdexz]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-[[Instruction_Set/f2sefp|f2sefp]] - Exactly convert a binary floating point value to a signed integer, rounding toward positive infinity and normal modulo overflow.
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-<br />
+            policy: toward zero; operation encoding group selector: exu-side operations; condition
-[[Instruction_Set/f2sefs|f2sefs]] - Exactly convert a binary floating point value to a signed integer, in current rounding mode and producing saturating result values.
+            code generator: generate condition codes by comparing result with zero; operation
-<br />
+            signature kind: belt operand from ops windo</nowiki><br />
-[[Instruction_Set/f2sefse|f2sefse]] - Exactly convert a binary floating point value to a signed integer, rounding toward even and producing saturating result values.
+[[Instruction_Set/f2sdez|f2sdez]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-[[Instruction_Set/f2sefsfz|f2sefsfz]] - Exactly convert a binary floating point value to a signed integer, rounding away from zero and producing saturating result values.
+            toward zero; operation encoding group selector: exu-side operations; condition code
-<br />
+            generator: generate condition codes by comparing result with zero; operation signature
-[[Instruction_Set/f2sefsn|f2sefsn]] - Exactly convert a binary floating point value to a signed integer, rounding toward nearest and producing saturating result values.
+            kind: belt operand from ops windo</nowiki><br />
-<br />
+[[Instruction_Set/f2sdi|f2sdi]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-[[Instruction_Set/f2sefsp|f2sefsp]] - Exactly convert a binary floating point value to a signed integer, rounding toward positive infinity and producing saturating result values.
+            floating point; exact result required: inexact; overflow policy: modulo; rounding
-<br />
+            policy: use current dynamic rounding mode; operation encoding group selector: exu-side
-[[Instruction_Set/f2sefsz|f2sefsz]] - Exactly convert a binary floating point value to a signed integer, rounding toward zero and producing saturating result values.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2sefx|f2sefx]] - Exactly convert a binary floating point value to a signed integer, in current rounding mode and producing [[NaR]]s on overflow.
+[[Instruction_Set/f2sdie|f2sdie]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: inexact; overflow policy: modulo; rounding
-[[Instruction_Set/f2sefxe|f2sefxe]] - Exactly convert a binary floating point value to a signed integer, rounding toward even and producing [[NaR]]s on overflow.
+            policy: to nearest, ties toward even adjacent value; operation encoding group selector:
-<br />
+            exu-side operations; condition code generator: generate condition codes by comparing
-[[Instruction_Set/f2sefxfz|f2sefxfz]] - Exactly convert a binary floating point value to a signed integer, rounding away from zero and producing [[NaR]]s on overflow.
+            result with zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2sdifz|f2sdifz]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-[[Instruction_Set/f2sefxn|f2sefxn]] - Exactly convert a binary floating point value to a signed integer, rounding toward nearest and producing [[NaR]]s on overflow.
+            floating point; exact result required: inexact; overflow policy: modulo; rounding
-<br />
+            policy: to nearest, ties away from zero; operation encoding group selector: exu-side
-[[Instruction_Set/f2sefxp|f2sefxp]] - Exactly convert a binary floating point value to a signed integer, rounding toward positive infinity and producing [[NaR]]s on overflow.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2sefxz|f2sefxz]] - Exactly convert a binary floating point value to a signed integer, rounding toward zero and producing [[NaR]]s on overflow.
+[[Instruction_Set/f2sdin|f2sdin]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: inexact; overflow policy: modulo; rounding
-[[Instruction_Set/f2sefz|f2sefz]] - Exactly convert a binary floating point value to a signed integer, rounding toward zero and normal modulo overflow.
+            policy: toward negative infinity; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2sf|f2sf]] - Inexactly convert a binary floating point value to a signed integer, in current rounding mode and normal modulo overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2sdip|f2sdip]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sdis|f2sdis]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sdise|f2sdise]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sdisfz|f2sdisfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sdisn|f2sdisn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sdisp|f2sdisp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sdisz|f2sdisz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2sdix|f2sdix]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sdixe|f2sdixe]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sdixfz|f2sdixfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sdixn|f2sdixn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sdixp|f2sdixp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sdixz|f2sdixz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2sdiz|f2sdiz]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/f2sfe|f2sfe]] - Inexactly convert a binary floating point value to a signed integer, rounding toward even and normal modulo overflow.
 <br />
-[[Instruction_Set/f2sffz|f2sffz]] - Inexactly convert a binary floating point value to a signed integer, rounding away from zero and normal modulo overflow.
+[[Instruction_Set/f2sfee|f2sfee]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: binary
-<br />
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-[[Instruction_Set/f2sfn|f2sfn]] - Inexactly convert a binary floating point value to a signed integer, rounding toward nearest and normal modulo overflow.
+            to nearest, ties toward even adjacent value; operation encoding group selector:
-<br />
+            exu-side operations; condition code generator: generate condition codes by comparing
-[[Instruction_Set/f2sfp|f2sfp]] - Inexactly convert a binary floating point value to a signed integer, rounding toward positive infinity and normal modulo overflow.
+            result with zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2sfefz|f2sfefz]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: binary
-[[Instruction_Set/f2sfs|f2sfs]] - Inexactly convert a binary floating point value to a signed integer, in current rounding mode and producing saturating result values.
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-<br />
+            to nearest, ties away from zero; operation encoding group selector: exu-side
-[[Instruction_Set/f2sfse|f2sfse]] - Inexactly convert a binary floating point value to a signed integer, rounding toward even and producing saturating result values.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2sfsfz|f2sfsfz]] - Inexactly convert a binary floating point value to a signed integer, rounding away from zero and producing saturating result values.
+[[Instruction_Set/f2sfen|f2sfen]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: binary
-<br />
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-[[Instruction_Set/f2sfsn|f2sfsn]] - Inexactly convert a binary floating point value to a signed integer, rounding toward nearest and producing saturating result values.
+            toward negative infinity; operation encoding group selector: exu-side operations;
-<br />
+            condition code generator: generate condition codes by comparing result with zero;
-[[Instruction_Set/f2sfsp|f2sfsp]] - Inexactly convert a binary floating point value to a signed integer, rounding toward positive infinity and producing saturating result values.
+            </nowiki><br />
-<br />
+[[Instruction_Set/f2sfep|f2sfep]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: binary
-[[Instruction_Set/f2sfsz|f2sfsz]] - Inexactly convert a binary floating point value to a signed integer, rounding toward zero and producing saturating result values.
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-<br />
+            toward positive infinity; operation encoding group selector: exu-side operations;
-[[Instruction_Set/f2sfx|f2sfx]] - Inexactly convert a binary floating point value to a signed integer, in current rounding mode and producing [[NaR]]s on overflow.
+            condition code generator: generate condition codes by comparing result with zero;
-<br />
+            </nowiki><br />
-[[Instruction_Set/f2sfxe|f2sfxe]] - Inexactly convert a binary floating point value to a signed integer, rounding toward even and producing [[NaR]]s on overflow.
+[[Instruction_Set/f2sfes|f2sfes]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: binary
-<br />
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-[[Instruction_Set/f2sfxfz|f2sfxfz]] - Inexactly convert a binary floating point value to a signed integer, rounding away from zero and producing [[NaR]]s on overflow.
+            policy: use current dynamic rounding mode; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2sfxn|f2sfxn]] - Inexactly convert a binary floating point value to a signed integer, rounding toward nearest and producing [[NaR]]s on overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2sfese|f2sfese]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: binary
-[[Instruction_Set/f2sfxp|f2sfxp]] - Inexactly convert a binary floating point value to a signed integer, rounding toward positive infinity and producing [[NaR]]s on overflow.
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-<br />
+            policy: to nearest, ties toward even adjacent value; operation encoding group selector:
-[[Instruction_Set/f2sfxz|f2sfxz]] - Inexactly convert a binary floating point value to a signed integer, rounding toward zero and producing [[NaR]]s on overflow.
+            exu-side operations; condition code generator: generate condition codes by comparing
-<br />
+            result with zero; </nowiki><br />
-[[Instruction_Set/f2sfz|f2sfz]] - Inexactly convert a binary floating point value to a signed integer, rounding toward zero and normal modulo overflow.
+[[Instruction_Set/f2sfesfz|f2sfesfz]] - <nowiki>principal op code: convert float to signed integer; arithmetic domain: binary
-<br />
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-[[Instruction_Set/f2ud|f2ud]] - Inexactly convert a decimal floating point value to a unsigned integer, in current rounding mode and normal modulo overflow.
+            policy: to nearest, ties away from zero; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
+            zero; </nowiki><br />
+[[Instruction_Set/f2sfesn|f2sfesn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfesp|f2sfesp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfesz|f2sfesz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2sfex|f2sfex]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfexe|f2sfexe]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfexfz|f2sfexfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfexn|f2sfexn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfexp|f2sfexp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfexz|f2sfexz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2sfez|f2sfez]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2sfi|f2sfi]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfie|f2sfie]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfifz|f2sfifz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfin|f2sfin]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfip|f2sfip]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfis|f2sfis]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfise|f2sfise]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfisfz|f2sfisfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfisn|f2sfisn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfisp|f2sfisp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfisz|f2sfisz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2sfix|f2sfix]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfixe|f2sfixe]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfixfz|f2sfixfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfixn|f2sfixn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfixp|f2sfixp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2sfixz|f2sfixz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2sfiz|f2sfiz]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/f2ude|f2ude]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward even and normal modulo overflow.
 <br />
-[[Instruction_Set/f2udfz|f2udfz]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding away from zero and normal modulo overflow.
+[[Instruction_Set/f2udee|f2udee]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-[[Instruction_Set/f2udn|f2udn]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward nearest and normal modulo overflow.
+            to nearest, ties toward even adjacent value; operation encoding group selector:
-<br />
+            exu-side operations; condition code generator: generate condition codes by comparing
-[[Instruction_Set/f2udp|f2udp]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward positive infinity and normal modulo overflow.
+            result with zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2udefz|f2udefz]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-[[Instruction_Set/f2uds|f2uds]] - Inexactly convert a decimal floating point value to a unsigned integer, in current rounding mode and producing saturating result values.
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-<br />
+            to nearest, ties away from zero; operation encoding group selector: exu-side
-[[Instruction_Set/f2udse|f2udse]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward even and producing saturating result values.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2udsfz|f2udsfz]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding away from zero and producing saturating result values.
+[[Instruction_Set/f2uden|f2uden]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-[[Instruction_Set/f2udsn|f2udsn]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward nearest and producing saturating result values.
+            toward negative infinity; operation encoding group selector: exu-side operations;
-<br />
+            condition code generator: generate condition codes by comparing result with zero;
-[[Instruction_Set/f2udsp|f2udsp]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward positive infinity and producing saturating result values.
+            </nowiki><br />
-<br />
+[[Instruction_Set/f2udep|f2udep]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-[[Instruction_Set/f2udsz|f2udsz]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward zero and producing saturating result values.
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-<br />
+            toward positive infinity; operation encoding group selector: exu-side operations;
-[[Instruction_Set/f2udx|f2udx]] - Inexactly convert a decimal floating point value to a unsigned integer, in current rounding mode and producing [[NaR]]s on overflow.
+            condition code generator: generate condition codes by comparing result with zero;
-<br />
+            </nowiki><br />
-[[Instruction_Set/f2udxe|f2udxe]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward even and producing [[NaR]]s on overflow.
+[[Instruction_Set/f2udes|f2udes]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-[[Instruction_Set/f2udxfz|f2udxfz]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding away from zero and producing [[NaR]]s on overflow.
+            policy: use current dynamic rounding mode; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2udxn|f2udxn]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward nearest and producing [[NaR]]s on overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2udese|f2udese]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-[[Instruction_Set/f2udxp|f2udxp]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward positive infinity and producing [[NaR]]s on overflow.
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-<br />
+            policy: to nearest, ties toward even adjacent value; operation encoding group selector:
-[[Instruction_Set/f2udxz|f2udxz]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward zero and producing [[NaR]]s on overflow.
+            exu-side operations; condition code generator: generate condition codes by comparing
-<br />
+            result with zero; </nowiki><br />
-[[Instruction_Set/f2udz|f2udz]] - Inexactly convert a decimal floating point value to a unsigned integer, rounding toward zero and normal modulo overflow.
+[[Instruction_Set/f2udesfz|f2udesfz]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-[[Instruction_Set/f2ued|f2ued]] - Exactly convert a decimal floating point value to a unsigned integer, in current rounding mode and normal modulo overflow.
+            policy: to nearest, ties away from zero; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2uede|f2uede]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward even and normal modulo overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2udesn|f2udesn]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-[[Instruction_Set/f2uedfz|f2uedfz]] - Exactly convert a decimal floating point value to a unsigned integer, rounding away from zero and normal modulo overflow.
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-<br />
+            policy: toward negative infinity; operation encoding group selector: exu-side
-[[Instruction_Set/f2uedn|f2uedn]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward nearest and normal modulo overflow.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2uedp|f2uedp]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward positive infinity and normal modulo overflow.
+[[Instruction_Set/f2udesp|f2udesp]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-[[Instruction_Set/f2ueds|f2ueds]] - Exactly convert a decimal floating point value to a unsigned integer, in current rounding mode and producing saturating result values.
+            policy: toward positive infinity; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2uedse|f2uedse]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward even and producing saturating result values.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2udesz|f2udesz]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-[[Instruction_Set/f2uedsfz|f2uedsfz]] - Exactly convert a decimal floating point value to a unsigned integer, rounding away from zero and producing saturating result values.
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-<br />
+            policy: toward zero; operation encoding group selector: exu-side operations; condition
-[[Instruction_Set/f2uedsn|f2uedsn]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward nearest and producing saturating result values.
+            code generator: generate condition codes by comparing result with zero; operation
-<br />
+            signature kind: belt operand from ops windo</nowiki><br />
-[[Instruction_Set/f2uedsp|f2uedsp]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward positive infinity and producing saturating result values.
+[[Instruction_Set/f2udex|f2udex]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-[[Instruction_Set/f2uedsz|f2uedsz]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward zero and producing saturating result values.
+            policy: use current dynamic rounding mode; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2uedx|f2uedx]] - Exactly convert a decimal floating point value to a unsigned integer, in current rounding mode and producing [[NaR]]s on overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2udexe|f2udexe]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-[[Instruction_Set/f2uedxe|f2uedxe]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward even and producing [[NaR]]s on overflow.
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-<br />
+            policy: to nearest, ties toward even adjacent value; operation encoding group selector:
-[[Instruction_Set/f2uedxfz|f2uedxfz]] - Exactly convert a decimal floating point value to a unsigned integer, rounding away from zero and producing [[NaR]]s on overflow.
+            exu-side operations; condition code generator: generate condition codes by comparing
-<br />
+            result with zero; </nowiki><br />
-[[Instruction_Set/f2uedxn|f2uedxn]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward nearest and producing [[NaR]]s on overflow.
+[[Instruction_Set/f2udexfz|f2udexfz]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-[[Instruction_Set/f2uedxp|f2uedxp]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward positive infinity and producing [[NaR]]s on overflow.
+            policy: to nearest, ties away from zero; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2uedxz|f2uedxz]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward zero and producing [[NaR]]s on overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2udexn|f2udexn]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-[[Instruction_Set/f2uedz|f2uedz]] - Exactly convert a decimal floating point value to a unsigned integer, rounding toward zero and normal modulo overflow.
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-<br />
+            policy: toward negative infinity; operation encoding group selector: exu-side
-[[Instruction_Set/f2uef|f2uef]] - Exactly convert a binary floating point value to a unsigned integer, in current rounding mode and normal modulo overflow.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2uefe|f2uefe]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward even and normal modulo overflow.
+[[Instruction_Set/f2udexp|f2udexp]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-[[Instruction_Set/f2ueffz|f2ueffz]] - Exactly convert a binary floating point value to a unsigned integer, rounding away from zero and normal modulo overflow.
+            policy: toward positive infinity; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2uefn|f2uefn]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward nearest and normal modulo overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2udexz|f2udexz]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-[[Instruction_Set/f2uefp|f2uefp]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward positive infinity and normal modulo overflow.
+            floating point; exact result required: exact; overflow policy: excepting; rounding
-<br />
+            policy: toward zero; operation encoding group selector: exu-side operations; condition
-[[Instruction_Set/f2uefs|f2uefs]] - Exactly convert a binary floating point value to a unsigned integer, in current rounding mode and producing saturating result values.
+            code generator: generate condition codes by comparing result with zero; operation
-<br />
+            signature kind: belt operand from ops windo</nowiki><br />
-[[Instruction_Set/f2uefse|f2uefse]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward even and producing saturating result values.
+[[Instruction_Set/f2udez|f2udez]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-[[Instruction_Set/f2uefsfz|f2uefsfz]] - Exactly convert a binary floating point value to a unsigned integer, rounding away from zero and producing saturating result values.
+            toward zero; operation encoding group selector: exu-side operations; condition code
-<br />
+            generator: generate condition codes by comparing result with zero; operation signature
-[[Instruction_Set/f2uefsn|f2uefsn]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward nearest and producing saturating result values.
+            kind: belt operand from ops windo</nowiki><br />
-<br />
+[[Instruction_Set/f2udi|f2udi]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-[[Instruction_Set/f2uefsp|f2uefsp]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward positive infinity and producing saturating result values.
+            floating point; exact result required: inexact; overflow policy: modulo; rounding
-<br />
+            policy: use current dynamic rounding mode; operation encoding group selector: exu-side
-[[Instruction_Set/f2uefsz|f2uefsz]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward zero and producing saturating result values.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2uefx|f2uefx]] - Exactly convert a binary floating point value to a unsigned integer, in current rounding mode and producing [[NaR]]s on overflow.
+[[Instruction_Set/f2udie|f2udie]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: inexact; overflow policy: modulo; rounding
-[[Instruction_Set/f2uefxe|f2uefxe]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward even and producing [[NaR]]s on overflow.
+            policy: to nearest, ties toward even adjacent value; operation encoding group selector:
-<br />
+            exu-side operations; condition code generator: generate condition codes by comparing
-[[Instruction_Set/f2uefxfz|f2uefxfz]] - Exactly convert a binary floating point value to a unsigned integer, rounding away from zero and producing [[NaR]]s on overflow.
+            result with zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2udifz|f2udifz]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-[[Instruction_Set/f2uefxn|f2uefxn]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward nearest and producing [[NaR]]s on overflow.
+            floating point; exact result required: inexact; overflow policy: modulo; rounding
-<br />
+            policy: to nearest, ties away from zero; operation encoding group selector: exu-side
-[[Instruction_Set/f2uefxp|f2uefxp]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward positive infinity and producing [[NaR]]s on overflow.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2uefxz|f2uefxz]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward zero and producing [[NaR]]s on overflow.
+[[Instruction_Set/f2udin|f2udin]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: decimal
-<br />
+            floating point; exact result required: inexact; overflow policy: modulo; rounding
-[[Instruction_Set/f2uefz|f2uefz]] - Exactly convert a binary floating point value to a unsigned integer, rounding toward zero and normal modulo overflow.
+            policy: toward negative infinity; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2uf|f2uf]] - Inexactly convert a binary floating point value to a unsigned integer, in current rounding mode and normal modulo overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2udip|f2udip]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2udis|f2udis]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2udise|f2udise]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2udisfz|f2udisfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2udisn|f2udisn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2udisp|f2udisp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2udisz|f2udisz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2udix|f2udix]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2udixe|f2udixe]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2udixfz|f2udixfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2udixn|f2udixn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2udixp|f2udixp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2udixz|f2udixz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2udiz|f2udiz]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/f2ufe|f2ufe]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward even and normal modulo overflow.
 <br />
-[[Instruction_Set/f2uffz|f2uffz]] - Inexactly convert a binary floating point value to a unsigned integer, rounding away from zero and normal modulo overflow.
+[[Instruction_Set/f2ufee|f2ufee]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: binary
-<br />
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-[[Instruction_Set/f2ufn|f2ufn]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward nearest and normal modulo overflow.
+            to nearest, ties toward even adjacent value; operation encoding group selector:
-<br />
+            exu-side operations; condition code generator: generate condition codes by comparing
-[[Instruction_Set/f2ufp|f2ufp]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward positive infinity and normal modulo overflow.
+            result with zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2ufefz|f2ufefz]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: binary
-[[Instruction_Set/f2ufs|f2ufs]] - Inexactly convert a binary floating point value to a unsigned integer, in current rounding mode and producing saturating result values.
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-<br />
+            to nearest, ties away from zero; operation encoding group selector: exu-side
-[[Instruction_Set/f2ufse|f2ufse]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward even and producing saturating result values.
+            operations; condition code generator: generate condition codes by comparing result with
-<br />
+            zero; </nowiki><br />
-[[Instruction_Set/f2ufsfz|f2ufsfz]] - Inexactly convert a binary floating point value to a unsigned integer, rounding away from zero and producing saturating result values.
+[[Instruction_Set/f2ufen|f2ufen]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: binary
-<br />
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-[[Instruction_Set/f2ufsn|f2ufsn]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward nearest and producing saturating result values.
+            toward negative infinity; operation encoding group selector: exu-side operations;
-<br />
+            condition code generator: generate condition codes by comparing result with zero;
-[[Instruction_Set/f2ufsp|f2ufsp]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward positive infinity and producing saturating result values.
+            </nowiki><br />
-<br />
+[[Instruction_Set/f2ufep|f2ufep]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: binary
-[[Instruction_Set/f2ufsz|f2ufsz]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward zero and producing saturating result values.
+            floating point; exact result required: exact; overflow policy: modulo; rounding policy:
-<br />
+            toward positive infinity; operation encoding group selector: exu-side operations;
-[[Instruction_Set/f2ufx|f2ufx]] - Inexactly convert a binary floating point value to a unsigned integer, in current rounding mode and producing [[NaR]]s on overflow.
+            condition code generator: generate condition codes by comparing result with zero;
-<br />
+            </nowiki><br />
-[[Instruction_Set/f2ufxe|f2ufxe]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward even and producing [[NaR]]s on overflow.
+[[Instruction_Set/f2ufes|f2ufes]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: binary
-<br />
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-[[Instruction_Set/f2ufxfz|f2ufxfz]] - Inexactly convert a binary floating point value to a unsigned integer, rounding away from zero and producing [[NaR]]s on overflow.
+            policy: use current dynamic rounding mode; operation encoding group selector: exu-side
-<br />
+            operations; condition code generator: generate condition codes by comparing result with
-[[Instruction_Set/f2ufxn|f2ufxn]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward nearest and producing [[NaR]]s on overflow.
+            zero; </nowiki><br />
-<br />
+[[Instruction_Set/f2ufese|f2ufese]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: binary
-[[Instruction_Set/f2ufxp|f2ufxp]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward positive infinity and producing [[NaR]]s on overflow.
+            floating point; exact result required: exact; overflow policy: saturating; rounding
-<br />
+            policy: to nearest, ties toward even adjacent value; operation encoding group selector:
-[[Instruction_Set/f2ufxz|f2ufxz]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward zero and producing [[NaR]]s on overflow.
+            exu-side operations; condition code generator: generate condition codes by comparing
-<br />
+            result with zero; </nowiki><br />
-[[Instruction_Set/f2ufz|f2ufz]] - Inexactly convert a binary floating point value to a unsigned integer, rounding toward zero and normal modulo overflow.
+[[Instruction_Set/f2ufesfz|f2ufesfz]] - <nowiki>principal op code: convert float to unsigned integer; arithmetic domain: binary
-<br />
+            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; </nowiki><br />
+[[Instruction_Set/f2ufesn|f2ufesn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufesp|f2ufesp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufesz|f2ufesz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2ufex|f2ufex]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufexe|f2ufexe]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufexfz|f2ufexfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufexn|f2ufexn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufexp|f2ufexp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufexz|f2ufexz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2ufez|f2ufez]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2ufi|f2ufi]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufie|f2ufie]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufifz|f2ufifz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufin|f2ufin]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufip|f2ufip]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufis|f2ufis]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufise|f2ufise]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufisfz|f2ufisfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufisn|f2ufisn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufisp|f2ufisp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufisz|f2ufisz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2ufix|f2ufix]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufixe|f2ufixe]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufixfz|f2ufixfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufixn|f2ufixn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufixp|f2ufixp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/f2ufixz|f2ufixz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/f2ufiz|f2ufiz]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/face|face]] - <nowiki>principal op code: fetch-ahead count extension; operation encoding group selector:
              flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
@@ Line 566: / Line 1,014: @@
 [[Instruction_Set/fault|fault]] - Raise an application [[Events#Faults|fault event]].
 <br />
-[[Instruction_Set/fill|fill]] - <nowiki>principal op code: retore spilled operand from extended scratchpad; operation
+[[Instruction_Set/faultfl|faultfl]] - <nowiki>principal op code: force an application fault; arithmetic domain: logical; sense of
+            condition: taken if false; operation encoding group selector: exu-side writers;
+            </nowiki><br />
+[[Instruction_Set/faulttr|faulttr]] - <nowiki>principal op code: force an application fault; arithmetic domain: logical; sense of
+            condition: taken if true; operation encoding group selector: exu-side writers;
+            </nowiki><br />
+[[Instruction_Set/fill|fill]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/flags|flags]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/flip|flip]] - Bit complement.
 <br />
 [[Instruction_Set/flips|flips]] - Alias for [[Instruction_Set/flip|flip]].<br />
 [[Instruction_Set/flipu|flipu]] - Alias for [[Instruction_Set/flip|flip]].<br />
+[[Instruction_Set/floatArgs|floatArgs]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/floatArgse|floatArgse]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/floatArgsfz|floatArgsfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/floatArgsn|floatArgsn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/floatArgsp|floatArgsp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/floatArgsz|floatArgsz]] - <nowiki>principal op code: mode control for ganged floating point operation; arithmetic
+            domain: logical; rounding policy: toward zero; operation encoding group selector:
+            exu-side operations; </nowiki><br />
 [[Instruction_Set/flowArgs|flowArgs]] - <nowiki>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 constan</nowiki><br />
+             kind: manifest constant, morsel-sized manifest constant, morsel-sized manifest
+            constant, morsel-sized manifest constan</nowiki><br />
+[[Instruction_Set/fma|fma]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/fmad|fmad]] - Decimal floating point fused multiply-add.
 <br />
@@ Line 601: / Line 1,080: @@
 [[Instruction_Set/fmafz|fmafz]] - Binary floating point fused multiply-add.
 <br />
+[[Instruction_Set/fmas|fmas]] - Alias for [[Instruction_Set/fma|fma]].<br />
+[[Instruction_Set/fmas2|fmas2]] - Alias for [[Instruction_Set/fmas|fmas]].<br />
+[[Instruction_Set/fmass|fmass]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/fmass2|fmass2]] - Alias for [[Instruction_Set/fmass|fmass]].<br />
+[[Instruction_Set/fmasw|fmasw]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/fmasw2|fmasw2]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/fmasx|fmasx]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/fmasx2|fmasx2]] - Alias for [[Instruction_Set/fmasx|fmasx]].<br />
+[[Instruction_Set/fmau|fmau]] - Alias for [[Instruction_Set/fma|fma]].<br />
+[[Instruction_Set/fmau2|fmau2]] - Alias for [[Instruction_Set/fmau|fmau]].<br />
+[[Instruction_Set/fmaus|fmaus]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/fmaus2|fmaus2]] - Alias for [[Instruction_Set/fmaus|fmaus]].<br />
+[[Instruction_Set/fmauw|fmauw]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/fmauw2|fmauw2]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/fmaux|fmaux]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/fmaux2|fmaux2]] - Alias for [[Instruction_Set/fmaux|fmaux]].<br />
 <div style="font-size: 10pt; font-weight: bold;" id="g">g</div>
-[[Instruction_Set/geq|geq]] - Integer greater than or equal comparison.
-<br />
 [[Instruction_Set/geqd|geqd]] - Decimal float greater than or equal comparison.
 <br />
+[[Instruction_Set/geqdb|geqdb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/geqdx|geqdx]] - Decimal float greater than or equal comparison. NaN-Aware.
 <br />
+[[Instruction_Set/geqdxb|geqdxb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/geqf|geqf]] - Binary float greater than or equal comparison.
 <br />
+[[Instruction_Set/geqfb|geqfb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/geqfx|geqfx]] - Binary float greater than or equal comparison. NaN-Aware.
 <br />
-[[Instruction_Set/geqp|geqp]] - Alias for [[Instruction_Set/leqp|leqp]].<br />
+[[Instruction_Set/geqfxb|geqfxb]] - <nowiki>principal op code: greater than or equal; arithmetic domain: binary floating point;
-[[Instruction_Set/geqs|geqs]] - Alias for [[Instruction_Set/gtrs|gtrs]].<br />
+            NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
-[[Instruction_Set/gequ|gequ]] - Alias for [[Instruction_Set/lequ|lequ]].<br />
+            "b" (bool) width; operation encoding group selector: exu-side operations;
-[[Instruction_Set/gtr|gtr]] - Integer greater than comparison.
+            </nowiki><br />
-<br />
+[[Instruction_Set/geqp|geqp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/geqpb|geqpb]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/geqs|geqs]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/geqsb|geqsb]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/gequ|gequ]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/gequb|gequb]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/globalize|globalize]] - <nowiki>principal op code: make pointer global; operation encoding group selector: flow-side
+            operations; </nowiki><br />
 [[Instruction_Set/gtrd|gtrd]] - Decimal float greater than comparison.
 <br />
+[[Instruction_Set/gtrdb|gtrdb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/gtrdx|gtrdx]] - Decimal float greater than comparison. NaN-Aware.
 <br />
+[[Instruction_Set/gtrdxb|gtrdxb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/gtrf|gtrf]] - Binary float greater than comparison.
 <br />
+[[Instruction_Set/gtrfb|gtrfb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/gtrfx|gtrfx]] - Binary float greater than comparison. NaN-Aware.
 <br />
-[[Instruction_Set/gtrp|gtrp]] - Alias for [[Instruction_Set/lssp|lssp]].<br />
+[[Instruction_Set/gtrfxb|gtrfxb]] - <nowiki>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;
+            </nowiki><br />
+[[Instruction_Set/gtrp|gtrp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/gtrpb|gtrpb]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/gtrs|gtrs]] - Signed integer greater than comparison.
 <br />
+[[Instruction_Set/gtrsb|gtrsb]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/gtru|gtru]] - Unsigned integer greater than comparison.
 <br />
+[[Instruction_Set/gtrub|gtrub]] - <nowiki>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; </nowiki><br />
 <div style="font-size: 10pt; font-weight: bold;" id="i">i</div>
@@ Line 637: / Line 1,212: @@
 [[Instruction_Set/imps|imps]] - Alias for [[Instruction_Set/imp|imp]].<br />
 [[Instruction_Set/impu|impu]] - Alias for [[Instruction_Set/imp|imp]].<br />
+[[Instruction_Set/incs2post|incs2post]] - Alias for [[Instruction_Set/incspost|incspost]].<br />
+[[Instruction_Set/incs2pre|incs2pre]] - Alias for [[Instruction_Set/incspre|incspre]].<br />
+[[Instruction_Set/incspost|incspost]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incspre|incspre]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incss2post|incss2post]] - Alias for [[Instruction_Set/incsspost|incsspost]].<br />
+[[Instruction_Set/incss2pre|incss2pre]] - Alias for [[Instruction_Set/incsspre|incsspre]].<br />
+[[Instruction_Set/incsspost|incsspost]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incsspre|incsspre]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incsw2post|incsw2post]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incsw2pre|incsw2pre]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incswpost|incswpost]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incswpre|incswpre]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incsx2post|incsx2post]] - Alias for [[Instruction_Set/incsxpost|incsxpost]].<br />
+[[Instruction_Set/incsx2pre|incsx2pre]] - Alias for [[Instruction_Set/incsxpre|incsxpre]].<br />
+[[Instruction_Set/incsxpost|incsxpost]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incsxpre|incsxpre]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incu2post|incu2post]] - Alias for [[Instruction_Set/incupost|incupost]].<br />
+[[Instruction_Set/incu2pre|incu2pre]] - Alias for [[Instruction_Set/incupre|incupre]].<br />
+[[Instruction_Set/incupost|incupost]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incupre|incupre]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incus2post|incus2post]] - Alias for [[Instruction_Set/incuspost|incuspost]].<br />
+[[Instruction_Set/incus2pre|incus2pre]] - Alias for [[Instruction_Set/incuspre|incuspre]].<br />
+[[Instruction_Set/incuspost|incuspost]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incuspre|incuspre]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incuw2post|incuw2post]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incuw2pre|incuw2pre]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incuwpost|incuwpost]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incuwpre|incuwpre]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incux2post|incux2post]] - Alias for [[Instruction_Set/incuxpost|incuxpost]].<br />
+[[Instruction_Set/incux2pre|incux2pre]] - Alias for [[Instruction_Set/incuxpre|incuxpre]].<br />
+[[Instruction_Set/incuxpost|incuxpost]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/incuxpre|incuxpre]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/inject|inject]] - Replace a vector element with a different scalar value.
 <br />
-[[Instruction_Set/inner|inner]] - <nowiki>principal op code: enter a loop; sense of condition: taken unconditionally; number
+[[Instruction_Set/inner|inner]] - Unconditional loop.
-            of results from a call: any number of results; operation encoding group selector:
-            flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
-            constant bytes; </nowiki><br />
-[[Instruction_Set/inner0|inner0]] - <nowiki>principal op code: enter a loop; sense of condition: taken unconditionally; number
-            of results from a call: no result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/inner1|inner1]] - <nowiki>principal op code: enter a loop; sense of condition: taken unconditionally; number
-            of results from a call: one result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/innerfl|innerfl]] - <nowiki>principal op code: enter a loop; sense of condition: taken if false; number of
-            results from a call: any number of results; operation encoding group selector:
-            flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
-            constant bytes; </nowiki><br />
-[[Instruction_Set/innerfl0|innerfl0]] - <nowiki>principal op code: enter a loop; sense of condition: taken if false; number of
-            results from a call: no result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/innerfl1|innerfl1]] - <nowiki>principal op code: enter a loop; sense of condition: taken if false; number of
-            results from a call: one result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/innerfln|innerfln]] - <nowiki>principal op code: enter a loop; sense of condition: taken if false; number of
-            results from a call: more than one result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/innern|innern]] - <nowiki>principal op code: enter a loop; sense of condition: taken unconditionally; number
-            of results from a call: more than one result; operation encoding group selector:
-            flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
-            constant bytes; </nowiki><br />
-[[Instruction_Set/innertr|innertr]] - <nowiki>principal op code: enter a loop; sense of condition: taken if true; number of
-            results from a call: any number of results; operation encoding group selector:
-            flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
-            constant bytes; </nowiki><br />
-[[Instruction_Set/innertr0|innertr0]] - <nowiki>principal op code: enter a loop; sense of condition: taken if true; number of
-            results from a call: no result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/innertr1|innertr1]] - <nowiki>principal op code: enter a loop; sense of condition: taken if true; number of
-            results from a call: one result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/innertrn|innertrn]] - <nowiki>principal op code: enter a loop; sense of condition: taken if true; number of
-            results from a call: more than one result; operation encoding group selector: flow-side
-            operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
-            </nowiki><br />
-[[Instruction_Set/integerd|integerd]] - Inexactly round a decimal float to an integer valued float. Uses current dynamic rounding mode.
 <br />
-[[Instruction_Set/integerde|integerde]] - Inexactly round a decimal float to an integer valued float. Rounds towards nearest even.
+[[Instruction_Set/innerfl|innerfl]] - Predicated loop on false condition.
 <br />
-[[Instruction_Set/integerdfz|integerdfz]] - Inexactly round a decimal float to an integer valued float. Rounds towards nearest away from zero.
+[[Instruction_Set/innerfls|innerfls]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/inners|inners]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/innertr|innertr]] - Predicated loop on true condition.
 <br />
-[[Instruction_Set/integerdn|integerdn]] - Inexactly round a decimal float to an integer valued float. Rounds towards negative infinity.
+[[Instruction_Set/innertrs|innertrs]] - <nowiki>principal op code: enter a loop; sense of condition: taken if true; suppress or
-<br />
+            permit in-flights across branches: discard in flight operations when taking branch;
-[[Instruction_Set/integerdp|integerdp]] - Inexactly round a decimal float to an integer valued float. Rounds towards positive infinity.
+            operation encoding group selector: flow-side operations; possible manifest sizes in
-<br />
+            bytes: zero, one, two, or four constant bytes; </nowiki><br />
-[[Instruction_Set/integerdz|integerdz]] - Inexactly round a decimal float to an integer valued float. Rounds towards zero.
+[[Instruction_Set/integerde|integerde]] - Inexactly round a decimal float to an integer valued float. Rounds towards nearest even.
-<br />
-[[Instruction_Set/integered|integered]] - Exactly round a decimal float to an integer valued float. Uses current dynamic rounding mode.
-<br />
-[[Instruction_Set/integerede|integerede]] - Exactly round a decimal float to an integer valued float. Rounds towards nearest even.
-<br />
-[[Instruction_Set/integeredfz|integeredfz]] - Exactly round a decimal float to an integer valued float. Rounds towards nearest away from zero.
-<br />
-[[Instruction_Set/integeredn|integeredn]] - Exactly round a decimal float to an integer valued float. Rounds towards negative infinity.
-<br />
-[[Instruction_Set/integeredp|integeredp]] - Exactly round a decimal float to an integer valued float. Rounds towards positive infinity.
-<br />
-[[Instruction_Set/integeredz|integeredz]] - Exactly round a decimal float to an integer valued float. Rounds towards zero.
-<br />
-[[Instruction_Set/integeref|integeref]] - Exactly round a binary float to an integer valued float. Uses current dynamic rounding mode.
-<br />
-[[Instruction_Set/integerefe|integerefe]] - Exactly round a binary float to an integer valued float. Rounds towards nearest even.
-<br />
-[[Instruction_Set/integereffz|integereffz]] - Exactly round a binary float to an integer valued float. Rounds towards nearest away from zero.
-<br />
-[[Instruction_Set/integerefn|integerefn]] - Exactly round a binary float to an integer valued float. Rounds towards negative infinity.
-<br />
-[[Instruction_Set/integerefp|integerefp]] - Exactly round a binary float to an integer valued float. Rounds towards positive infinity.
-<br />
-[[Instruction_Set/integerefz|integerefz]] - Exactly round a binary float to an integer valued float. Rounds towards zero.
-<br />
-[[Instruction_Set/integerf|integerf]] - Inexactly round a binary float to an integer valued float. Uses current dynamic rounding mode.
 <br />
+[[Instruction_Set/integerdee|integerdee]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerdefz|integerdefz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerden|integerden]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerdep|integerdep]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerdez|integerdez]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/integerdi|integerdi]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerdie|integerdie]] - <nowiki>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;
+            </nowiki><br />
+[[Instruction_Set/integerdifz|integerdifz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerdin|integerdin]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerdip|integerdip]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerdiz|integerdiz]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/integerfe|integerfe]] - Inexactly round a binary float to an integer valued float. Rounds towards nearest even.
 <br />
-[[Instruction_Set/integerffz|integerffz]] - Inexactly round a binary float to an integer valued float. Rounds towards nearest away from zero.
+[[Instruction_Set/integerfee|integerfee]] - <nowiki>principal op code: round to integral-valued float; arithmetic domain: binary
-<br />
+            floating point; exact result required: exact; rounding policy: to nearest, ties toward
-[[Instruction_Set/integerfn|integerfn]] - Inexactly round a binary float to an integer valued float. Rounds towards negative infinity.
+            even adjacent value; operation encoding group selector: exu-side operations; condition
-<br />
+            code generator: generate condition codes by comparing result with zero; operation
-[[Instruction_Set/integerfp|integerfp]] - Inexactly round a binary float to an integer valued float. Rounds towards positive infinity.
+            signature kind: belt operand from ops windo</nowiki><br />
-<br />
+[[Instruction_Set/integerfefz|integerfefz]] - <nowiki>principal op code: round to integral-valued float; arithmetic domain: binary
-[[Instruction_Set/integerfz|integerfz]] - Inexactly round a binary float to an integer valued float. Rounds towards zero.
+            floating point; exact result required: exact; rounding policy: to nearest, ties away
-<br />
+            from zero; operation encoding group selector: exu-side operations; condition code
-[[Instruction_Set/internalized|internalized]] - <nowiki>principal op code: convert a floating-point number from memory to internal format;
+            generator: generate condition codes by comparing result with zero; operation signature
-             arithmetic domain: decimal floating point; operation encoding group selector: flow-side
+            kind: belt operand from ops windo</nowiki><br />
-             operations; </nowiki><br />
+[[Instruction_Set/integerfen|integerfen]] - <nowiki>principal op code: round to integral-valued float; arithmetic domain: binary
-[[Instruction_Set/internalizef|internalizef]] - <nowiki>principal op code: convert a floating-point number from memory to internal format;
+            floating point; exact result required: exact; rounding policy: toward negative
-             arithmetic domain: binary floating point; operation encoding group selector: flow-side
+            infinity; operation encoding group selector: exu-side operations; condition code
-             operations; </nowiki><br />
+            generator: generate condition codes by comparing result with zero; operation signature
+            kind: belt operand from ops windo</nowiki><br />
+[[Instruction_Set/integerfep|integerfep]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerfez|integerfez]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/integerfi|integerfi]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerfie|integerfie]] - <nowiki>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;
+            </nowiki><br />
+[[Instruction_Set/integerfifz|integerfifz]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerfin|integerfin]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerfip|integerfip]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/integerfiz|integerfiz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/isNaR|isNaR]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/isNaRb|isNaRb]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/isNilp|isNilp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/isNilpb|isNilpb]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/isNone|isNone]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/isNoneb|isNoneb]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/isntNilp|isntNilp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/isntNilpb|isntNilpb]] - <nowiki>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; </nowiki><br />
+<div style="font-size: 10pt; font-weight: bold;" id="j">j</div>
+[[Instruction_Set/join|join]] - <nowiki>principal op code: bitwise concatenate; arithmetic domain: logical; single vs dual
+            vector result: single; operation encoding group selector: exu-side operations;
+            </nowiki><br />
+[[Instruction_Set/join2|join2]] - <nowiki>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</nowiki><br />
 <div style="font-size: 10pt; font-weight: bold;" id="l">l</div>
 [[Instruction_Set/lea|lea]] - Load Effective Address.
 <br />
+[[Instruction_Set/leas|leas]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/leass|leass]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/leau|leau]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/leaus|leaus]] - <nowiki>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;
+            </nowiki><br />
+[[Instruction_Set/leave|leave]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/leavefl|leavefl]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/leavefls|leavefls]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/leaves|leaves]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/leavetr|leavetr]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/leavetrs|leavetrs]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/left|left]] - Count leading false in or construct bool vector with leading false.
-<br />
-[[Instruction_Set/leq|leq]] - Integer lesser than or equal comparison.
 <br />
 [[Instruction_Set/leqd|leqd]] - Decimal float lesser than or equal comparison.
 <br />
+[[Instruction_Set/leqdb|leqdb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/leqdx|leqdx]] - Decimal float lesser than or equal comparison. NaN-Aware.
 <br />
+[[Instruction_Set/leqdxb|leqdxb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/leqf|leqf]] - Binary float lesser than or equal comparison.
 <br />
+[[Instruction_Set/leqfb|leqfb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/leqfx|leqfx]] - Binary float lesser than or equal comparison. NaN-Aware.
 <br />
-[[Instruction_Set/leqp|leqp]] - <nowiki>principal op code: less than or equal; arithmetic domain: pointers; operation
+[[Instruction_Set/leqfxb|leqfxb]] - <nowiki>principal op code: less than or equal; arithmetic domain: binary floating point;
-             encoding group selector: exu-side operations; </nowiki><br />
+            NaN-awareness: NaN-aware; retain argument width or narrow to bool: result has
+            "b" (bool) width; operation encoding group selector: exu-side operations;
+            </nowiki><br />
+[[Instruction_Set/leqp|leqp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/leqpb|leqpb]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/leqs|leqs]] - Signed integer lesser than or equal comparison.
 <br />
+[[Instruction_Set/leqsb|leqsb]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/lequ|lequ]] - Unsigned integer lesser than or equal comparison.
 <br />
-[[Instruction_Set/load|load]] - <nowiki>principal op code: load from memory; arithmetic domain: logical; addressing base:
+[[Instruction_Set/lequb|lequb]] - <nowiki>principal op code: less than or equal; arithmetic domain: unsigned integer; retain
-             pointer; operation encoding group selector: flow-side operations; possible manifest
+            argument width or narrow to bool: result has "b" (bool) width; operation
-             sizes in bytes: zero or one constant bytes; </nowiki><br />
+            encoding group selector: exu-side operations; </nowiki><br />
-[[Instruction_Set/loadd|loadd]] - <nowiki>principal op code: load from memory; arithmetic domain: decimal floating point;
+[[Instruction_Set/load|load]] - Schedule data load from memory address into belt.
-             addressing base: register; operation encoding group selector: flow-side operations;
+<br />
-             possible manifest sizes in bytes: zero, one, two, or four constant bytes; operation
+[[Instruction_Set/loadfl|loadfl]] - <nowiki>principal op code: load from memory; arithmetic domain: logical; addressing base:
-             signature kind: base special register, manifest constant, belt operand from opsWindow,
+             pointer; sense of condition: taken if false; operation encoding group selector:
-             scale factor for indexes in load/store/lea, data width and scalarity (flo</nowiki><br />
+            flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
-[[Instruction_Set/loadf|loadf]] - <nowiki>principal op code: load from memory; arithmetic domain: binary floating point;
+             constant bytes; </nowiki><br />
-             addressing base: register; operation encoding group selector: flow-side operations;
+[[Instruction_Set/loadfls|loadfls]] - <nowiki>principal op code: load from memory; arithmetic domain: logical; addressing base:
-             possible manifest sizes in bytes: zero, one, two, or four constant bytes; operation
+            register; sense of condition: taken if false; whether index in a memory reference is
-             signature kind: base special register, manifest constant, belt operand from opsWindow,
+            signed or unsigned: index is signed; index scale factor: index is in byte units;
-             scale factor for indexes in load/store/lea, data width and scalarity (flow),
+            operation encoding group selector: flow-side operations; possible manifest sizes in
-             morsel-sized manifest constan</nowiki><br />
+            bytes: zero, one, two, or four constant bytes; </nowiki><br />
+[[Instruction_Set/loadflss|loadflss]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loadflu|loadflu]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loadflus|loadflus]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loadRefresh|loadRefresh]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loads|loads]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loadss|loadss]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loadtr|loadtr]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loadtrs|loadtrs]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loadtrss|loadtrss]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loadtru|loadtru]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loadtrus|loadtrus]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loadu|loadu]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/loadus|loadus]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/localize|localize]] - <nowiki>principal op code: make pointer local; operation encoding group selector: flow-side
+            operations; </nowiki><br />
 [[Instruction_Set/logBd|logBd]] - <nowiki>principal op code: extract exponent; arithmetic domain: decimal floating point;
              operation encoding group selector: exu-side operations; </nowiki><br />
 [[Instruction_Set/logBf|logBf]] - <nowiki>principal op code: extract exponent; arithmetic domain: binary floating point;
              operation encoding group selector: exu-side operations; </nowiki><br />
-[[Instruction_Set/lss|lss]] - Integer lesser than comparison.
+[[Instruction_Set/longjmpl|longjmpl]] - target:p
 <br />
 [[Instruction_Set/lssd|lssd]] - Decimal float lesser than comparison.
 <br />
+[[Instruction_Set/lssdb|lssdb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/lssdx|lssdx]] - Decimal float lesser than comparison. NaN-Aware.
 <br />
+[[Instruction_Set/lssdxb|lssdxb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/lssf|lssf]] - Binary float lesser than comparison.
 <br />
+[[Instruction_Set/lssfb|lssfb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/lssfx|lssfx]] - Binary float lesser than comparison. NaN-Aware.
 <br />
+[[Instruction_Set/lssfxb|lssfxb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/lssp|lssp]] - Pointer lesser than.
 <br />
+[[Instruction_Set/lsspb|lsspb]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/lsss|lsss]] - Signed integer lesser than comparison.
 <br />
+[[Instruction_Set/lsssb|lsssb]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/lssu|lssu]] - Unsigned integer lesser than comparison.
 <br />
+[[Instruction_Set/lssub|lssub]] - <nowiki>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; </nowiki><br />
 <div style="font-size: 10pt; font-weight: bold;" id="m">m</div>
@@ Line 838: / Line 1,739: @@
 <br />
 [[Instruction_Set/muls|muls]] - Alias for [[Instruction_Set/mul|mul]].<br />
+[[Instruction_Set/muls2|muls2]] - Alias for [[Instruction_Set/muls|muls]].<br />
 [[Instruction_Set/mulsf|mulsf]] - Signed Fixed Point multiply. Uses current dynamic rounding mode.
 <br />
@@ Line 888: / Line 1,790: @@
 [[Instruction_Set/mulss|mulss]] - Signed Integer multiply. Saturating.
 <br />
-[[Instruction_Set/mulssv|mulssv]] - Alias for [[Instruction_Set/mulss|mulss]].<br />
+[[Instruction_Set/mulss2|mulss2]] - Alias for [[Instruction_Set/mulss|mulss]].<br />
-[[Instruction_Set/mulsv|mulsv]] - Alias for [[Instruction_Set/mul|mul]].<br />
 [[Instruction_Set/mulsw|mulsw]] - Signed Integer multiply. Widening.
 <br />
-[[Instruction_Set/mulswv|mulswv]] - Signed integer multiply. Widening for a vector.
+[[Instruction_Set/mulsw2|mulsw2]] - <nowiki>principal op code: multiplication; arithmetic domain: signed integer; overflow
-<br />
+            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; </nowiki><br />
 [[Instruction_Set/mulsx|mulsx]] - Signed Integer multiply. Excepting.
 <br />
-[[Instruction_Set/mulsxv|mulsxv]] - Alias for [[Instruction_Set/mulsx|mulsx]].<br />
+[[Instruction_Set/mulsx2|mulsx2]] - Alias for [[Instruction_Set/mulsx|mulsx]].<br />
 [[Instruction_Set/mulu|mulu]] - Alias for [[Instruction_Set/mul|mul]].<br />
+[[Instruction_Set/mulu2|mulu2]] - Alias for [[Instruction_Set/mulu|mulu]].<br />
 [[Instruction_Set/muluf|muluf]] - Unsigned Fixed Point multiply. Uses current dynamic rounding mode.
 <br />
@@ Line 948: / Line 1,852: @@
 [[Instruction_Set/mulus|mulus]] - Unsigned integer multiply. Saturating.
 <br />
-[[Instruction_Set/mulusv|mulusv]] - Alias for [[Instruction_Set/mulus|mulus]].<br />
+[[Instruction_Set/mulus2|mulus2]] - Alias for [[Instruction_Set/mulus|mulus]].<br />
-[[Instruction_Set/muluv|muluv]] - Alias for [[Instruction_Set/mul|mul]].<br />
 [[Instruction_Set/muluw|muluw]] - Unsigned integer multiply. Widening.
 <br />
-[[Instruction_Set/muluwv|muluwv]] - Unsigned integer multiply. Widening for a vector.
+[[Instruction_Set/muluw2|muluw2]] - <nowiki>principal op code: multiplication; arithmetic domain: unsigned integer; overflow
-<br />
+            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; </nowiki><br />
 [[Instruction_Set/mulux|mulux]] - Unsigned integer multiply. Excepting.
 <br />
-[[Instruction_Set/muluxv|muluxv]] - Alias for [[Instruction_Set/mulux|mulux]].<br />
+[[Instruction_Set/mulux2|mulux2]] - Alias for [[Instruction_Set/mulux|mulux]].<br />
 <div style="font-size: 10pt; font-weight: bold;" id="n">n</div>
@@ Line 964: / Line 1,869: @@
 [[Instruction_Set/nandu|nandu]] - Alias for [[Instruction_Set/nand|nand]].<br />
 [[Instruction_Set/NaR|NaR]] - Produces a [[NaR]] of the given width and kind.
-<br />
-[[Instruction_Set/narrow|narrow]] - Half the width of an integer value.
 <br />
 [[Instruction_Set/narrowd|narrowd]] - Half the width of a decimal float value. Current rounding mode.
@@ Line 991: / Line 1,894: @@
 [[Instruction_Set/narrowfz|narrowfz]] - Half the width of a binary float value. Rounding towards zero.
 <br />
-[[Instruction_Set/narrows|narrows]] - Alias for [[Instruction_Set/narrow|narrow]].<br />
+[[Instruction_Set/narrows|narrows]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/narrows2|narrows2]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/narrowss|narrowss]] - Half the width of a signed integer value. Saturating on overflow.
 <br />
+[[Instruction_Set/narrowss2|narrowss2]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/narrowsx|narrowsx]] - Half the width of a signed integer value. Exception on overflow.
 <br />
-[[Instruction_Set/narrowu|narrowu]] - Alias for [[Instruction_Set/narrow|narrow]].<br />
+[[Instruction_Set/narrowsx2|narrowsx2]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/narrowu|narrowu]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/narrowu2|narrowu2]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/narrowus|narrowus]] - Half the width of an unsigned integer value. Saturating on overflow.
 <br />
+[[Instruction_Set/narrowus2|narrowus2]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/narrowux|narrowux]] - Half the width of an unsigned integer value. Exception on overflow.
 <br />
-[[Instruction_Set/neg|neg]] - Integer arithmetic negation. Modulo overflow.
+[[Instruction_Set/narrowux2|narrowux2]] - <nowiki>principal op code: narrow scalar to half width; arithmetic domain: unsigned integer;
-<br />
+            overflow policy: excepting; single vs dual vector result: dual; operation encoding
+            group selector: exu-side operations; </nowiki><br />
 [[Instruction_Set/negd|negd]] - Decimal float arithmetic negation.
 <br />
 [[Instruction_Set/negf|negf]] - Binary float arithmetic negation.
 <br />
-[[Instruction_Set/negs|negs]] - Alias for [[Instruction_Set/neg|neg]].<br />
-[[Instruction_Set/negss|negss]] - Integer arithmetic negation. Saturating overflow.
-<br />
-[[Instruction_Set/negssv|negssv]] - Alias for [[Instruction_Set/negss|negss]].<br />
-[[Instruction_Set/negsv|negsv]] - Alias for [[Instruction_Set/neg|neg]].<br />
-[[Instruction_Set/negsw|negsw]] - Integer arithmetic negation. Widening.
-<br />
-[[Instruction_Set/negswv|negswv]] - <nowiki>principal op code: negate; arithmetic domain: signed integer; overflow policy:
-            widening; scalar vs. vector data: vector; operation encoding group selector: exu-side
-            operations; condition code generator: generate condition codes; operation signature
-            kind: belt operand from ops windo</nowiki><br />
-[[Instruction_Set/negsx|negsx]] - Integer arithmetic negation. Exception on overflow.
-<br />
-[[Instruction_Set/negsxv|negsxv]] - Alias for [[Instruction_Set/negsx|negsx]].<br />
 [[Instruction_Set/neq|neq]] - Integer inequality comparison.
 <br />
+[[Instruction_Set/neqb|neqb]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/neqd|neqd]] - Decimal float inequality comparison.
 <br />
+[[Instruction_Set/neqdb|neqdb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/neqdx|neqdx]] - Decimal float inequality comparison. NaN-Aware.
 <br />
+[[Instruction_Set/neqdxb|neqdxb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/neqf|neqf]] - Binary float inequality comparison.
 <br />
+[[Instruction_Set/neqfb|neqfb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/neqfx|neqfx]] - Binary float inequality comparison. NaN-Aware.
 <br />
+[[Instruction_Set/neqfxb|neqfxb]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/neqp|neqp]] - Pointer inequality.
 <br />
+[[Instruction_Set/neqpb|neqpb]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/neqs|neqs]] - Alias for [[Instruction_Set/neq|neq]].<br />
+[[Instruction_Set/neqsb|neqsb]] - Alias for [[Instruction_Set/neqb|neqb]].<br />
 [[Instruction_Set/nequ|nequ]] - Alias for [[Instruction_Set/neq|neq]].<br />
+[[Instruction_Set/nequb|nequb]] - Alias for [[Instruction_Set/neqb|neqb]].<br />
 [[Instruction_Set/nextDownd|nextDownd]] - <nowiki>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; </nowiki><br />
+             generator: generate condition codes by comparing result with zero; operation signature
+            kind: belt operand from ops windo</nowiki><br />
 [[Instruction_Set/nextDownf|nextDownf]] - <nowiki>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; </nowiki><br />
+             generator: generate condition codes by comparing result with zero; operation signature
+            kind: belt operand from ops windo</nowiki><br />
 [[Instruction_Set/nextUpd|nextUpd]] - <nowiki>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; </nowiki><br />
+             generator: generate condition codes by comparing result with zero; operation signature
+            kind: belt operand from ops windo</nowiki><br />
 [[Instruction_Set/nextUpf|nextUpf]] - <nowiki>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; </nowiki><br />
+             generator: generate condition codes by comparing result with zero; operation signature
+            kind: belt operand from ops windo</nowiki><br />
 [[Instruction_Set/nimp|nimp]] - Bitwise negative implication.
 <br />
@@ Line 1,058: / Line 1,995: @@
 <br />
 [[Instruction_Set/norddx|norddx]] - <nowiki>principal op code: unordered relation; arithmetic domain: decimal floating point;
-             NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
+             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</nowiki><br />
+[[Instruction_Set/norddxb|norddxb]] - <nowiki>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;
              </nowiki><br />
 [[Instruction_Set/nordfx|nordfx]] - <nowiki>principal op code: unordered relation; arithmetic domain: binary floating point;
-             NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
+             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</nowiki><br />
+[[Instruction_Set/nordfxb|nordfxb]] - <nowiki>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;
              </nowiki><br />
 [[Instruction_Set/nors|nors]] - Alias for [[Instruction_Set/nor|nor]].<br />
@@ Line 1,087: / Line 2,034: @@
 [[Instruction_Set/orls|orls]] - Alias for [[Instruction_Set/orl|orl]].<br />
 [[Instruction_Set/orlu|orlu]] - Alias for [[Instruction_Set/orl|orl]].<br />
-[[Instruction_Set/overflow|overflow]] - <nowiki>principal op code: overflow gang predicate; arithmetic domain: logical; operation
+[[Instruction_Set/overflow|overflow]] - Gets the overflow condition code of the ganged operation and puts it on the belt.
+<br />
+[[Instruction_Set/overflowb|overflowb]] - <nowiki>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; </nowiki><br />
 <div style="font-size: 10pt; font-weight: bold;" id="p">p</div>
+[[Instruction_Set/p2u|p2u]] - <nowiki>principal op code: convert pointer to unsigned integer; operation encoding group
+            selector: flow-side operations; </nowiki><br />
 [[Instruction_Set/pick|pick]] - Pick between two values based on a condition.
 <br />
-[[Instruction_Set/pickup|pickup]] - <nowiki>principal op code: accept a speculative load; arithmetic domain: logical; operation
+[[Instruction_Set/pickup|pickup]] - <nowiki>principal op code: accept a speculative load; arithmetic domain: logical; sense of
-             encoding group selector: exu-side readers; </nowiki><br />
+            condition: taken unconditionally; operation encoding group selector: exu-side readers;
+             </nowiki><br />
+[[Instruction_Set/pickupfl|pickupfl]] - <nowiki>principal op code: accept a speculative load; arithmetic domain: logical; sense of
+            condition: taken if false; operation encoding group selector: exu-side readers;
+            </nowiki><br />
+[[Instruction_Set/pickuptr|pickuptr]] - <nowiki>principal op code: accept a speculative load; arithmetic domain: logical; sense of
+            condition: taken if true; operation encoding group selector: exu-side readers;
+            </nowiki><br />
 <div style="font-size: 10pt; font-weight: bold;" id="q">q</div>
@@ Line 1,104: / Line 2,063: @@
 [[Instruction_Set/rd|rd]] - <nowiki>principal op code: hardware reader; arithmetic domain: logical; operation encoding
              group selector: exu-side readers; </nowiki><br />
-[[Instruction_Set/rdivd|rdivd]] - Decimal float reciprocal dividide.
-<br />
-[[Instruction_Set/rdivf|rdivf]] - Binary float reciprocal dividide.
-<br />
-[[Instruction_Set/rdivs|rdivs]] - Signed integer reciprocal dividion. Helper operation for software division implementation.
-<br />
-[[Instruction_Set/rdivu|rdivu]] - Unsigned integer reciprocal dividion. Helper operation for software division implementation.
-<br />
 [[Instruction_Set/recur|recur]] - Pick between two values based on a condition value being a [[NaR]] or not.
 <br />
@@ Line 1,126: / Line 2,077: @@
 [[Instruction_Set/rescue|rescue]] - Move belt items to the front of the belt.
 <br />
+[[Instruction_Set/resf|resf]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/resolve|resolve]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/resolvep|resolvep]] - Alias for [[Instruction_Set/resolve|resolve]].<br />
+[[Instruction_Set/restoreStack|restoreStack]] - <nowiki>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:</nowiki><br />
 [[Instruction_Set/retire|retire]] - <nowiki>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; </nowiki><br />
-[[Instruction_Set/retn|retn]] - <nowiki>principal op code: return from function; sense of condition: taken unconditionally;
+[[Instruction_Set/retn|retn]] - Returns values and control to the caller.
-            operation encoding group selector: flow-side operations; possible manifest sizes in
+<br />
-            bytes: zero, one, two, or four constant bytes; </nowiki><br />
+[[Instruction_Set/retnfl|retnfl]] - Conditionally returns values and control to the caller on false.
-[[Instruction_Set/retnfl|retnfl]] - <nowiki>principal op code: return from function; sense of condition: taken if false;
+<br />
-            operation encoding group selector: flow-side operations; possible manifest sizes in
+[[Instruction_Set/retntr|retntr]] - Conditionally returns values and control to the caller on true.
-            bytes: zero, one, two, or four constant bytes; </nowiki><br />
+<br />
-[[Instruction_Set/retntr|retntr]] - <nowiki>principal op code: return from function; 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; </nowiki><br />
 [[Instruction_Set/reverse|reverse]] - Reverse the bit order.
 <br />
-[[Instruction_Set/reversep|reversep]] - Alias for [[Instruction_Set/reverse|reverse]].<br />
 [[Instruction_Set/rootd|rootd]] - Decimal floating point square root in current rounding mode.
 <br />
@@ Line 1,172: / Line 2,126: @@
 [[Instruction_Set/rootu|rootu]] - Unsigned integer square root. Helper operation for software square root implementation.
 <br />
-[[Instruction_Set/rotate|rotate]] - <nowiki>principal op code: bitwise rotate; arithmetic domain: logical; operation encoding
-            group selector: exu-side readers; </nowiki><br />
 [[Instruction_Set/rotatel|rotatel]] - Bit rotate left.
 <br />
@@ Line 1,180: / Line 2,132: @@
 [[Instruction_Set/rrootd|rrootd]] - Decimal float reciprocal square root.
 <br />
+[[Instruction_Set/rrootde|rrootde]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rrootdfz|rrootdfz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rrootdn|rrootdn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rrootdp|rrootdp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rrootdz|rrootdz]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/rrootf|rrootf]] - Binary float reciprocal square root.
 <br />
+[[Instruction_Set/rrootfe|rrootfe]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rrootffz|rrootffz]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rrootfn|rrootfn]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rrootfp|rrootfp]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rrootfz|rrootfz]] - <nowiki>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;
+            </nowiki><br />
 [[Instruction_Set/rroots|rroots]] - <nowiki>principal op code: reciprocal square root; arithmetic domain: signed integer;
-             operation encoding group selector: exu-side operations; </nowiki><br />
+             operation encoding group selector: exu-side operations; condition code generator:
+            generate condition codes by comparing result with zero; </nowiki><br />
 [[Instruction_Set/rrootu|rrootu]] - <nowiki>principal op code: reciprocal square root; arithmetic domain: unsigned integer;
-             operation encoding group selector: exu-side operations; </nowiki><br />
+             operation encoding group selector: exu-side operations; condition code generator:
+            generate condition codes by comparing result with zero; </nowiki><br />
+[[Instruction_Set/rsub|rsub]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rsubs|rsubs]] - Alias for [[Instruction_Set/rsub|rsub]].<br />
+[[Instruction_Set/rsubs2|rsubs2]] - Alias for [[Instruction_Set/rsubs|rsubs]].<br />
+[[Instruction_Set/rsubss|rsubss]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rsubss2|rsubss2]] - Alias for [[Instruction_Set/rsubss|rsubss]].<br />
+[[Instruction_Set/rsubsw|rsubsw]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rsubsw2|rsubsw2]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rsubsx|rsubsx]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rsubsx2|rsubsx2]] - Alias for [[Instruction_Set/rsubsx|rsubsx]].<br />
+[[Instruction_Set/rsubu|rsubu]] - Alias for [[Instruction_Set/rsub|rsub]].<br />
+[[Instruction_Set/rsubu2|rsubu2]] - Alias for [[Instruction_Set/rsubu|rsubu]].<br />
+[[Instruction_Set/rsubus|rsubus]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rsubus2|rsubus2]] - Alias for [[Instruction_Set/rsubus|rsubus]].<br />
+[[Instruction_Set/rsubuw|rsubuw]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rsubuw2|rsubuw2]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rsubux|rsubux]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/rsubux2|rsubux2]] - Alias for [[Instruction_Set/rsubux|rsubux]].<br />
 <div style="font-size: 10pt; font-weight: bold;" id="s">s</div>
@@ Line 1,214: / Line 2,251: @@
 [[Instruction_Set/s2u|s2u]] - Signed integer to unsigned integer.
 <br />
+[[Instruction_Set/s2u2|s2u2]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/s2us|s2us]] - Signed integer to unsigned integer. Saturating.
 <br />
+[[Instruction_Set/s2us2|s2us2]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/s2ux|s2ux]] - Signed integer to unsigned integer. Excepting.
 <br />
+[[Instruction_Set/s2ux2|s2ux2]] - <nowiki>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; </nowiki><br />
 [[Instruction_Set/sameQuantumd|sameQuantumd]] - <nowiki>principal op code: same exponent; arithmetic domain: decimal floating point;
              operation encoding group selector: exu-side operations; </nowiki><br />
+[[Instruction_Set/saveStack|saveStack]] - <nowiki>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:</nowiki><br />
 [[Instruction_Set/scaleBd|scaleBd]] - <nowiki>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; operation
+             exu-side operations; condition code generator: generate condition codes by comparing
-             signature kind: belt operand from ops window, belt operand from ops windo</nowiki><br />
+             result with zero; </nowiki><br />
 [[Instruction_Set/scaleBde|scaleBde]] - <nowiki>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;
+             selector: exu-side operations; condition code generator: generate condition codes by
-             </nowiki><br />
+             comparing result with zero; </nowiki><br />
 [[Instruction_Set/scaleBdfz|scaleBdfz]] - <nowiki>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; operation
+             exu-side operations; condition code generator: generate condition codes by comparing
-             signature kind: belt operand from ops window, belt operand from ops windo</nowiki><br />
+             result with zero; </nowiki><br />
 [[Instruction_Set/scaleBdn|scaleBdn]] - <nowiki>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; operation signature
+             operations; condition code generator: generate condition codes by comparing result with
-             kind: belt operand from ops window, belt operand from ops windo</nowiki><br />
+             zero; </nowiki><br />
 [[Instruction_Set/scaleBdp|scaleBdp]] - <nowiki>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; operation signature
+             operations; condition code generator: generate condition codes by comparing result with
-             kind: belt operand from ops window, belt operand from ops windo</nowiki><br />
+             zero; </nowiki><br />
 [[Instruction_Set/scaleBdz|scaleBdz]] - <nowiki>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; </nowiki><br />
+             condition code generator: generate condition codes by comparing result with zero;
+            </nowiki><br />
 [[Instruction_Set/scaleBf|scaleBf]] - <nowiki>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; operation
+             exu-side operations; condition code generator: generate condition codes by comparing
-             signature kind: belt operand from ops window, belt operand from ops windo</nowiki><br />
+             result with zero; </nowiki><br />
 [[Instruction_Set/scaleBfe|scaleBfe]] - <nowiki>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;
+             selector: exu-side operations; condition code generator: generate condition codes by
-             </nowiki><br />
+             comparing result with zero; </nowiki><br />
 [[Instruction_Set/scaleBffz|scaleBffz]] - <nowiki>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; operation
+             exu-side operations; condition code generator: generate condition codes by comparing
-             signature kind: belt operand from ops window, belt operand from ops windo</nowiki><br />
+             result with zero; </nowiki><br />
 [[Instruction_Set/scaleBfn|scaleBfn]] - <nowiki>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; operation signature
+             operations; condition code generator: generate condition codes by comparing result with
-             kind: belt operand from ops window, belt operand from ops windo</nowiki><br />
+             zero; </nowiki><br />
 [[Instruction_Set/scaleBfp|scaleBfp]] - <nowiki>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; operation signature
+             operations; condition code generator: generate condition codes by comparing result with
-             kind: belt operand from ops window, belt operand from ops windo</nowiki><br />
+             zero; </nowiki><br />
 [[Instruction_Set/scaleBfz|scaleBfz]] - <nowiki>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; </nowiki><br />
+             condition code generator: generate condition codes by comparing result with zero;
+            </nowiki><br />
 [[Instruction_Set/scratchf|scratchf]] - <nowiki>principal op code: allocate scratchpad frame; arithmetic domain: logical; operation
              encoding group selector: exu-side readers; </nowiki><br />
 [[Instruction_Set/set|set]] - Set a single indexed bit.
+<br />
+[[Instruction_Set/setjmp|setjmp]] -
 <br />
 [[Instruction_Set/shiftl|shiftl]] - Bitwise left shift.
 <br />
 [[Instruction_Set/shiftls|shiftls]] - Alias for [[Instruction_Set/shiftl|shiftl]].<br />
+[[Instruction_Set/shiftls2|shiftls2]] - Alias for [[Instruction_Set/shiftl|shiftl]].<br />
 [[Instruction_Set/shiftlss|shiftlss]] - Signed bitwise left shift. Saturating.
 <br />
-[[Instruction_Set/shiftlssv|shiftlssv]] - Alias for [[Instruction_Set/shiftlss|shiftlss]].<br />
+[[Instruction_Set/shiftlss2|shiftlss2]] - Alias for [[Instruction_Set/shiftlss|shiftlss]].<br />
-[[Instruction_Set/shiftlsv|shiftlsv]] - Alias for [[Instruction_Set/shiftl|shiftl]].<br />
 [[Instruction_Set/shiftlsw|shiftlsw]] - Signed bitwise left shift. Widening.
 <br />
-[[Instruction_Set/shiftlswv|shiftlswv]] - Signed bitwise vector left shift. Widening.
+[[Instruction_Set/shiftlsw2|shiftlsw2]] - <nowiki>principal op code: bitwise shift; shift direction: toward greater significance;
-<br />
+            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</nowiki><br />
 [[Instruction_Set/shiftlsx|shiftlsx]] - Signed bitwise left shift. Excepting.
 <br />
-[[Instruction_Set/shiftlsxv|shiftlsxv]] - Alias for [[Instruction_Set/shiftlsx|shiftlsx]].<br />
+[[Instruction_Set/shiftlsx2|shiftlsx2]] - Alias for [[Instruction_Set/shiftlsx|shiftlsx]].<br />
 [[Instruction_Set/shiftlu|shiftlu]] - Alias for [[Instruction_Set/shiftl|shiftl]].<br />
+[[Instruction_Set/shiftlu2|shiftlu2]] - Alias for [[Instruction_Set/shiftlu|shiftlu]].<br />
 [[Instruction_Set/shiftlus|shiftlus]] - Unsigned bitwise left shift. Saturating.
 <br />
-[[Instruction_Set/shiftlusv|shiftlusv]] - Alias for [[Instruction_Set/shiftlus|shiftlus]].<br />
+[[Instruction_Set/shiftlus2|shiftlus2]] - Alias for [[Instruction_Set/shiftlus|shiftlus]].<br />
-[[Instruction_Set/shiftluv|shiftluv]] - Alias for [[Instruction_Set/shiftl|shiftl]].<br />
 [[Instruction_Set/shiftluw|shiftluw]] - Unsigned bitwise left shift. Widening.
 <br />
-[[Instruction_Set/shiftluwv|shiftluwv]] - Unsigned bitwise vector left shift. Widening.
+[[Instruction_Set/shiftluw2|shiftluw2]] - <nowiki>principal op code: bitwise shift; shift direction: toward greater significance;
-<br />
+            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</nowiki><br />
 [[Instruction_Set/shiftlux|shiftlux]] - Unsigned bitwise left shift. Excepting.
 <br />
-[[Instruction_Set/shiftluxv|shiftluxv]] - Alias for [[Instruction_Set/shiftlux|shiftlux]].<br />
+[[Instruction_Set/shiftlux2|shiftlux2]] - Alias for [[Instruction_Set/shiftlux|shiftlux]].<br />
 [[Instruction_Set/shiftrs|shiftrs]] - Signed bit shift right.
 <br />
@@ Line 1,326: / Line 2,385: @@
 [[Instruction_Set/shuffle|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.
 <br />
+[[Instruction_Set/sig|sig]] - <nowiki>principal op code: assert width of belt operand; arithmetic domain: logical;
+            operation encoding group selector: exu-side writers; </nowiki><br />
 [[Instruction_Set/smeari|smeari]] - Find the first one in a bool vector and set all remaining elments to one too.
 <br />
 [[Instruction_Set/smearx|smearx]] - Find the first one in a bool vector, shift it one to the right and set all remaining elments to one too.
 <br />
-[[Instruction_Set/spill|spill]] - <nowiki>principal op code: spill operand to extended scratchpad; operation encoding group
+[[Instruction_Set/spill|spill]] - <nowiki>principal op code: spill operand to extended scratchpad; arithmetic domain: logical;
-             selector: flow-side operations; possible manifest sizes in bytes: zero, one, two, or
+            sense of condition: taken unconditionally; operation encoding group selector: exu-side
-             four constant bytes; </nowiki><br />
+             writers; </nowiki><br />
+[[Instruction_Set/spillfl|spillfl]] - <nowiki>principal op code: spill operand to extended scratchpad; arithmetic domain: logical;
+            sense of condition: taken if false; operation encoding group selector: exu-side
+            writers; </nowiki><br />
+[[Instruction_Set/spilltr|spilltr]] - <nowiki>principal op code: spill operand to extended scratchpad; arithmetic domain: logical;
+             sense of condition: taken if true; operation encoding group selector: exu-side writers;
+            </nowiki><br />
 [[Instruction_Set/splat|splat]] - Duplicate a scalar value into a vector.
 <br />
@@ Line 1,338: / Line 2,405: @@
              flow-side operations; possible manifest sizes in bytes: zero, one, two, or four
              constant bytes; </nowiki><br />
-[[Instruction_Set/store|store]] - <nowiki>principal op code: store to memory; arithmetic domain: logical; addressing base:
+[[Instruction_Set/store|store]] - Take a value from the belt and store it to the computed address.
-             register; operation encoding group selector: flow-side operations; possible manifest
+<br />
+[[Instruction_Set/storefl|storefl]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storefls|storefls]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storeflss|storeflss]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storeflu|storeflu]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storeflus|storeflus]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storep|storep]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storepfl|storepfl]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storepfls|storepfls]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storepflss|storepflss]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storepflu|storepflu]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storepflus|storepflus]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storeps|storeps]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storepss|storepss]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storeptr|storeptr]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storeptrs|storeptrs]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storeptrss|storeptrss]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storeptru|storeptru]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storeptrus|storeptrus]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storepu|storepu]] - <nowiki>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; </nowiki><br />
-[[Instruction_Set/stored|stored]] - <nowiki>principal op code: store to memory; arithmetic domain: decimal floating point;
+[[Instruction_Set/storepus|storepus]] - <nowiki>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</nowiki><br />
+[[Instruction_Set/stores|stores]] - <nowiki>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 or one constant bytes; </nowiki><br />
+             bytes: zero, one, two, or four constant bytes; </nowiki><br />
-[[Instruction_Set/storef|storef]] - <nowiki>principal op code: store to memory; arithmetic domain: binary floating point;
+[[Instruction_Set/storess|storess]] - <nowiki>principal op code: store to memory; arithmetic domain: logical; addressing base:
-             addressing base: register; operation encoding group selector: flow-side operations;
+             pointer; sense of condition: taken unconditionally; whether index in a memory reference
-             possible manifest sizes in bytes: zero, one, two, or four constant bytes; operation
+            is signed or unsigned: index is signed; index scale factor: index is in scalar width
-             signature kind: base special register, manifest constant, belt operand from opsWindow,
+            units; operation encoding group selector: flow-side operations; possible manifest sizes
-             scale factor for indexes in load/store/lea, late-evaluated operand from bel</nowiki><br />
+            in bytes: zero, one, two, or four constant bytes; </nowiki><br />
-[[Instruction_Set/storep|storep]] - <nowiki>principal op code: store to memory; arithmetic domain: pointers; addressing base:
+[[Instruction_Set/storetr|storetr]] - <nowiki>principal op code: store to memory; arithmetic domain: logical; addressing base:
-             register; operation encoding group selector: flow-side operations; possible manifest
+            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; </nowiki><br />
+[[Instruction_Set/storetrs|storetrs]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storetrss|storetrss]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storetru|storetru]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storetrus|storetrus]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storeu|storeu]] - <nowiki>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; </nowiki><br />
+[[Instruction_Set/storeus|storeus]] - <nowiki>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</nowiki><br />
 [[Instruction_Set/streamf|streamf]] - <nowiki>principal op code: allocate streamer frame; operation encoding group selector:
              flow-side operations; </nowiki><br />
 [[Instruction_Set/sub|sub]] - Normal unsigned substraction.
-<br />
-[[Instruction_Set/sub1u|sub1u]] - Decrement by one.
 <br />
 [[Instruction_Set/subd|subd]] - Decimal floating point subtraction in current rounding mode.
@@ Line 1,385: / Line 2,582: @@
 <br />
 [[Instruction_Set/subs|subs]] - Alias for [[Instruction_Set/sub|sub]].<br />
+[[Instruction_Set/subs2|subs2]] - Alias for [[Instruction_Set/subs|subs]].<br />
 [[Instruction_Set/subss|subss]] - Saturating signed integer subtraction.
 <br />
-[[Instruction_Set/subssv|subssv]] - Alias for [[Instruction_Set/subss|subss]].<br />
+[[Instruction_Set/subss2|subss2]] - Alias for [[Instruction_Set/subss|subss]].<br />
-[[Instruction_Set/subsv|subsv]] - Alias for [[Instruction_Set/sub|sub]].<br />
 [[Instruction_Set/subsw|subsw]] - Widening signed integer subtraction.
 <br />
-[[Instruction_Set/subswv|subswv]] - Widening signed integer vector subtraction.
+[[Instruction_Set/subsw2|subsw2]] - <nowiki>principal op code: subtraction; arithmetic domain: signed integer; overflow policy:
-<br />
+            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; </nowiki><br />
 [[Instruction_Set/subsx|subsx]] - Excepting signed integer subtraction.
 <br />
-[[Instruction_Set/subsxv|subsxv]] - Alias for [[Instruction_Set/subsx|subsx]].<br />
+[[Instruction_Set/subsx2|subsx2]] - Alias for [[Instruction_Set/subsx|subsx]].<br />
 [[Instruction_Set/subu|subu]] - Alias for [[Instruction_Set/sub|sub]].<br />
+[[Instruction_Set/subu2|subu2]] - Alias for [[Instruction_Set/subu|subu]].<br />
 [[Instruction_Set/subus|subus]] - Saturating unsigned integer subtraction.
 <br />
-[[Instruction_Set/subusv|subusv]] - Alias for [[Instruction_Set/subus|subus]].<br />
+[[Instruction_Set/subus2|subus2]] - Alias for [[Instruction_Set/subus|subus]].<br />
-[[Instruction_Set/subuv|subuv]] - Alias for [[Instruction_Set/sub|sub]].<br />
 [[Instruction_Set/subuw|subuw]] - Widening unsigned integer subtraction.
 <br />
-[[Instruction_Set/subuwv|subuwv]] - Widening unsigned integer vector subtraction.
+[[Instruction_Set/subuw2|subuw2]] - <nowiki>principal op code: subtraction; arithmetic domain: unsigned integer; overflow
-<br />
+            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; </nowiki><br />
 [[Instruction_Set/subux|subux]] - Excepting unsigned integer subtraction.
 <br />
-[[Instruction_Set/subuxv|subuxv]] - Alias for [[Instruction_Set/subux|subux]].<br />
+[[Instruction_Set/subux2|subux2]] - Alias for [[Instruction_Set/subux|subux]].<br />
 <div style="font-size: 10pt; font-weight: bold;" id="t">t</div>
 [[Instruction_Set/test|test]] - Test if a single indexed bit is set.
 <br />
+[[Instruction_Set/trap|trap]] - <nowiki>principal op code: trigger a trap to a handler; arithmetic domain: logical; sense of
+            condition: taken unconditionally; operation encoding group selector: exu-side writers;
+            </nowiki><br />
+[[Instruction_Set/trapfl|trapfl]] - <nowiki>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;
+            </nowiki><br />
+[[Instruction_Set/traptr|traptr]] - <nowiki>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;
+            </nowiki><br />
 <div style="font-size: 10pt; font-weight: bold;" id="u">u</div>
@@ Line 1,438: / Line 2,648: @@
 [[Instruction_Set/u2ffz|u2ffz]] - Unsigned integer to binary float conversion. Rounding towards zero.
 <br />
+[[Instruction_Set/u2p|u2p]] - <nowiki>principal op code: convert unsigned integer to pointer; operation encoding group
+            selector: flow-side operations; </nowiki><br />
 [[Instruction_Set/u2s|u2s]] - Unsigned integer to signed integer.
 <br />
+[[Instruction_Set/u2s2|u2s2]] - Alias for [[Instruction_Set/u2s|u2s]].<br />
 [[Instruction_Set/u2ss|u2ss]] - Unsigned integer to signed integer. Saturating.
 <br />
-[[Instruction_Set/u2ssv|u2ssv]] - Alias for [[Instruction_Set/u2ss|u2ss]].<br />
+[[Instruction_Set/u2ss2|u2ss2]] - Alias for [[Instruction_Set/u2ss|u2ss]].<br />
-[[Instruction_Set/u2sv|u2sv]] - Alias for [[Instruction_Set/u2s|u2s]].<br />
 [[Instruction_Set/u2sw|u2sw]] - Unsigned integer to signed integer. Widening.
 <br />
-[[Instruction_Set/u2swv|u2swv]] - Unsigned integer vector to signed integer vectors. Widening.
+[[Instruction_Set/u2sw2|u2sw2]] - <nowiki>principal op code: convert unsigned to signed; arithmetic domain: logical; overflow
-<br />
+            policy: widening; single vs dual vector result: dual; operation encoding group
+            selector: exu-side operations; </nowiki><br />
 [[Instruction_Set/u2sx|u2sx]] - Unsigned integer to signed integer. Excepting.
 <br />
-[[Instruction_Set/u2sxv|u2sxv]] - Alias for [[Instruction_Set/u2sx|u2sx]].<br />
+[[Instruction_Set/u2sx2|u2sx2]] - Alias for [[Instruction_Set/u2sx|u2sx]].<br />
 <div style="font-size: 10pt; font-weight: bold;" id="v">v</div>
@@ Line 1,457: / Line 2,670: @@
 <div style="font-size: 10pt; font-weight: bold;" id="w">w</div>
-[[Instruction_Set/widen|widen]] - Double the scalar width of an unsigned integer.
-<br />
 [[Instruction_Set/widend|widend]] - Double the scalar width of a decimal float.
 <br />
-[[Instruction_Set/widendv|widendv]] - Double the scalar width of the elements of a decimal float vector.
+[[Instruction_Set/widend2|widend2]] - <nowiki>principal op code: widen to double width; arithmetic domain: decimal floating point;
-<br />
+            single vs dual vector result: dual; operation encoding group selector: exu-side
+            operations; </nowiki><br />
 [[Instruction_Set/widenf|widenf]] - Double the scalar width of a binary float.
 <br />
-[[Instruction_Set/widenfv|widenfv]] - Double the scalar width of the elements of a binary float vector.
+[[Instruction_Set/widenf2|widenf2]] - <nowiki>principal op code: widen to double width; arithmetic domain: binary floating point;
-<br />
+            single vs dual vector result: dual; operation encoding group selector: exu-side
+            operations; </nowiki><br />
 [[Instruction_Set/widens|widens]] - Double the scalar width of a signed integer.
 <br />
+[[Instruction_Set/widens2|widens2]] - <nowiki>principal op code: widen to double width; arithmetic domain: signed integer; single
+            vs dual vector result: dual; operation encoding group selector: exu-side operations;
+            </nowiki><br />
 [[Instruction_Set/widensf|widensf]] - Double the scalar width of a signed fixed point value.
 <br />
-[[Instruction_Set/widensfv|widensfv]] - Double the scalar widths in a signed fixed point vector.
+[[Instruction_Set/widensf2|widensf2]] - <nowiki>principal op code: widen to double width; arithmetic domain: signed fixed point;
-<br />
+            single vs dual vector result: dual; operation encoding group selector: exu-side
-[[Instruction_Set/widensv|widensv]] - Double the scalar widths in an signed integer vector.
+            operations; </nowiki><br />
-<br />
+[[Instruction_Set/widenu|widenu]] - <nowiki>principal op code: widen to double width; arithmetic domain: unsigned integer;
-[[Instruction_Set/widenu|widenu]] - Alias for [[Instruction_Set/widen|widen]].<br />
+            single vs dual vector result: single; operation encoding group selector: exu-side
+            operations; </nowiki><br />
+[[Instruction_Set/widenu2|widenu2]] - <nowiki>principal op code: widen to double width; arithmetic domain: unsigned integer;
+            single vs dual vector result: dual; operation encoding group selector: exu-side
+            operations; </nowiki><br />
 [[Instruction_Set/widenuf|widenuf]] - Double the scalar width of an unsigned fixed point value.
 <br />
-[[Instruction_Set/widenufv|widenufv]] - Double the scalar widths in an unsigned fixed point vector.
+[[Instruction_Set/widenuf2|widenuf2]] - <nowiki>principal op code: widen to double width; arithmetic domain: unsigned fixed point;
-<br />
+            single vs dual vector result: dual; operation encoding group selector: exu-side
-[[Instruction_Set/widenuv|widenuv]] - Alias for [[Instruction_Set/widenv|widenv]].<br />
+            operations; </nowiki><br />
-[[Instruction_Set/widenv|widenv]] - Double the scalar widths in an unsigned integer vector.
-<br />
 [[Instruction_Set/wr|wr]] - <nowiki>principal op code: hardware writer; arithmetic domain: logical; operation encoding
              group selector: exu-side writers; </nowiki><br />