Difference between revisions of "Instruction Set"

Revision as of 22:16, 5 November 2014

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, Cores, Registers

a

abortAtomic - principal op code: abort an in-progress atomic extent; operation encoding group selector: flow-side operations;
add - This is the basic overflowing integer addition. With 32bit values it defines the Cycle on the Mill architecture.
add1u - principal op code: addition plus 1; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
addd - principal op code: addition; 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 signature kind: belt operand from ops window, belt operand from ops windo
addde - principal op code: addition; 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; operation signature kind: belt operand from ops window, belt operand from ops windo
adddfz - principal op code: addition; 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 signature kind: belt operand from ops window, belt operand from ops windo
adddn - principal op code: addition; 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 kind: belt operand from ops window, belt operand from ops windo
adddp - principal op code: addition; 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 kind: belt operand from ops window, belt operand from ops windo
adddz - principal op code: addition; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
addf - principal op code: addition; 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 signature kind: belt operand from ops window, belt operand from ops windo
addfe - principal op code: addition; 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; operation signature kind: belt operand from ops window, belt operand from ops windo
addffz - principal op code: addition; 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 signature kind: belt operand from ops window, belt operand from ops windo
addfn - principal op code: addition; 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 kind: belt operand from ops window, belt operand from ops windo
addfp - principal op code: addition; 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 kind: belt operand from ops window, belt operand from ops windo
addfz - principal op code: addition; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
addp - principal op code: addition; arithmetic domain: pointers; operation encoding group selector: exu-side operations;
adds - principal op code: addition; arithmetic domain: signed integer; overflow policy: modulo; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, small immediate constant of per-slot varying rang
addss - principal op code: addition; arithmetic domain: signed integer; overflow policy: saturating; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
addssv - principal op code: addition; arithmetic domain: signed integer; overflow policy: saturating; 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 window, belt operand from ops windo
addsv - principal op code: addition; arithmetic domain: signed integer; overflow policy: modulo; 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 window, belt operand from ops windo
addsw - principal op code: addition; arithmetic domain: signed integer; overflow policy: widening; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
addswv - principal op code: addition; 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 window, belt operand from ops windo
addsx - principal op code: addition; arithmetic domain: signed integer; overflow policy: excepting; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
addsxv - principal op code: addition; arithmetic domain: signed integer; overflow policy: excepting; 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 window, small immediate constant of per-slot varying rang
addu - principal op code: addition; arithmetic domain: unsigned integer; overflow policy: modulo; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, small immediate constant of per-slot varying rang
addus - principal op code: addition; arithmetic domain: unsigned integer; overflow policy: saturating; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, small immediate constant of per-slot varying rang
addusv - principal op code: addition; arithmetic domain: unsigned integer; overflow policy: saturating; 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 window, belt operand from ops windo
adduv - principal op code: addition; arithmetic domain: unsigned integer; overflow policy: modulo; 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 window, small immediate constant of per-slot varying rang
adduw - principal op code: addition; arithmetic domain: unsigned integer; overflow policy: widening; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, small immediate constant of per-slot varying rang
adduwv - principal op code: addition; arithmetic domain: unsigned 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 window, belt operand from ops windo
addux - principal op code: addition; arithmetic domain: unsigned integer; overflow policy: excepting; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
adduxv - principal op code: addition; arithmetic domain: unsigned integer; overflow policy: excepting; 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 window, belt operand from ops windo
all - principal op code: vector AND reduction; arithmetic domain: logical; operation encoding group selector: exu-side operations;
allocStack - principal op code: allocate more memory in the current stack frame; operation encoding group selector: flow-side operations;
alternate - principal op code: interlace two vectors; arithmetic domain: logical; operation encoding group selector: exu-side operations;
andl - principal op code: bitwise and; arithmetic domain: logical; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
andls - principal op code: bitwise and; arithmetic domain: signed integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
andlu - principal op code: bitwise and; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
any - principal op code: vector OR reduction; arithmetic domain: logical; operation encoding group selector: exu-side operations;
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

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 - principal op code: branch; sense of condition: taken unconditionally; operation encoding group selector: flow-side operations;
brfl - principal op code: branch; 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;
brtr - principal op code: branch; 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;

c

cachebcl - principal op code: cache control operation; memory sub-operation: Load entire code range to lowest on-chip cache; operation encoding group selector: flow-side operations;
cachebdl - principal op code: cache control operation; memory sub-operation: Load entire data range to lowest on-chip cache; operation encoding group selector: flow-side operations;
cached - principal op code: cache control operation; memory sub-operation: duplicate cache line to new address; operation encoding group selector: flow-side operations; operation signature kind: belt operand from opsWindow, belt operand from opsWindo
cachee - principal op code: cache control operation; memory sub-operation: evict cache line to memory; operation encoding group selector: flow-side operations; operation signature kind: belt operand from opsWindow, belt operand from opsWindo
cachex - principal op code: cache control operation; memory sub-operation: discard cache line without flush; operation encoding group selector: flow-side operations; operation signature kind: belt operand from opsWindo
call - The general purpose unconditional abstract call operations you will be using when writing general assembly code.
call0 - 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;
call1 - 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;
callfl - 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;
callfl0 - 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;
callfl1 - 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;
callfln - 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;
calln - 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;
calltr - 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;
calltr0 - 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;
calltr1 - 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;
calltrn - 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;
carry - principal op code: carry/borrow gang predicate; arithmetic domain: logical; operation encoding group selector: exu-side operations;
classifyd - principal op code: floating point kind; arithmetic domain: decimal floating point; operation encoding group selector: exu-side operations;
classifyf - principal op code: floating point kind; arithmetic domain: binary floating point; operation encoding group selector: exu-side operations;
clear - principal op code: bit reset; arithmetic domain: logical; operation encoding group selector: exu-side operations;
comp - principal op code: bitwise (ones) complement; arithmetic domain: logical; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
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;
conform - principal op code: normalize belt contents to argument list; operation encoding group selector: flow-side operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
countlfl - principal op code: number of bits before condition; shift direction: toward greater significance; arithmetic domain: logical; sense of condition: taken if false; operation encoding group selector: exu-side operations;
countltr - principal op code: number of bits before condition; shift direction: toward greater significance; arithmetic domain: logical; sense of condition: taken if true; operation encoding group selector: exu-side operations;
countrfl - principal op code: number of bits before condition; shift direction: toward lesser significance; arithmetic domain: logical; sense of condition: taken if false; operation encoding group selector: exu-side operations;
countrtr - principal op code: number of bits before condition; shift direction: toward lesser significance; arithmetic domain: logical; sense of condition: taken if true; operation encoding group selector: exu-side operations;

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 - principal op code: distance between pointers; arithmetic domain: logical; operation encoding group selector: exu-side operations;
divd - principal op code: divide for quotient; 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 signature kind: belt operand from ops window, belt operand from ops windo
divde - principal op code: divide for quotient; 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;
divdfz - principal op code: divide for quotient; 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 signature kind: belt operand from ops window, belt operand from ops windo
divdn - principal op code: divide for quotient; 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 kind: belt operand from ops window, belt operand from ops windo
divdp - principal op code: divide for quotient; 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 kind: belt operand from ops window, belt operand from ops windo
divdz - principal op code: divide for quotient; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
divf - principal op code: divide for quotient; 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 signature kind: belt operand from ops window, belt operand from ops windo
divfe - principal op code: divide for quotient; 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;
divffz - principal op code: divide for quotient; 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 signature kind: belt operand from ops window, belt operand from ops windo
divfn - principal op code: divide for quotient; 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 kind: belt operand from ops window, belt operand from ops windo
divfp - principal op code: divide for quotient; 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 kind: belt operand from ops window, belt operand from ops windo
divfz - principal op code: divide for quotient; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
divRems - principal op code: divide for quotient and remainder; arithmetic domain: signed integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
divRemu - principal op code: divide for quotient and remainder; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
divs - principal op code: divide for quotient; arithmetic domain: signed integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
divu - principal op code: divide for quotient; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
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 - principal op code: equal; arithmetic domain: logical; operation encoding group selector: exu-side operations;
eqld - principal op code: equal; arithmetic domain: decimal floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, belt operand from ops windo
eqldx - principal op code: equal; arithmetic domain: decimal floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, belt operand from ops windo
eqlf - principal op code: equal; arithmetic domain: binary floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, belt operand from ops windo
eqlfx - principal op code: equal; arithmetic domain: binary floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, belt operand from ops windo
eqlp - principal op code: equal; arithmetic domain: pointers; operation encoding group selector: exu-side operations;
eqls - principal op code: equal; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
eqlu - principal op code: equal; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;
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;
externalized - 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;
externalizef - 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;
extract - principal op code: extract a scalar element from a vector; operation encoding group selector: exu-side operations;
exuArgs - principal op code: additional slot for ganged exu operation; operation encoding group selector: exu-side operations;

f

f2fd - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: decimal floating point; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations;
f2fde - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: decimal floating point; rounding policy: to nearest, ties toward even adjacent value; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops windo
f2fdfz - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: decimal floating point; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations;
f2fdn - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: decimal floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations;
f2fdp - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: decimal floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations;
f2fdz - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations;
f2ff - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: binary floating point; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations;
f2ffe - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: binary floating point; rounding policy: to nearest, ties toward even adjacent value; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops windo
f2fffz - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: binary floating point; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations;
f2ffn - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: binary floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations;
f2ffp - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: binary floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations;
f2ffz - principal op code: convert binary float to decimal float and vice versa; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations;
f2sd - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sde - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; 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; operation signature kind: belt operand from ops windo
f2sdfz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sdn - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sdp - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sds - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sdse - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; 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; operation signature kind: belt operand from ops windo
f2sdsfz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sdsn - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sdsp - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sdsz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sdx - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sdxe - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; 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; operation signature kind: belt operand from ops windo
f2sdxfz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sdxn - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sdxp - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sdxz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sdz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sed - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sede - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; 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; operation signature kind: belt operand from ops windo
f2sedfz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sedn - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sedp - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2seds - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sedse - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; 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; operation signature kind: belt operand from ops windo
f2sedsfz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sedsn - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sedsp - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sedsz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sedx - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sedxe - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; 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; operation signature kind: belt operand from ops windo
f2sedxfz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sedxn - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sedxp - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sedxz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sedz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sef - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sefe - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; 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; operation signature kind: belt operand from ops windo
f2seffz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sefn - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sefp - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sefs - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sefse - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; 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; operation signature kind: belt operand from ops windo
f2sefsfz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sefsn - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sefsp - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sefsz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sefx - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sefxe - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; 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; operation signature kind: belt operand from ops windo
f2sefxfz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sefxn - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sefxp - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sefxz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sefz - principal op code: convert float to signed integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sf - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sfe - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; 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; operation signature kind: belt operand from ops windo
f2sffz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sfn - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sfp - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sfs - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sfse - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; 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; operation signature kind: belt operand from ops windo
f2sfsfz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sfsn - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sfsp - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sfsz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sfx - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sfxe - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; 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; operation signature kind: belt operand from ops windo
f2sfxfz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2sfxn - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sfxp - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sfxz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2sfz - principal op code: convert float to signed integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2ud - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ude - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; 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; operation signature kind: belt operand from ops windo
f2udfz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2udn - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2udp - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uds - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2udse - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; 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;
f2udsfz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2udsn - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2udsp - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2udsz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2udx - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2udxe - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; 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;
f2udxfz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2udxn - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2udxp - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2udxz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2udz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2ued - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uede - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; 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; operation signature kind: belt operand from ops windo
f2uedfz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uedn - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uedp - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2ueds - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uedse - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; 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; operation signature kind: belt operand from ops windo
f2uedsfz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uedsn - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uedsp - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uedsz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: saturating; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uedx - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uedxe - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; 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; operation signature kind: belt operand from ops windo
f2uedxfz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uedxn - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uedxp - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uedxz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: excepting; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uedz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: decimal floating point; overflow policy: modulo; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uef - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uefe - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; 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; operation signature kind: belt operand from ops windo
f2ueffz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uefn - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uefp - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uefs - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uefse - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; 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; operation signature kind: belt operand from ops windo
f2uefsfz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uefsn - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uefsp - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uefsz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uefx - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uefxe - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; 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; operation signature kind: belt operand from ops windo
f2uefxfz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2uefxn - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uefxp - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uefxz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uefz - principal op code: convert float to unsigned integer; exact result required: exact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2uf - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufe - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; 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; operation signature kind: belt operand from ops windo
f2uffz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufn - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufp - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufs - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufse - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; 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;
f2ufsfz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufsn - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufsp - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufsz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: saturating; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2ufx - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufxe - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; 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; operation signature kind: belt operand from ops windo
f2ufxfz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufxn - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufxp - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
f2ufxz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: excepting; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
f2ufz - principal op code: convert float to unsigned integer; exact result required: inexact; arithmetic domain: binary floating point; overflow policy: modulo; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
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 - principal op code: force an application fault; arithmetic domain: logical; operation encoding group selector: exu-side operations;
fill - principal op code: retore spilled operand from extended scratchpad; operation encoding group selector: flow-side operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
flip - principal op code: bit complement; arithmetic domain: logical; operation encoding group selector: exu-side operations;
flips - principal op code: bit complement; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
flipu - principal op code: bit complement; arithmetic domain: unsigned integer; 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 constan
fmad - principal op code: fused multiply-add or -add/subtract; arithmetic domain: decimal floating point; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations;
fmade - principal op code: fused multiply-add or -add/subtract; arithmetic domain: decimal floating point; rounding policy: to nearest, ties toward even adjacent value; operation encoding group selector: exu-side operations;
fmadfz - principal op code: fused multiply-add or -add/subtract; arithmetic domain: decimal floating point; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations;
fmadn - principal op code: fused multiply-add or -add/subtract; arithmetic domain: decimal floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations;
fmadp - principal op code: fused multiply-add or -add/subtract; arithmetic domain: decimal floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations;
fmadz - principal op code: fused multiply-add or -add/subtract; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations;
fmaf - A floating point fused multiply-add. As usual for those, it yields a higher precision than doing it separately, and is faster too.
fmafe - principal op code: fused multiply-add or -add/subtract; arithmetic domain: binary floating point; rounding policy: to nearest, ties toward even adjacent value; operation encoding group selector: exu-side operations;
fmaffz - principal op code: fused multiply-add or -add/subtract; arithmetic domain: binary floating point; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations;
fmafn - principal op code: fused multiply-add or -add/subtract; arithmetic domain: binary floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations;
fmafp - principal op code: fused multiply-add or -add/subtract; arithmetic domain: binary floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations;
fmafz - principal op code: fused multiply-add or -add/subtract; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations;

g

geq - principal op code: greater than or equal; arithmetic domain: logical; operation encoding group selector: exu-side operations;
geqd - principal op code: greater than or equal; arithmetic domain: decimal floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations;
geqdx - principal op code: greater than or equal; arithmetic domain: decimal floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
geqf - principal op code: greater than or equal; arithmetic domain: binary floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations;
geqfx - principal op code: greater than or equal; arithmetic domain: binary floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
geqp - principal op code: greater than or equal; arithmetic domain: pointers; operation encoding group selector: exu-side operations;
geqs - principal op code: greater than or equal; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
gequ - principal op code: greater than or equal; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;
gtr - principal op code: greater than; arithmetic domain: logical; operation encoding group selector: exu-side operations;
gtrd - principal op code: greater than; arithmetic domain: decimal floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations;
gtrdx - principal op code: greater than; arithmetic domain: decimal floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
gtrf - principal op code: greater than; arithmetic domain: binary floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations;
gtrfx - principal op code: greater than; arithmetic domain: binary floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
gtrp - principal op code: greater than; arithmetic domain: pointers; operation encoding group selector: exu-side operations;
gtrs - principal op code: greater than; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
gtru - principal op code: greater than; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;

i

imp - principal op code: implies; arithmetic domain: logical; operation encoding group selector: exu-side operations;
imps - principal op code: implies; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
impu - principal op code: implies; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;
inject - principal op code: replace a vector element with a scalar; operation encoding group selector: exu-side operations;
inner - principal op code: enter a loop; sense of condition: taken unconditionally; 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;
inner0 - 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;
inner1 - 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;
innerfl - 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;
innerfl0 - 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;
innerfl1 - 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;
innerfln - 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;
innern - 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;
innertr - 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;
innertr0 - 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;
innertr1 - 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;
innertrn - 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;
integerd - principal op code: round to integral-valued float; exact result required: inexact; 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;
integerde - principal op code: round to integral-valued float; exact result required: inexact; 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;
integerdfz - principal op code: round to integral-valued float; exact result required: inexact; 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;
integerdn - principal op code: round to integral-valued float; exact result required: inexact; arithmetic domain: decimal floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
integerdp - principal op code: round to integral-valued float; exact result required: inexact; arithmetic domain: decimal floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
integerdz - principal op code: round to integral-valued float; exact result required: inexact; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
integered - principal op code: round to integral-valued float; exact result required: exact; 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;
integerede - principal op code: round to integral-valued float; exact result required: exact; 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;
integeredfz - principal op code: round to integral-valued float; exact result required: exact; 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;
integeredn - principal op code: round to integral-valued float; exact result required: exact; arithmetic domain: decimal floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
integeredp - principal op code: round to integral-valued float; exact result required: exact; arithmetic domain: decimal floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
integeredz - principal op code: round to integral-valued float; exact result required: exact; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
integeref - principal op code: round to integral-valued float; exact result required: exact; 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;
integerefe - principal op code: round to integral-valued float; exact result required: exact; 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;
integereffz - principal op code: round to integral-valued float; exact result required: exact; 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;
integerefn - principal op code: round to integral-valued float; exact result required: exact; arithmetic domain: binary floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
integerefp - principal op code: round to integral-valued float; exact result required: exact; arithmetic domain: binary floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
integerefz - principal op code: round to integral-valued float; exact result required: exact; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
integerf - principal op code: round to integral-valued float; exact result required: inexact; 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;
integerfe - principal op code: round to integral-valued float; exact result required: inexact; 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;
integerffz - principal op code: round to integral-valued float; exact result required: inexact; 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;
integerfn - principal op code: round to integral-valued float; exact result required: inexact; arithmetic domain: binary floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
integerfp - principal op code: round to integral-valued float; exact result required: inexact; arithmetic domain: binary floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
integerfz - principal op code: round to integral-valued float; exact result required: inexact; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
internalized - principal op code: convert a floating-point number from memory to internal format; arithmetic domain: decimal floating point; operation encoding group selector: flow-side operations;
internalizef - principal op code: convert a floating-point number from memory to internal format; arithmetic domain: binary floating point; operation encoding group selector: flow-side operations;

l

lea - principal op code: load effective address; addressing base: pointer; operation encoding group selector: flow-side operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
left - principal op code: construct a bool vector with N leading false, or count leading false in a bool vector; arithmetic domain: logical; operation encoding group selector: exu-side operations;
leq - principal op code: less than or equal; arithmetic domain: logical; operation encoding group selector: exu-side operations;
leqd - principal op code: less than or equal; arithmetic domain: decimal floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations;
leqdx - principal op code: less than or equal; arithmetic domain: decimal floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
leqf - principal op code: less than or equal; arithmetic domain: binary floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations;
leqfx - principal op code: less than or equal; arithmetic domain: binary floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
leqp - principal op code: less than or equal; arithmetic domain: pointers; operation encoding group selector: exu-side operations;
leqs - principal op code: less than or equal; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
lequ - principal op code: less than or equal; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;
load - principal op code: load from memory; arithmetic domain: logical; addressing base: pointer; operation encoding group selector: flow-side operations; possible manifest sizes in bytes: zero or one constant bytes;
loadd - principal op code: load from memory; arithmetic domain: decimal floating point; addressing base: register; 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, scale factor for indexes in load/store/lea, data width and scalarity (flo
loadf - principal op code: load from memory; arithmetic domain: binary floating point; addressing base: register; 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, scale factor for indexes in load/store/lea, data width and scalarity (flow), morsel-sized manifest constan
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;
lss - principal op code: less than; arithmetic domain: logical; operation encoding group selector: exu-side operations;
lssd - principal op code: less than; arithmetic domain: decimal floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations;
lssdx - principal op code: less than; arithmetic domain: decimal floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
lssf - principal op code: less than; arithmetic domain: binary floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations;
lssfx - principal op code: less than; arithmetic domain: binary floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
lssp - principal op code: less than; arithmetic domain: pointers; operation encoding group selector: exu-side operations;
lsss - principal op code: less than; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
lssu - principal op code: less than; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;

m

mask - principal op code: bitmask conversion between vector of bool and scalar; arithmetic domain: logical; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, data width and scalarity (ex
maxd - principal op code: maximum; arithmetic domain: decimal floating point; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
maxf - principal op code: maximum; arithmetic domain: binary floating point; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
merge - principal op code: bitwise merge; arithmetic domain: logical; operation encoding group selector: exu-side operations;
mind - principal op code: minimum; arithmetic domain: decimal floating point; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
minf - principal op code: minimum; arithmetic domain: binary floating point; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mul - principal op code: multiplication; arithmetic domain: logical; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
muld - principal op code: multiplication; 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 signature kind: belt operand from ops window, belt operand from ops windo
mulde - principal op code: multiplication; 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;
muldfz - principal op code: multiplication; 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 signature kind: belt operand from ops window, belt operand from ops windo
muldn - principal op code: multiplication; 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 kind: belt operand from ops window, belt operand from ops windo
muldp - principal op code: multiplication; 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 kind: belt operand from ops window, belt operand from ops windo
muldz - principal op code: multiplication; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulf - principal op code: multiplication; 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 signature kind: belt operand from ops window, belt operand from ops windo
mulfe - principal op code: multiplication; 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;
mulffz - principal op code: multiplication; 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 signature kind: belt operand from ops window, belt operand from ops windo
mulfn - principal op code: multiplication; 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 kind: belt operand from ops window, belt operand from ops windo
mulfp - principal op code: multiplication; 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 kind: belt operand from ops window, belt operand from ops windo
mulfz - principal op code: multiplication; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
muls - principal op code: multiplication; arithmetic domain: signed integer; overflow policy: modulo; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
mulsf - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: modulo; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfe - principal op code: multiplication; arithmetic domain: signed fixed point; 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;
mulsffz - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: modulo; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfn - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: modulo; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfp - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: modulo; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfs - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: saturating; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfse - principal op code: multiplication; arithmetic domain: signed fixed point; 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;
mulsfsfz - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: saturating; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfsn - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: saturating; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfsp - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: saturating; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfsz - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: saturating; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops window, bit numbe
mulsfw - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: widening; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfwe - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: widening; rounding policy: to nearest, ties toward even adjacent value; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfwfz - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: widening; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfwn - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: widening; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfwp - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: widening; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfwz - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: widening; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops window, bit numbe
mulsfx - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: excepting; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfxe - principal op code: multiplication; arithmetic domain: signed fixed point; 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;
mulsfxfz - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: excepting; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfxn - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: excepting; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfxp - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: excepting; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulsfxz - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: excepting; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops window, bit numbe
mulsfz - principal op code: multiplication; arithmetic domain: signed fixed point; overflow policy: modulo; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops window, bit numbe
mulss - principal op code: multiplication; arithmetic domain: signed integer; overflow policy: saturating; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
mulssv - principal op code: multiplication; arithmetic domain: signed integer; overflow policy: saturating; 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 window, belt operand from ops windo
mulsv - principal op code: multiplication; arithmetic domain: signed integer; overflow policy: modulo; 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 window, belt operand from ops windo
mulsw - principal op code: multiplication; arithmetic domain: signed integer; overflow policy: widening; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
mulswv - principal op code: multiplication; 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 window, belt operand from ops windo
mulsx - principal op code: multiplication; arithmetic domain: signed integer; overflow policy: excepting; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
mulsxv - principal op code: multiplication; arithmetic domain: signed integer; overflow policy: excepting; 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 window, belt operand from ops windo
mulu - principal op code: multiplication; arithmetic domain: unsigned integer; overflow policy: modulo; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
muluf - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: modulo; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufe - principal op code: multiplication; arithmetic domain: unsigned fixed point; 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;
muluffz - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: modulo; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufn - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: modulo; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufp - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: modulo; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufs - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: saturating; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufse - principal op code: multiplication; arithmetic domain: unsigned fixed point; 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;
mulufsfz - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: saturating; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufsn - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: saturating; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufsp - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: saturating; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufsz - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: saturating; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops window, bit numbe
mulufw - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: widening; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufwe - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: widening; rounding policy: to nearest, ties toward even adjacent value; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufwfz - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: widening; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufwn - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: widening; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufwp - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: widening; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufwz - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: widening; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops window, bit numbe
mulufx - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: excepting; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufxe - principal op code: multiplication; arithmetic domain: unsigned fixed point; 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;
mulufxfz - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: excepting; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufxn - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: excepting; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufxp - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: excepting; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
mulufxz - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: excepting; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops window, bit numbe
mulufz - principal op code: multiplication; arithmetic domain: unsigned fixed point; overflow policy: modulo; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops window, bit numbe
mulus - principal op code: multiplication; arithmetic domain: unsigned integer; overflow policy: saturating; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
mulusv - principal op code: multiplication; arithmetic domain: unsigned integer; overflow policy: saturating; 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 window, belt operand from ops windo
muluv - principal op code: multiplication; arithmetic domain: unsigned integer; overflow policy: modulo; 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 window, belt operand from ops windo
muluw - principal op code: multiplication; arithmetic domain: unsigned integer; overflow policy: widening; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
muluwv - principal op code: multiplication; arithmetic domain: unsigned 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 window, belt operand from ops windo
mulux - principal op code: multiplication; arithmetic domain: unsigned integer; overflow policy: excepting; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
muluxv - principal op code: multiplication; arithmetic domain: unsigned integer; overflow policy: excepting; 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 window, belt operand from ops windo

n

nand - principal op code: bitwise complement of and; arithmetic domain: logical; operation encoding group selector: exu-side operations;
nands - principal op code: bitwise complement of and; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
nandu - principal op code: bitwise complement of and; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;
NaR - principal op code: construct and destruct NaRs; arithmetic domain: logical; operation encoding group selector: exu-side operations;
narrow - principal op code: narrow scalar to half width; arithmetic domain: logical; operation encoding group selector: exu-side operations;
narrowd - principal op code: narrow scalar to half width; arithmetic domain: decimal floating point; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations;
narrowde - principal op code: narrow scalar to half width; arithmetic domain: decimal floating point; rounding policy: to nearest, ties toward even adjacent value; operation encoding group selector: exu-side operations;
narrowdfz - principal op code: narrow scalar to half width; arithmetic domain: decimal floating point; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations;
narrowdn - principal op code: narrow scalar to half width; arithmetic domain: decimal floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations;
narrowdp - principal op code: narrow scalar to half width; arithmetic domain: decimal floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations;
narrowdz - principal op code: narrow scalar to half width; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations;
narrowf - principal op code: narrow scalar to half width; arithmetic domain: binary floating point; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations;
narrowfe - principal op code: narrow scalar to half width; arithmetic domain: binary floating point; rounding policy: to nearest, ties toward even adjacent value; operation encoding group selector: exu-side operations;
narrowffz - principal op code: narrow scalar to half width; arithmetic domain: binary floating point; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations;
narrowfn - principal op code: narrow scalar to half width; arithmetic domain: binary floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations;
narrowfp - principal op code: narrow scalar to half width; arithmetic domain: binary floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations;
narrowfz - principal op code: narrow scalar to half width; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations;
narrows - principal op code: narrow scalar to half width; arithmetic domain: signed integer; overflow policy: modulo; operation encoding group selector: exu-side operations;
narrowss - principal op code: narrow scalar to half width; arithmetic domain: signed integer; overflow policy: saturating; operation encoding group selector: exu-side operations;
narrowsx - principal op code: narrow scalar to half width; arithmetic domain: signed integer; overflow policy: excepting; operation encoding group selector: exu-side operations;
narrowu - principal op code: narrow scalar to half width; arithmetic domain: unsigned integer; overflow policy: modulo; operation encoding group selector: exu-side operations;
narrowus - principal op code: narrow scalar to half width; arithmetic domain: unsigned integer; overflow policy: saturating; operation encoding group selector: exu-side operations;
narrowux - principal op code: narrow scalar to half width; arithmetic domain: unsigned integer; overflow policy: excepting; operation encoding group selector: exu-side operations;
neg - principal op code: negate; arithmetic domain: logical; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
negd - principal op code: negate; arithmetic domain: decimal floating point; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
negf - principal op code: negate; arithmetic domain: binary floating point; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
negs - principal op code: negate; arithmetic domain: signed integer; overflow policy: modulo; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
negss - principal op code: negate; arithmetic domain: signed integer; overflow policy: saturating; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
negssv - principal op code: negate; arithmetic domain: signed integer; overflow policy: saturating; 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
negsv - principal op code: negate; arithmetic domain: signed integer; overflow policy: modulo; 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
negsw - principal op code: negate; arithmetic domain: signed integer; overflow policy: widening; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
negswv - 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
negsx - principal op code: negate; arithmetic domain: signed integer; overflow policy: excepting; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
negsxv - principal op code: negate; arithmetic domain: signed integer; overflow policy: excepting; 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
neq - principal op code: not equal; arithmetic domain: logical; operation encoding group selector: exu-side operations;
neqd - principal op code: not equal; arithmetic domain: decimal floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations;
neqdx - principal op code: not equal; arithmetic domain: decimal floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
neqf - principal op code: not equal; arithmetic domain: binary floating point; NaN-awareness: NaN-unaware; operation encoding group selector: exu-side operations;
neqfx - principal op code: not equal; arithmetic domain: binary floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
neqp - principal op code: not equal; arithmetic domain: pointers; operation encoding group selector: exu-side operations;
neqs - principal op code: not equal; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
nequ - principal op code: not equal; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;
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;
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;
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;
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;
nimp - principal op code: bitwise complement of implies; arithmetic domain: logical; operation encoding group selector: exu-side operations;
nimps - principal op code: bitwise complement of implies; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
nimpu - principal op code: bitwise complement of implies; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, belt operand from ops windo
nope - principal op code: no-operation; arithmetic domain: logical; operation encoding group selector: exu-side operations;
nopf - principal op code: no-operation; operation encoding group selector: flow-side operations;
nor - principal op code: bitwise complement of inclusive or; arithmetic domain: logical; operation encoding group selector: exu-side operations;
norddx - principal op code: unordered relation; arithmetic domain: decimal floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
nordfx - principal op code: unordered relation; arithmetic domain: binary floating point; NaN-awareness: NaN-aware; operation encoding group selector: exu-side operations;
nors - principal op code: bitwise complement of inclusive or; arithmetic domain: signed integer; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, belt operand from ops windo
noru - principal op code: bitwise complement of inclusive or; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, belt operand from ops windo
notl - principal op code: logical not; arithmetic domain: logical; operation encoding group selector: exu-side operations;
notls - principal op code: logical not; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
notlu - principal op code: logical not; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;
nxor - principal op code: bitwise complement of exclusive or; arithmetic domain: logical; operation encoding group selector: exu-side operations;
nxors - principal op code: bitwise complement of exclusive or; arithmetic domain: signed integer; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, belt operand from ops windo
nxoru - principal op code: bitwise complement of exclusive or; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, belt operand from ops windo

o

ones - principal op code: count of one-bits; arithmetic domain: logical; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
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 - principal op code: bitwise inclusive or; arithmetic domain: logical; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
orls - principal op code: bitwise inclusive or; arithmetic domain: signed integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
orlu - principal op code: bitwise inclusive or; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
overflows - principal op code: overflow gang predicate; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
overflowu - principal op code: overflow gang predicate; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;

p

pick - principal op code: pick; arithmetic domain: logical; operation encoding group selector: exu-side picks;
pickup - principal op code: accept a speculative load; arithmetic domain: logical; 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;
rdivd - principal op code: reciprocal divide; arithmetic domain: decimal floating point; operation encoding group selector: exu-side operations;
rdivf - principal op code: reciprocal divide; arithmetic domain: binary floating point; operation encoding group selector: exu-side operations;
rdivs - principal op code: reciprocal divide; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
rdivu - principal op code: reciprocal divide; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;
recur - principal op code: recurnce update; arithmetic domain: logical; operation encoding group selector: exu-side picks;
refuse - principal op code: reject a speculative load; arithmetic domain: logical; operation encoding group selector: exu-side readers;
remd - principal op code: divide for remainder; arithmetic domain: decimal floating point; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
remf - principal op code: divide for remainder; arithmetic domain: binary floating point; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
rems - principal op code: divide for remainder; arithmetic domain: signed integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
remu - principal op code: divide for remainder; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
rescue - principal op code: copy arguments to front of belt; 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
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 - principal op code: return from function; sense of condition: taken unconditionally; operation encoding group selector: flow-side operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
retnfl - principal op code: return from function; 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;
retntr - 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;
reverse - principal op code: bit reverse; arithmetic domain: logical; operation encoding group selector: exu-side operations;
reversep - principal op code: bit reverse; arithmetic domain: pointers; operation encoding group selector: exu-side operations;
rootd - principal op code: square root; 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 signature kind: belt operand from ops windo
rootde - principal op code: 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; operation signature kind: belt operand from ops windo
rootdfz - principal op code: 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; operation signature kind: belt operand from ops windo
rootdn - principal op code: 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; operation signature kind: belt operand from ops windo
rootdp - principal op code: 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; operation signature kind: belt operand from ops windo
rootdz - principal op code: square root; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
rootf - principal op code: square root; 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 signature kind: belt operand from ops windo
rootfe - principal op code: 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; operation signature kind: belt operand from ops windo
rootffz - principal op code: 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; operation signature kind: belt operand from ops windo
rootfn - principal op code: 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; operation signature kind: belt operand from ops windo
rootfp - principal op code: 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; operation signature kind: belt operand from ops windo
rootfz - principal op code: square root; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
roots - principal op code: square root; arithmetic domain: signed integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
rootu - principal op code: square root; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
rotate - principal op code: bitwise rotate; arithmetic domain: logical; operation encoding group selector: exu-side readers;
rotatel - principal op code: bitwise rotate; shift direction: toward greater significance; arithmetic domain: logical; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
rotater - principal op code: bitwise rotate; shift direction: toward lesser significance; arithmetic domain: logical; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
rrootd - principal op code: reciprocal square root; arithmetic domain: decimal floating point; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops windo
rrootf - principal op code: reciprocal square root; arithmetic domain: binary floating point; operation encoding group selector: exu-side operations;
rroots - principal op code: reciprocal square root; arithmetic domain: signed integer; operation encoding group selector: exu-side operations;
rrootu - principal op code: reciprocal square root; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations;

s

s2fd - principal op code: convert signed integer to float; 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;
s2fde - principal op code: convert signed integer to float; 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;
s2fdfz - principal op code: convert signed integer to float; 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;
s2fdn - principal op code: convert signed integer to float; arithmetic domain: decimal floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
s2fdp - principal op code: convert signed integer to float; arithmetic domain: decimal floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
s2fdz - principal op code: convert signed integer to float; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
s2ff - principal op code: convert signed integer to float; 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;
s2ffe - principal op code: convert signed integer to float; 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;
s2fffz - principal op code: convert signed integer to float; 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;
s2ffn - principal op code: convert signed integer to float; arithmetic domain: binary floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
s2ffp - principal op code: convert signed integer to float; arithmetic domain: binary floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
s2ffz - principal op code: convert signed integer to float; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
s2u - principal op code: convert signed to unsigned; arithmetic domain: logical; overflow policy: modulo; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops windo
s2us - principal op code: convert signed to unsigned; arithmetic domain: logical; overflow policy: saturating; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops windo
s2ux - principal op code: convert signed to unsigned; arithmetic domain: logical; overflow policy: excepting; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops windo
sameQuantumd - principal op code: same exponent; arithmetic domain: decimal floating point; operation encoding group selector: exu-side operations;
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; operation signature kind: belt operand from ops window, belt operand from ops windo
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;
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; operation signature kind: belt operand from ops window, belt operand from ops windo
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; operation signature kind: belt operand from ops window, belt operand from ops windo
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; operation signature kind: belt operand from ops window, belt operand from ops windo
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;
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; operation signature kind: belt operand from ops window, belt operand from ops windo
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;
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; operation signature kind: belt operand from ops window, belt operand from ops windo
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; operation signature kind: belt operand from ops window, belt operand from ops windo
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; operation signature kind: belt operand from ops window, belt operand from ops windo
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;
scratchf - principal op code: allocate scratchpad frame; arithmetic domain: logical; operation encoding group selector: exu-side readers;
set - principal op code: bit set; arithmetic domain: logical; operation encoding group selector: exu-side operations;
shiftl - Bitwise left shift.
shiftls - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: signed integer; overflow policy: modulo; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftlss - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: signed integer; overflow policy: saturating; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftlssv - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: signed integer; overflow policy: saturating; scalar vs. vector data: vector; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftlsv - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: signed integer; overflow policy: modulo; scalar vs. vector data: vector; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftlsw - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: signed integer; overflow policy: widening; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftlswv - principal op code: bitwise shift; shift direction: toward greater significance; 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;
shiftlsx - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: signed integer; overflow policy: excepting; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftlsxv - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: signed integer; overflow policy: excepting; scalar vs. vector data: vector; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftlu - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: unsigned integer; overflow policy: modulo; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftlus - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: unsigned integer; overflow policy: saturating; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftlusv - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: unsigned integer; overflow policy: saturating; scalar vs. vector data: vector; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftluv - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: unsigned integer; overflow policy: modulo; scalar vs. vector data: vector; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftluw - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: unsigned integer; overflow policy: widening; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftluwv - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: unsigned integer; overflow policy: widening; scalar vs. vector data: vector; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftlux - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: unsigned integer; overflow policy: excepting; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftluxv - principal op code: bitwise shift; shift direction: toward greater significance; arithmetic domain: unsigned integer; overflow policy: excepting; scalar vs. vector data: vector; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftrs - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: signed integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
shiftrsf - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: signed fixed point; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftrsfe - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: signed fixed point; rounding policy: to nearest, ties toward even adjacent value; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftrsffz - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: signed fixed point; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftrsfn - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: signed fixed point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftrsfp - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: signed fixed point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftrsfz - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: signed fixed point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftru - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, bit numbe
shiftruf - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: unsigned fixed point; rounding policy: use current dynamic rounding mode; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftrufe - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: unsigned fixed point; rounding policy: to nearest, ties toward even adjacent value; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftruffz - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: unsigned fixed point; rounding policy: to nearest, ties away from zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftrufn - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: unsigned fixed point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftrufp - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: unsigned fixed point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shiftrufz - principal op code: bitwise shift; shift direction: toward lesser significance; arithmetic domain: unsigned fixed point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
shuffle - principal op code: reorder a vector; arithmetic domain: logical; operation encoding group selector: exu-side operations;
smeari - principal op code: smear first one to end of vector; arithmetic domain: logical; whether inclusive or exclusive of boundary: inclusive; operation encoding group selector: exu-side operations;
smearx - principal op code: smear first one to end of vector; arithmetic domain: logical; whether inclusive or exclusive of boundary: exclusive; operation encoding group selector: exu-side operations;
spill - principal op code: spill operand to extended scratchpad; operation encoding group selector: flow-side operations; possible manifest sizes in bytes: zero, one, two, or four constant bytes;
splat - principal op code: replicate scalar to vector; arithmetic domain: logical; operation encoding group selector: exu-side operations;
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 - principal op code: store to memory; arithmetic domain: logical; operation encoding group selector: flow-side operations; possible manifest sizes in bytes: zero or one constant bytes;
stored - principal op code: store to memory; arithmetic domain: decimal floating point; addressing base: register; 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, scale factor for indexes in load/store/lea, late-evaluated operand from bel
storef - principal op code: store to memory; arithmetic domain: binary floating point; operation encoding group selector: flow-side operations; possible manifest sizes in bytes: zero or one constant bytes;
storep - principal op code: store to memory; arithmetic domain: pointers; operation encoding group selector: flow-side operations; possible manifest sizes in bytes: zero or one constant bytes;
streamf - principal op code: allocate streamer frame; operation encoding group selector: flow-side operations;
sub - Normal unsigned substraction.
sub1u - principal op code: subtraction minus 1; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
subd - principal op code: subtraction; 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 signature kind: belt operand from ops window, belt operand from ops windo
subde - principal op code: subtraction; 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; operation signature kind: belt operand from ops window, belt operand from ops windo
subdfz - principal op code: subtraction; 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 signature kind: belt operand from ops window, belt operand from ops windo
subdn - principal op code: subtraction; 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 kind: belt operand from ops window, belt operand from ops windo
subdp - principal op code: subtraction; 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 kind: belt operand from ops window, belt operand from ops windo
subdz - principal op code: subtraction; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
subf - principal op code: subtraction; 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 signature kind: belt operand from ops window, belt operand from ops windo
subfe - principal op code: subtraction; 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; operation signature kind: belt operand from ops window, belt operand from ops windo
subffz - principal op code: subtraction; 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 signature kind: belt operand from ops window, belt operand from ops windo
subfn - principal op code: subtraction; 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 kind: belt operand from ops window, belt operand from ops windo
subfp - principal op code: subtraction; 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 kind: belt operand from ops window, belt operand from ops windo
subfz - principal op code: subtraction; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
subp - principal op code: subtraction; arithmetic domain: pointers; operation encoding group selector: exu-side operations;
subs - principal op code: subtraction; arithmetic domain: signed integer; overflow policy: modulo; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
subss - principal op code: subtraction; arithmetic domain: signed integer; overflow policy: saturating; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
subssv - principal op code: subtraction; arithmetic domain: signed integer; overflow policy: saturating; 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 window, belt operand from ops windo
subsv - principal op code: subtraction; arithmetic domain: signed integer; overflow policy: modulo; 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 window, belt operand from ops windo
subsw - principal op code: subtraction; arithmetic domain: signed integer; overflow policy: widening; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
subswv - principal op code: subtraction; 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 window, belt operand from ops windo
subsx - principal op code: subtraction; arithmetic domain: signed integer; overflow policy: excepting; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
subsxv - principal op code: subtraction; arithmetic domain: signed integer; overflow policy: excepting; 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 window, small immediate constant of per-slot varying rang
subu - principal op code: subtraction; arithmetic domain: unsigned integer; overflow policy: modulo; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, small immediate constant of per-slot varying rang
subus - principal op code: subtraction; arithmetic domain: unsigned integer; overflow policy: saturating; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
subusv - principal op code: subtraction; arithmetic domain: unsigned integer; overflow policy: saturating; 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 window, belt operand from ops windo
subuv - principal op code: subtraction; arithmetic domain: unsigned integer; overflow policy: modulo; 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 window, belt operand from ops windo
subuw - principal op code: subtraction; arithmetic domain: unsigned integer; overflow policy: widening; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
subuwv - principal op code: subtraction; arithmetic domain: unsigned 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 window, belt operand from ops windo
subux - principal op code: subtraction; arithmetic domain: unsigned integer; overflow policy: excepting; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops window, belt operand from ops windo
subuxv - principal op code: subtraction; arithmetic domain: unsigned integer; overflow policy: excepting; 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 window, belt operand from ops windo

t

test - principal op code: bit test; arithmetic domain: logical; operation encoding group selector: exu-side operations;

u

u2fd - principal op code: convert unsigned integer to float; 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;
u2fde - principal op code: convert unsigned integer to float; 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;
u2fdfz - principal op code: convert unsigned integer to float; 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;
u2fdn - principal op code: convert unsigned integer to float; arithmetic domain: decimal floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
u2fdp - principal op code: convert unsigned integer to float; arithmetic domain: decimal floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
u2fdz - principal op code: convert unsigned integer to float; arithmetic domain: decimal floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
u2ff - principal op code: convert unsigned integer to float; 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;
u2ffe - principal op code: convert unsigned integer to float; 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;
u2fffz - principal op code: convert unsigned integer to float; 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;
u2ffn - principal op code: convert unsigned integer to float; arithmetic domain: binary floating point; rounding policy: toward negative infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
u2ffp - principal op code: convert unsigned integer to float; arithmetic domain: binary floating point; rounding policy: toward positive infinity; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
u2ffz - principal op code: convert unsigned integer to float; arithmetic domain: binary floating point; rounding policy: toward zero; operation encoding group selector: exu-side operations; condition code generator: generate condition codes; operation signature kind: belt operand from ops windo
u2s - principal op code: convert unsigned to signed; arithmetic domain: logical; overflow policy: modulo; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations;
u2ss - principal op code: convert unsigned to signed; arithmetic domain: logical; overflow policy: saturating; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations;
u2ssv - principal op code: convert unsigned to signed; arithmetic domain: logical; overflow policy: saturating; scalar vs. vector data: vector; operation encoding group selector: exu-side operations;
u2sv - principal op code: convert unsigned to signed; arithmetic domain: logical; overflow policy: modulo; scalar vs. vector data: vector; operation encoding group selector: exu-side operations;
u2sw - principal op code: convert unsigned to signed; arithmetic domain: logical; overflow policy: widening; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations;
u2swv - principal op code: convert unsigned to signed; arithmetic domain: logical; overflow policy: widening; scalar vs. vector data: vector; operation encoding group selector: exu-side operations;
u2sx - principal op code: convert unsigned to signed; arithmetic domain: logical; overflow policy: excepting; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations;
u2sxv - principal op code: convert unsigned to signed; arithmetic domain: logical; overflow policy: excepting; scalar vs. vector data: vector; operation encoding group selector: exu-side operations;

v

vec - principal op code: vector constructor; arithmetic domain: logical; operation encoding group selector: exu-side operations;

w

widen - principal op code: widen to double width; arithmetic domain: logical; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, belt operand from ops windo
widend - principal op code: widen to double width; arithmetic domain: decimal floating point; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations;
widendv - principal op code: widen to double width; arithmetic domain: decimal floating point; scalar vs. vector data: vector; operation encoding group selector: exu-side operations;
widenf - principal op code: widen to double width; arithmetic domain: binary floating point; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations;
widenfv - principal op code: widen to double width; arithmetic domain: binary floating point; scalar vs. vector data: vector; operation encoding group selector: exu-side operations;
widens - principal op code: widen to double width; arithmetic domain: signed integer; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations;
widensf - principal op code: widen to double width; arithmetic domain: signed fixed point; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations;
widensfv - principal op code: widen to double width; arithmetic domain: signed fixed point; scalar vs. vector data: vector; operation encoding group selector: exu-side operations;
widensv - principal op code: widen to double width; arithmetic domain: signed integer; scalar vs. vector data: vector; operation encoding group selector: exu-side operations;
widenu - principal op code: widen to double width; arithmetic domain: unsigned integer; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations;
widenuf - principal op code: widen to double width; arithmetic domain: unsigned fixed point; scalar vs. vector data: scalar; operation encoding group selector: exu-side operations;
widenufv - principal op code: widen to double width; arithmetic domain: unsigned fixed point; scalar vs. vector data: vector; operation encoding group selector: exu-side operations;
widenuv - principal op code: widen to double width; arithmetic domain: unsigned integer; scalar vs. vector data: vector; operation encoding group selector: exu-side operations;
widenv - principal op code: widen to double width; arithmetic domain: logical; scalar vs. vector data: vector; operation encoding group selector: exu-side operations; operation signature kind: belt operand from ops window, belt operand from ops windo
wr - principal op code: hardware writer; arithmetic domain: logical; operation encoding group selector: exu-side writers;

x

xorl - principal op code: bitwise exclusive or; arithmetic domain: logical; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
xorls - principal op code: bitwise exclusive or; arithmetic domain: signed integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;
xorlu - principal op code: bitwise exclusive or; arithmetic domain: unsigned integer; operation encoding group selector: exu-side operations; condition code generator: generate condition codes;

@@ Line 2,156: / Line 2,156: @@
 [[Instruction_Set/set|set]] - <nowiki>principal op code: bit set; arithmetic domain: logical; operation encoding group
              selector: exu-side operations; </nowiki><br />
-[[Instruction_Set/shiftl|shiftl]] - <nowiki>principal op code: bitwise shift; shift direction: toward greater significance;
+[[Instruction_Set/shiftl|shiftl]] - Bitwise left shift.
-            arithmetic domain: logical; operation encoding group selector: exu-side operations;
+<br />
-            </nowiki><br />
 [[Instruction_Set/shiftls|shiftls]] - <nowiki>principal op code: bitwise shift; shift direction: toward greater significance;
              arithmetic domain: signed integer; overflow policy: modulo; scalar vs. vector data:

Difference between revisions of "Instruction Set"

Revision as of 22:16, 5 November 2014

Navigation menu

Personal tools

Namespaces

Variants

Views

Actions

Search

Navigation

Tools