instruction_list.csv

Instruction list for ForwardCom instruction set. Version 1.13. 2024-08-06,,,,,,,,,,,,,
Name,Id,Category,Formats,Template,Template variant,Source operands,OP1,OP2,Operand types general purpose registers,Operand types scalar,Operand types vectors,Immediate operand type,Description
nop,0x30000,3,0x00000FFF,0,D0,0,0,0,0x000F,0xFF,0,0,no operation
nop2,0x30200,3,0xFFFFF000,0,D0,0,0,0,0x000F,0xFF,0,0,no operation
nop3,0x30300,3,0xFFFFF00000000,0,D0,0,0,0,0x000F,0xFF,0,0,no operation
store,1,3,0xA0900F0FA3F0,0,M0F0,1,1,0,0x000F,0x906F,0x906F,0,store value of register to memory
move,2,3,-1,0,,1,2,0,0x000F,0x906F,0x906F,0,copy value to register
prefetch,3,3,0xA0900F0FA3F0,0,D1O4,1,3,0,0x000F,0x906F,0x906F,0,prefetch to cache
sign_extend,4,3,-1,0,,1,4,0,0x0007,0x0007,0x0007,0,sign extend to 64 bits
sign_extend_add,5,3,-1,0,O6,2,5,0,0x0F00,0,0,0,"sign extend to 64 bits, scale, and add 64 bit register"
compare_h,0x50007,3,-1,0,O6U3H0F1,2,6,0,0,0x0200,0x0200,0,"compare two operands, return condition code"
compare,7,3,-1,0,O6U3F1,2,7,0,0x000F,0x906F,0x906F,0,"compare two operands, return condition code"
add,8,3,-1,0,,2,8,0,0x000F,0x906F,0x906F,0,addition
sub,9,3,-1,0,,2,9,0,0x000F,0x906F,0x906F,0,subtraction
sub_rev,10,3,-1,0,,2,10,0,0x000F,0x906F,0x906F,0,subtraction. Operands swapped
mul,11,3,-1,0,,2,11,0,0x000F,0x906F,0x9867,0,multiply (low part of result for integer operands)
mul_hi,12,3,-1,0,,2,12,0,0x0B04,0x1B04,0x1F00,0,"multiply signed integers, high part of result"
mul_hi_u,13,3,-1,0,U0,2,13,0,0x0B04,0x1B04,0x1F00,0,"multiply unsigned integers, high part of result"
div,14,3,-1,0,O6H5,2,14,0,0x000F,0x906F,0x9867,0,division
div_u,15,3,-1,0,O4U0,2,15,0,0x000F,0x100F,0x100F,0,unsigned integer division
div_rev,16,3,-1,0,O6H5,2,16,0,0x000F,0x906F,0xFF00,0,division. Operands swapped
div_rev_u,17,3,-1,0,O4U0,2,17,0,0x000F,0x906F,0xFF00,0,unsigned integer division. Operands swapped
rem,18,3,-1,0,,2,18,0,0x000F,0x906F,0xFF00,0,"remainder or modulo, signed"
rem_u,19,3,-1,0,U0,2,19,0,0x000F,0x000F,0x0F00,0,remainder or modulo for unsigned integers
min,20,3,-1,0,O6U3H5,2,20,0,0x000F,0x906F,0x906F,0,minimum of two numbers
max,21,3,-1,0,O6U3H5,2,21,0,0x000F,0x906F,0x906F,0,maximum of two numbers
and,26,3,-1,0,,2,26,0,0x000F,0x906F,0x906F,0,bitwise and
or,27,3,-1,0,,2,27,0,0x000F,0x906F,0x906F,0,bitwise and
xor,28,3,-1,0,,2,28,0,0x000F,0x906F,0x906F,0,bitwise exclusive or
shift_left,32,3,0x7F7F0FFFFAFFF,0,I2,2,32,0,0x100F,0x100F,0x100F,0,shift integer bits left
mul_pow2,32,3,0x7F7F0FFFFAFFF,0,I2,2,32,0,0x0000,0x8060,0x8060,0,Multiply float by integer power of 2
rotate,33,3,0x7F7F0FFFFAFFF,0,I2,2,33,0,0x100F,0x100F,0x100F,0,"rotate bits left if src2 positive, right if negative"
shift_right_s,34,3,0x7F7F0FFFFAFFF,0,I2,2,34,0,0x100F,0x100F,0x100F,0,shift integer bits right with sign extension
shift_right_u,35,3,0x7F7F0FFFFAFFF,0,I2U0,2,35,0,0x100F,0x100F,0x100F,0,shift integer bits right with sign extension
clear_bit,36,3,0x7F7F0FFFFAFFF,0,I2,2,36,0,0x000F,0x906F,0x906F,0,clear single bit
set_bit,37,3,0x7F7F0FFFFAFFF,0,I2,2,37,0,0x000F,0x906F,0x906F,0,set single bit
toggle_bit,38,3,0x7F7F0FFFFAFFF,0,I2,2,38,0,0x000F,0x906F,0x906F,0,toggle single bit
test_bit,39,3,-1,0,O5F1I2,2,39,0,0x000F,0x906F,0x906F,0,test one bit
test_bits_and,40,3,-1,0,O5F1I2,2,40,0,0x000F,0x906F,0x906F,0,test if all the indicated bits are one
test_bits_or,41,3,-1,0,O5F1I2,2,41,0,0x000F,0x906F,0x906F,0,test if at least one of the indicated bits is one
add_h,0x50008,3,-1,0,H0,2,44,0,0,0x0200,0x0200,0,add half precision floating point vectors
sub_h,0x50009,3,-1,0,H0,2,45,0,0,0x0200,0x0200,0,subtract half precision floating point vectors
mul_h,0x5000B,3,-1,0,H0,2,46,0,0,0x0200,0x0200,0,multiply half precision floating point vectors
mul_add,49,3,0xFFFFFFFFF700F,0,O6H5,3,49,0,0x0F00,0xFF00,0xFF00,0,"src1+src2*src3. Fused multiply and add, optional sign change"
mul_add2,50,3,0xFFFFFFFFF700F,0,O6H5,3,50,0,0x0F00,0xFF00,0xFF00,0,"src1*src2+src3. Fused multiply and add, optional sign change"
add_add,51,3,0xFFFFFFFFF700F,0,O3,3,51,0,0x0F00,0xFF00,0xFF00,0,"src1+src2+src3. Three operand add, optional sign change"
select_bits,52,3,0x7F7F0FFFF700F,0,I2,3,52,0,0x000F,0x906F,0x906F,,"combine bits from two operands, using third operand as selector"
funnel_shift,53,3,0x7F7F0FFFF700F,0,I2,3,53,0,0x100F,0x100F,0x100F,0,concatenate two bit fields and shift right
userdef55,55,3,-1,0,,2,55,0,0x000F,0x906F,0x906F,0,user defined instruction
userdef56,56,3,-1,0,,2,56,0,0x000F,0x906F,0x906F,0,user defined instruction
userdef57,57,3,-1,0,,2,57,0,0x000F,0x906F,0x906F,0,user defined instruction
userdef58,58,3,-1,0,,2,58,0,0x000F,0x906F,0x906F,0,user defined instruction
userdef59,59,3,-1,0,,2,59,0,0x000F,0x906F,0x906F,0,user defined instruction
userdef60,60,3,-1,0,,2,60,0,0x000F,0x906F,0x906F,0,user defined instruction
userdef61,61,3,-1,0,,2,61,0,0x000F,0x906F,0x906F,0,user defined instruction
userdef62,62,3,-1,0,,2,62,0,0x000F,0x906F,0x906F,0,user defined instruction
undef,63,3,-1,0,D0,2,63,0,0x000F,0x00FF,0x00FF,0,undefined instruction. will never be defined
move,2,1,0x110,0xC,,1,0,0,0x0004,0,0,3,copy 16-bit sign extended constant to register
move,2,1,0x110,0xC,,1,1,0,0x0008,0,0,3,copy 16-bit sign extended constant to register
move,2,1,0x110,0xC,U0,1,3,0,0x0008,0,0,19,copy 16-bit zero extended constant to register
move,2,1,0x110,0xC,,1,4,0,0x0004,0,0,6,sign-extend IM2 to 32 bits and shift left by unsigned constant IM1
move,2,1,0x110,0xC,,1,5,0,0x0008,0,0,6,sign-extend IM2 to 64 bits and shift left by unsigned constant IM1
add,8,1,0x110,0xC,,2,6,0,0x0004,0,0,3,add 16-bit sign extended constant to register
mul,11,1,0x110,0xC,,2,8,0,0x0004,0,0,3,multiply 16-bit sign extended constant with register
add,8,1,0x110,0xC,,2,10,0,0x0004,0,0,6,sign-extend IM2 to 32 bits and shift left by unsigned constant IM1 and add to register
add,8,1,0x110,0xC,,2,11,0,0x0008,0,0,6,sign-extend IM2 to 64 bits and shift left by unsigned constant IM1 and add to register
and,26,1,0x110,0xC,,2,12,0,0x0004,0,0,6,sign-extend IM2 to 32 bits and shift left by unsigned constant IM1 and do bitwise AND with register
and,26,1,0x110,0xC,,2,13,0,0x0008,0,0,6,sign-extend IM2 to 64 bits and shift left by unsigned constant IM1 and do bitwise AND with register
or,27,1,0x110,0xC,,2,14,0,0x0004,0,0,6,sign-extend IM2 to 32 bits and shift left by unsigned constant IM1 and do bitwise OR with register
or,27,1,0x110,0xC,,2,15,0,0x0008,0,0,6,sign-extend IM2 to 64 bits and shift left by unsigned constant IM1 and do bitwise OR with register
xor,28,1,0x110,0xC,,2,16,0,0x0004,0,0,6,sign-extend IM2 to 32 bits and shift left by unsigned constant IM1 and do bitwise exclusive OR with register
xor,28,1,0x110,0xC,,2,17,0,0x0008,0,0,6,sign-extend IM2 to 64 bits and shift left by unsigned constant IM1 and do bitwise exclusive OR with register
add,8,1,0x110,0xC,,2,18,0,0x0004,0,0,8,shift 16-bit zero extended constant left by 16 and add to 32 bit register
abs,0xA0000,1,0x180,0xB,,2,0,0,0x100F,0,0,18,absolute value of integer. use saturation if IM1 = 1
bitscan,0x10001,1,0x180,0xB,,2,2,0,0x100F,0,0,18,bit scan forward or reverse. Find index first or last set bit 
popcount,0x13018,1,0x180,0xB,,2,4,0,0x100F,0,0,i0,population count. number of bits that are 1
roundp2,0x10003,1,0x180,0xB,,2,3,0,0x100F,0,0,18,round up or down to nearest power of 2
read_spec,0x18020,1,0x180,0xB,X1,2,32,0,0x1708,0,0,i0,read special register into general purpose register
read_spec,0x18020,1,0x180,0xB,X1,2,32,0,0x1708,0,0,18,read special register into general purpose register
write_spec,0x18021,1,0x180,0xB,Y1,2,33,0,0x1708,0,0,i0,write general purpose register to special register
write_spec,0x18021,1,0x180,0xB,Y1,2,33,0,0x1708,0,0,18,write general purpose register to special register
read_capabilities,0x18022,1,0x180,0xB,X2,2,34,0,0x1708,0,0,18,read capabilities register into general purpose register
write_capabilities,0x18023,1,0x180,0xB,Y2,2,35,0,0x1708,0,0,18,write general purpose register to capabilities register
read_perf,0x18024,1,0x180,0xB,X3,2,36,0,0x1708,0,0,18,read performance counter into general purpose register
read_perfs,0x18025,1,0x180,0xB,X3,2,37,0,0x1708,0,0,18,"read performance counter into general purpose register, serializing"
read_sys,0x18026,1,0x180,0xB,X4,2,38,0,0x1708,0,0,18,read system register into general purpose register
write_sys,0x18027,1,0x180,0xB,Y4,2,39,0,0x1708,0,0,18,write general purpose register to system register
push,0x18038,1,0x180,0xB,D3,3,56,0,0xFF00,0,0,18,push one or more g.p. registers to stack pointed to by rd
pop,0x18039,1,0x180,0xB,D3,3,57,0,0xFF00,0,0,18,pop one or more g.p. registers from stack pointed to by rd
input,0x1803E,1,0x180,0xB,,2,62,0,0x100F,0,0,18,read from input port. RS or IM1 = port address
output,0x1803F,1,0x180,0xB,D1,3,63,0,0x100F,0,0,18,"write to output port. RD = source operand, RS or IM1 = port address"
move_bits,0x28700,1,0x207,0xE,O6I2,3,0,1,0x1F00,0,0,25,extract bitfield from one operand and insert it at another position in another operand
move,2,1,0x290,0xA,,1,0,0,0x0008,0,0,9,load 32-bit constant into high part of general purpose register. low part is zero
insert_hi,0x29001,1,0x290,0xA,,2,1,0,0x0008,0,0,20,insert 32-bit constant into high part of general purpose register. low part is unchanged
add,8,1,0x290,0xA,,2,2,0,0x0008,0,0,20,Add zero-extended 32-bit constant to general purpose register
sub,9,1,0x290,0xA,,2,3,0,0x0008,0,0,20,Subtract zero-extended 32-bit constant from general purpose register
add,8,1,0x290,0xA,,2,4,0,0x0008,0,0,9,shift 32-bit constant left by 32 and add to register
and,26,1,0x290,0xA,,2,5,0,0x0008,0,0,9,shift 32-bit constant left by 32 and do a bitwise AND with register
or,27,1,0x290,0xA,,2,6,0,0x0008,0,0,9,shift 32-bit constant left by 32 and do a bitwise OR with register
xor,28,1,0x290,0xA,,2,7,0,0x0008,0,0,9,shift 32-bit constant left by 32 and do a bitwise exclusive OR with register
address,0x29020,1,0x291,0xA,X0,1,32,0,0x000E,0,0,0,"add signed constant to pointer register. can be DATAP, IP, SP"
get_len,0x12001,1,0x120,0xA,R0,1,0,0,0,0x906F,0x906F,0,get length of vector as number of bytes
get_num,0x12003,1,0x120,0xA,R0,1,1,0,0,0x906F,0x906F,0,get length of vector as number of elements
set_len,0x12000,1,0x120,0xA,RL,2,2,0,0,0x906F,0x906F,0,change length of vector to specified number of bytes
set_num,0x12002,1,0x120,0xA,RL,2,3,0,0,0x906F,0x906F,0,change length of vector to specified number of elements
insert,0x1200C,1,0x120,0xA,R3,3,4,0,0,0x00FF,0x00FF,0,insert one element into vector. other elements are unchanged
extract,0x1200B,1,0x120,0xA,R2,2,5,0,0,0x00FF,0x00FF,0,extract one element from vector into a scalar
broad,0x1200D,1,0x120,0xA,RL,2,6,0,0,0x00FF,0x00FF,0,broadcast first element of source vector into all elements of destination vector
compress_sparse,0x12009,1,0x120,0xA,F0,1,8,0,0,0xFF00,0xFF00,0,compress sparse vector elements indicated by mask bits into contiguous vector
expand_sparse,0x1200A,1,0x120,0xA,RLF0,2,9,0,0,0xFF00,0xFF00,0,expand contiguous vector into sparse vector with positions indicated by mask bits
bits2bool,0x1200E,1,0x120,0xA,RL,2,12,0,0,0x906F,0x906F,0,unpack bits to boolean vector
shift_expand,0x12012,1,0x120,0xA,R2,2,16,0,0,0x00FF,0x00FF,0,shift vector bytes up. destination vector will be longer with lower half zero
shift_reduce,0x12013,1,0x120,0xA,R2,2,17,0,0,0x00FF,0x00FF,0,shift vector bytes down. destination vector will be shorter with lower part lost
shift_up,0x12014,1,0x120,0xA,R2,2,18,0,0,0x906F,0x906F,0,shift vector elements up. upper elements are lost
shift_down,0x12015,1,0x120,0xA,R2,2,19,0,0,0x906F,0x906F,0,shift vector elements down. lower elements are lost
div_ex,0x12018,1,0x120,0xA,,2,24,0,0,0x1906,0x1F00,0,divide double-size signed integers with single-size integers. save quotient and remainder
div_ex_u,0x12019,1,0x120,0xA,U0,2,25,0,0,0x1906,0x1F00,0,divide double-size unsigned integers with single-size integers. save quotient and remainder
mul_ex,0x1201A,1,0x120,0xA,,2,26,0,0,0x1B04,0x1F00,0,"multiply signed integers in even vector elements, double size result"
mul_ex_u,0x1201B,1,0x120,0xA,U0,2,27,0,0,0x1B04,0x1F00,0,"multiply unsigned integers in even vector elements, double size result"
sqrt,0x1201C,1,0x120,0xA,H0,1,28,0,0,0xE200,0xE200,0,square root
add_ss,0x12020,1,0x120,0xA,,2,32,0,0,0x1F00,0x1F00,0,"add integers, signed with saturation"
add_us,0x12021,1,0x120,0xA,U0,2,33,0,0,0x1F00,0x1F00,0,"add integers, unsigned with saturation"
sub_ss,0x12022,1,0x120,0xA,,2,34,0,0,0x1F00,0x1F00,0,"subtract integers, signed with saturation"
sub_us,0x12023,1,0x120,0xA,U0,2,35,0,0,0x1F00,0x1F00,0,"subtract integers, unsigned with saturation"
mul_ss,0x12024,1,0x120,0xA,,2,36,0,0,0x1F00,0x1F00,0,"multiply integers, signed with saturation"
mul_us,0x12025,1,0x120,0xA,U0,2,37,0,0,0x1F00,0x1F00,0,"multiply integers, unsigned with saturation"
add_oc,0x12026,1,0x120,0xA,,2,38,0,0,0xFF00,0xFF00,0,"add with overflow check. data in even elements, overflow bits in odd elements"
sub_oc,0x12027,1,0x120,0xA,,2,39,0,0,0xFF00,0xFF00,0,"subtract with overflow check. data in even elements, overflow bits in odd elements"
mul_oc,0x12028,1,0x120,0xA,,2,40,0,0,0xFF00,0xFF00,0,"multiply with overflow check. data in even elements, overflow bits in odd elements"
div_oc,0x12029,1,0x120,0xA,,2,41,0,0,0xFF00,0xFF00,0,"divide with overflow check. data in even elements, overflow bits in odd elements"
add_c,0x1202A,1,0x120,0xA,,2,42,0,0,0x1F00,0x1F00,0,"add with carry. data in even vector elements, carry in odd elements"
sub_b,0x1202B,1,0x120,0xA,,2,43,0,0,0x1F00,0x1F00,0,"subtract with borrow. data in even vector elements, borrow bit in odd elements"
read_spev,0x12030,1,0x120,0xA,RL,2,56,0,0,0x100F,0x100F,0,read and broadcast special register into vector register
read_call_stack,0x1203A,1,0x120,0xA,R1R2,2,58,0,0,0x100F,0x100F,0,Read internal call stack (privileged).
write_call_stack,0x1203B,1,0x120,0xA,R2R3D0,3,59,0,0,0x100F,0x100F,0,Write internal call stack (privileged).
read_memory_map,0x1203C,1,0x120,0xA,R1R2,2,60,0,0,0x100F,0x100F,0,Read memory map (privileged).
write_memory_map,0x1203D,1,0x120,0xA,R2R3D0,3,61,0,0,0x100F,0x100F,0,Write memory map (privileged).
input,0x1803E,1,0x120,0xA,R1R2,2,62,0,0,0x100F,0x100F,0,"read from input port. RD = vector register, RS = port address, RT = vector length (privileged instruction)."
output,0x1803F,1,0x120,0xA,R2R3D1,3,63,0,0,0x100F,0x100F,0,"write to output port. RD = vector register source operand, RS = port address, RT = vector length (privileged instruction)."
gp2vec,0x13000,1,0x130,0xB,R1,1,0,0,0x006F,0x006F,0,0,copy value from general purpose register to vector register
vec2gp,0x13001,1,0x130,0xB,R0,1,1,0,0x006F,0x006F,0x006F,0,copy value from first element of vector register to general purpose register
make_sequence,0x13004,1,0x130,0xB,R1,2,3,0,0,0xF00F,0xF00F,2,Make a vector with RT sequential numbers. First value is IM1.
insert,0x1200C,1,0x130,0xB,,3,4,0,0,0x00FF,0x00FF,18,insert one element into vector. other elements are unchanged
extract,0x1200B,1,0x130,0xB,,2,5,0,0,0x00FF,0x00FF,18,extract one element from vector into a scalar
compress,0x12004,1,0x130,0xB,,2,6,0,0,0xB04E,0xB04E,18,compress vector of specified length to half the length and half the element size
expand,0x12007,1,0x130,0xB,,2,7,0,0,0xB04E,0xB04E,18,expand vector to double length and element size.
float2int,0x1300C,1,0x130,0xB,I2H0,2,12,0,0,0x926C,0x926C,18,convert floating point to integer
int2float,0x1300D,1,0x130,0xB,I2H0,2,13,0,0,0x926C,0x926C,i0,convert integer to floating point
round,0x1300E,1,0x130,0xB,I2,2,14,0,0,0x8060,0x8060,18,round floating point to integer in floating point representation
round2n,0x1300F,1,0x130,0xB,I2,2,15,0,0,0xE000,0xE000,2,round floating point to nearest multiple of 2^n
abs,0xA0000,1,0x130,0xB,I2,2,16,0,0,0xF00F,0xF00F,2,absolute value of integer and optionally floating point
fp_category,0x0054,1,0x130,0xB,I2H0 ,2,17,0,0,0x926C,0x926C,18,check if floating point number belongs to a specified set of categories. Also used as part of conditional jump
broad,0x1200D,1,0x130,0xB,R1,2,18,0,0,0x906F,0x906F,2,broadcast constant to vector
broadcast_max,0x13013,1,0x130,0xB,,1,19,0,0,0x906F,0x906F,2,broadcast constant to vector of maximum length
byte_reverse,0x13014,1,0x130,0xB,,2,20,0,0,0x100F,0x100F,18,reverse the order of bytes in each element of vector
bit_reverse,0x13015,1,0x130,0xB,,2,20,0,0,0x1F00,0x1F00,18,reverse the order of bits in each element of vector
bitscan,0x10001,1,0x130,0xB,,2,21,0,0,0x100F,0x1F00,18,bit scan forward or reverse. find index to first or last set bit
popcount,0x13018,1,0x130,0xB,,2,22,0,0,0x100F,0x1F00,i0,population count. number of bits that are 1
bool2bits,0x1301A,1,0x130,0xB,,2,25,0,0,0x906F,0x906F,i0,pack boolean vector into bits
bool_reduce,0x1301B,1,0x130,0xB,,2,26,0,0,0x100F,0x100F,18,AND/OR combination of all elements in boolean vector
fp_category_reduce,0x1301C,1,0x130,0xB,I2H0,2,27,0,0,0x8260,0x8260,18,OR combinations of elements belonging to one of 8 categories
push,0x18038,1,0x130,0xB,D3R0,3,56,0,0,0xFF00,0xFF00,18,push one or more vector registers to stack pointed to by rd
pop,0x18039,1,0x130,0xB,D3R0,3,57,0,0,0xFF00,0xFF00,18,pop one or more vector registers from stack pointed to by rd
clear,0x1303A,1,0x130,0xB,D0,2,58,0,0,0xFF00,0xFF00,18,clear one or more vector registers by setting their length to zero
move,2,1,0x141,0xC,,1,0,0,0,0x0200,0,3,copy 16-bit constant to 16-bit scalar
add,8,1,0x141,0xC,,2,1,0,0,0x0200,0x0200,3,broadcast 16-bit constant and add it to 16-bit vector elements
and,26,1,0x141,0xC,,2,2,0,0,0x0200,0x0200,3,broadcast 16-bit constant and do a bitwise AND with 16-bit vector elements
or,27,1,0x141,0xC,,2,3,0,0,0x0200,0x0200,3,broadcast 16-bit constant and do a bitwise OR with 16-bit vector elements
xor,28,1,0x141,0xC,,2,4,0,0,0x0200,0x0200,3,broadcast 16-bit constant and do a bitwise exclusive OR with 16-bit vector elements
move,2,1,0x142,0xC,,1,8,0,0,0x0400,0,6,shift 8-bit signed constant left by another 8-bit constant and store it in 32-bit scalar
move,2,1,0x142,0xC,,1,9,0,0,0x0800,0,6,shift 8-bit signed constant left by another 8-bit constant and store it in 64-bit scalar
add,8,1,0x142,0xC,,2,10,0,0,0x0400,0x0400,6,"shift 8-bit signed constant left by another 8-bit constant, broadcast and add to 32-bit vector elements"
add,8,1,0x142,0xC,,2,11,0,0,0x0800,0x0800,6,"shift 8-bit signed constant left by another 8-bit constant, broadcast and add to 64-bit vector elements"
and,26,1,0x142,0xC,,2,12,0,0,0x0400,0x0400,6,"shift 8-bit signed constant left by another 8-bit constant, broadcast and do a bitwise AND with 32-bit vector elements"
and,26,1,0x142,0xC,,2,13,0,0,0x0800,0x0800,6,"shift 8-bit signed constant left by another 8-bit constant, broadcast and do a bitwise AND with 64-bit vector elements"
or,27,1,0x142,0xC,,2,14,0,0,0x0400,0x0400,6,"shift 8-bit signed constant left by another 8-bit constant, broadcast and do a bitwise OR with 32-bit vector elements"
or,27,1,0x142,0xC,,2,15,0,0,0x0800,0x0800,6,"shift 8-bit signed constant left by another 8-bit constant, broadcast and do a bitwise OR with 64-bit vector elements"
xor,28,1,0x142,0xC,,2,16,0,0,0x0400,0x0400,6,"shift 8-bit signed constant left by another 8-bit constant, broadcast and do a bitwise exclusive OR with 32-bit vector elements"
xor,28,1,0x142,0xC,,2,17,0,0,0x0800,0x0800,6,"shift 8-bit signed constant left by another 8-bit constant, broadcast and do a bitwise exclusive OR with 64-bit vector elements"
move,2,1,0x143,0xC,,1,32,0,0,0x2000,0x2000,64,convert half precision floating point constant to single precision scalar
move,2,1,0x143,0xC,,1,33,0,0,0x4000,0x4000,64,convert half precision floating point constant to double precision scalar
add,8,1,0x143,0xC,,2,34,0,0,0x2000,0x2000,64,"convert half precision floating point constant to single precision, broadcast and add to vector"
add,8,1,0x143,0xC,,2,35,0,0,0x4000,0x4000,64,"convert half precision floating point constant to double precision, broadcast and add to vector"
mul,11,1,0x143,0xC,,2,36,0,0,0x2000,0x2000,64,"convert half precision floating point constant to single precision, broadcast and multiply with vector"
mul,11,1,0x143,0xC,,2,37,0,0,0x4000,0x4000,64,"convert half precision floating point constant to double precision, broadcast and multiply with vector"
add_h,0x50008,1,0x144,0xC,H0,2,40,0,0,0x0200,0x0200,64,add half precision floating point constant to half precision vector
mul_h,0x5000B,1,0x144,0xC,H0,2,41,0,0,0x0200,0x0200,64,multiply half precision floating point vector with half precision constant
concatenate,0x22600,1,0x226,0xE,RL,3,0,1,0,0x906F,0x906F,0,concatenate two vector of same lengths
permute,0x22601,1,0x226,0xE,RL,3,1,1,0,0x906F,0x906F,0,"permute vector elements within blocks, using index vector"
interleave,0x22602,1,0x226,0xE,RL,3,2,1,0,0,0xFF00,0,interleave elements from two vectors
move_bits,0x28700,1,0x227,0xE,O6I2,3,0,1,0,0x1F00,0x1F00,25,extract bitfield from one operand and insert it at another position in another operand
mask_length,0x28701,1,0x227,0xE,R2O5,3,1,1,0,0x100F,0x100F,19,Make mask with true in the first RT elements
repeat_block,0x22708,1,0x227,0xE,RLI2,3,8,1,0,0,0xFC00,19,repeat a block of data to make a longer vector
repeat_within_blocks,0x22709,1,0x227,0xE,RLI2,3,9,1,0,0,0xFC00,19,broadcast the first element of each block of data in a vector to the entire block
truth_tab3,0x22603,1,0x206,0xE,O5I2,4,48,1,0x1F00,0x1F00,0x1F00,20,"boolean function of three inputs, given by truth table"
truth_tab3,0x22603,1,0x226,0xE,O5I2,4,48,1,0,0x1F00,0x1F00,20,"boolean function of three inputs, given by truth table"
load_hi,0x26000,1,0x260,0xA,,1,0,0,0,0x906F,0x906F,100,"make vector of two elements. first element is zero, second element is constant"
insert_hi,0x29001,1,0x260,0xA,,2,1,0,0,0x906F,0x906F,100,"make vector of two elements. first element comes from source, second element is constant"
make_mask,0x26002,1,0x260,0xA,,2,2,0,0,0x906F,0x906F,20,make boolean vector from 32 constant bits
replace,0xA0001,1,0x260,0xA,,2,3,0,0,0x906F,0x906F,100,replace all or selected elements in vector by constant
replace_even,0x26004,1,0x260,0xA,,2,4,0,0,0x906F,0x906F,100,replace even-numbered elements in vector by constant
replace_odd,0x26005,1,0x260,0xA,,2,5,0,0,0x906F,0x906F,100,replace odd-numbered elements in vector by constant
broad,0x1200D,1,0x260,0xA,RL,2,6,0,0,0x906F,0x906F,100,broadcast constant to make vector of identical elements
permute,0x22601,1,0x260,0xA,I2RL,3,8,0,0,0x906F,0x906F,20,"permute vector elements within blocks, using constant indices"
store,1,1,0x258,0xB,M0,1,8,0,0xFF00,0xFF00,0,100,store constant to memory operand with base and 8-bit offset
fence,0x25910,1,0x259,0xA,D1,2,16,0,0xFF00,0,0,18,memory fence. type indicated by IM1 bits
compare_swap,0x25912,1,0x259,0xA,,3,18,0,0xFF00,0xFF00,0,0,atomic compare and exchange
read_insert,0x25A18,1,0x25A,0xA,R2,3,32,0,0,0xFF00,0xFF00,0,replace one element in vector with scalar memory operand
extract_store,0x25A20,1,0x25A,0xA,R2M0,2,40,0,0,0xFF00,0xFF00,0,extract one element from vector and store to memory
replace,0xA0001,1,0x318,0xA,,2,32,0,0,0x906F,0x906F,100,replace all or selected elements in vector by constant
broad,0x1200D,1,0x318,0xA,RL,2,33,0,0,0x4800,0x4800,100,broadcast constant to vector
,,,,,,,,,,,,,
sub/jump_zero,0x101209,4,0xFFFD,0xB,,3,0,0,0x000F,0x1000,0,0,"subtract, jump if zero"
sub/jump_nzero,0x101309,4,0xFFFD,0xB,,3,1,0,0x000F,0x1000,0,0,"subtract, jump if not zero"
sub/jump_neg,0x101409,4,0xFFFD,0xB,,3,2,0,0x000F,0x1000,0,0,"subtract signed, jump if negative"
sub/jump_nneg,0x101509,4,0xFFFD,0xB,,3,3,0,0x000F,0x1000,0,0,"subtract signed, jump if zero or positive"
sub/jump_pos,0x101609,4,0xFFFD,0xB,,3,4,0,0x000F,0x1000,0,0,"subtract signed, jump if positive"
sub/jump_npos,0x101709,4,0xFFFD,0xB,,3,5,0,0x000F,0x1000,0,0,"subtract signed, jump if zero or negative"
sub/jump_overfl,0x101809,4,0xFFFD,0xB,,3,6,0,0x000F,0x1000,0,0,"subtract signed, jump if overflow"
sub/jump_noverfl,0x101909,4,0xFFFD,0xB,,3,7,0,0x000F,0x1000,0,0,"subtract signed, jump if not overflow"
sub/jump_borrow,0x102009,4,0xFFFD,0xB,U0,3,8,0,0x000F,0x1000,0,0,"subtract unsigned , jump if borrow"
sub/jump_nborrow,0x102109,4,0xFFFD,0xB,U0,3,9,0,0x000F,0x1000,0,0,"subtract unsigned , jump if not borrow"
and/jump_zero,0x10121A,4,0xFFFD,0,,3,10,0,0x000F,0x9060,0,0,"bitwise and, jump if zero"
and/jump_nzero,0x10131A,4,0xFFFD,0,,3,11,0,0x000F,0x9060,0,0,"bitwise and, jump if not zero"
or/jump_zero,0x10121B,4,0xFFFD,0,,3,12,0,0x000F,0x9060,0,0,"bitwise or, jump if zero"
or/jump_nzero,0x10131B,4,0xFFFD,0,,3,13,0,0x000F,0x9060,0,0,"bitwise or, jump if not zero"
xor/jump_zero,0x10121C,4,0xFFFD,0,,3,14,0,0x000F,0x9060,0,0,"bitwise exclusive or, jump if zero"
xor/jump_nzero,0x10131C,4,0xFFFD,0,,3,15,0,0x000F,0x9060,0,0,"bitwise exclusive or, jump if not zero"
add/jump_zero,0x101208,4,0xFFFF,0,,3,16,0,0x000F,0x1000,0,0,"add, jump if zero"
add/jump_nzero,0x101308,4,0xFFFF,0,,3,17,0,0x000F,0x1000,0,0,"add, jump if not zero"
add/jump_neg,0x101408,4,0xFFFF,0,,3,18,0,0x000F,0x1000,0,0,"add signed, jump if negative"
add/jump_nneg,0x101508,4,0xFFFF,0,,3,19,0,0x000F,0x1000,0,0,"add signed, jump if zero or positive"
add/jump_pos,0x101608,4,0xFFFF,0,,3,20,0,0x000F,0x1000,0,0,"add signed, jump if positive"
add/jump_npos,0x101708,4,0xFFFF,0,,3,21,0,0x000F,0x1000,0,0,"add signed, jump if zero or negative"
add/jump_overfl,0x101808,4,0xFFFF,0,,3,22,0,0x000F,0x1000,0,0,"add signed, jump if overflow"
add/jump_noverfl,0x101908,4,0xFFFF,0,,3,23,0,0x000F,0x1000,0,0,"add signed, jump if not overflow"
add/jump_carry,0x102008,4,0xFFFF,0,U0,3,24,0,0x000F,0x1000,0,0,"add unsigned, jump if carry"
add/jump_ncarry,0x102108,4,0xFFFF,0,U0,3,25,0,0x000F,0x1000,0,0,"add unsigned, jump if not carry"
test_bit/jump_true,0x102427,4,0xFFFF,0,D1I2,3,26,0,0x000F,0x9060,0,0,"test single bit in source1 indexed by source2, jump if 1"
test_bit/jump_false,0x102527,4,0xFFFF,0,D1I2,3,27,0,0x000F,0x9060,0,0,"test single bit in source1 indexed by source2, jump if 0"
test_bit/jump_nzero,0x101327,4,0xFFFF,0,D1I2,3,26,0,0x000F,0x9060,0,0,alias
test_bit/jump_zero,0x101227,4,0xFFFF,0,D1I2,3,27,0,0x000F,0x9060,0,0,alias
test_bits_and/jump_true,0x102428,4,0xFFFF,0,D1I2,3,28,0,0x000F,0x9060,0,0,jump if all bits in src1 indicated by src2 are 1
test_bits_and/jump_false,0x102528,4,0xFFFF,0,D1I2,3,29,0,0x000F,0x9060,0,0,jump if not all bits in src1 indicated by src2 are 1
test_bits_and/jump_nzero,0x101328,4,0xFFFF,0,D1I2,3,28,0,0x000F,0x9060,0,0,jump if all bits in src1 indicated by src2 are 1
test_bits_and/jump_zero,0x101228,4,0xFFFF,0,D1I2,3,29,0,0x000F,0x9060,0,0,jump if not all bits in src1 indicated by src2 are 1
test_bits_or/jump_true,0x102429,4,0xFFFF,0,D1I2,3,30,0,0x000F,0x9060,0,0,jump if all bits in src1 indicated by src2 are 1
test_bits_or/jump_false,0x102529,4,0xFFFF,0,D1I2,3,31,0,0x000F,0x9060,0,0,jump if not all bits in src1 indicated by src2 are 1
test_bits_or/jump_nzero,0x101329,4,0xFFFF,0,D1I2,3,30,0,0x000F,0x9060,0,0,jump if all bits in src1 indicated by src2 are 1
test_bits_or/jump_zero,0x101229,4,0xFFFF,0,D1I2,3,31,0,0x000F,0x9060,0,0,jump if not all bits in src1 indicated by src2 are 1
compare/jump_equal,0x101207,4,0xFFFF,0,D1O4,3,32,0,0x000F,0x9060,0,0,"compare, jump if equal"
compare/jump_nequal,0x101307,4,0xFFFF,0,D1O4,3,33,0,0x000F,0x9060,0,0,"compare, jump if not equal"
compare/jump_sbelow,0x101407,4,0xFFFF,0,D1O4,3,34,0,0x000F,0x1000,0,0,"compare signed integer, jump if below"
compare/jump_saboveeq,0x101507,4,0xFFFF,0,D1O4,3,35,0,0x000F,0x1000,0,0,"compare signed integer, jump if above or equal"
compare/jump_sabove,0x101607,4,0xFFFF,0,D1O4,3,36,0,0x000F,0x1000,0,0,"compare signed integer, jump if above"
compare/jump_sbeloweq,0x101707,4,0xFFFF,0,D1O4,3,37,0,0x000F,0x1000,0,0,"compare signed integer, jump if below or equal"
compare/jump_ubelow,0x102007,4,0xFFFF,0,D1U0O4,3,38,0,0x000F,0x1000,0,0,"compare unsigned integer, jump if below"
compare/jump_uaboveeq,0x102107,4,0xFFFF,0,D1U0O4,3,39,0,0x000F,0x1000,0,0,"compare unsigned integer, jump if above or equal"
compare/jump_uabove,0x102207,4,0xFFFF,0,D1U0O4,3,40,0,0x000F,0x1000,0,0,"compare unsigned integer, jump if above"
compare/jump_ubeloweq,0x102307,4,0xFFFF,0,D1U0O4,3,41,0,0x000F,0x1000,0,0,"compare unsigned integer, jump if below or equal"
compare/jump_below,0x101407,4,0xFFFF,0,D1O4,3,34,0,0,0x8060,0,0,"compare float, jump if below"
compare/jump_aboveeq,0x101507,4,0xFFFF,0,D1O4,3,35,0,0,0x8060,0,0,"compare float, jump if above or equal"
compare/jump_above,0x101607,4,0xFFFF,0,D1O4,3,36,0,0,0x8060,0,0,"compare float, jump if above"
compare/jump_beloweq,0x101707,4,0xFFFF,0,D1O4,3,37,0,0,0x8060,0,0,"compare float, jump if below or equal"
compare/jump_abs_below,0x102007,4,0xFFFD,0,D1O4,3,38,0,0,0x8060,0,0,"compare abs float, jump if below"
compare/jump_abs_aboveeq,0x102107,4,0xFFFD,0,D1O4,3,39,0,0,0x8060,0,0,"compare abs float, jump if above or equal"
compare/jump_abs_above,0x102207,4,0xFFFD,0,D1O4,3,40,0,0,0x8060,0,0,"compare abs float, jump if above"
compare/jump_abs_beloweq,0x102307,4,0xFFFD,0,D1O4,3,41,0,0,0x8060,0,0,"compare abs float, jump if below or equal"
compare/jump_equal_uo,0x109207,4,0xFFFD,0,D1O4,3,0,0,0,0x8060,0,0,"compare float, jump if equal or unordered"
compare/jump_nequal_uo,0x109307,4,0xFFFD,0,D1O4,3,1,0,0,0x8060,0,0,"compare float, jump if different or unordered"
compare/jump_below_uo,0x109407,4,0xFFFD,0,D1O4,3,2,0,0,0x8060,0,0,"compare float, jump if below or unordered"
compare/jump_aboveeq_uo,0x109507,4,0xFFFD,0,D1O4,3,3,0,0,0x8060,0,0,"compare float, jump if above or equal or unordered"
compare/jump_above_uo,0x109607,4,0xFFFD,0,D1O4,3,4,0,0,0x8060,0,0,"compare float, jump if above or unordered"
compare/jump_beloweq_uo,0x109707,4,0xFFFD,0,D1O4,3,5,0,0,0x8060,0,0,"compare float, jump if below or equal or unordered"
compare/jump_unordered,0x109E07,4,0xFFFD,0,D1O4,3,22,0,0,0x8060,0,0,"compare float, jump if unordered"
compare/jump_ordered,0x109F07,4,0xFFFD,0,D1O4,3,23,0,0,0x8060,0,0,"compare float, jump if no operand is NaN"
compare/jump_abs_below_uo,0x10A007,4,0xFFFD,0,D1O4,3,6,0,0,0x8060,0,0,"compare abs float, jump if below or unordered"
compare/jump_abs_aboveeq_uo,0x10A107,4,0xFFFD,0,D1O4,3,7,0,0,0x8060,0,0,"compare abs float, jump if above or equal or unordered"
compare/jump_abs_above_uo,0x10A207,4,0xFFFD,0,D1O4,3,8,0,0,0x8060,0,0,"compare abs float, jump if above or unordered"
compare/jump_abs_beloweq_uo,0x10A307,4,0xFFFD,0,D1O4,3,9,0,0,0x8060,0,0,"compare abs float, jump if below or equal or unordered"
fp_category/jump_true,0x102454,4,0xFFFD,0,D1O4I2,3,24,0,0,0x8060,0,0,jump if float value belongs to any of the indicated categories
fp_category/jump_false,0x102554,4,0xFFFD,0,D1O4I2,3,25,0,0,0x8060,0,0,jump if float value does not belong to any of the indicated categories
,,,,,,,,,,,,,
increment_compare/jump_sbelow,0x101451,4,0xFFFF,0,O4,3,48,0,0x000F,0x1000,0,0,dest = source1 + 1. jump if dest > source2 (signed)
increment_compare/jump_saboveeq,0x101551,4,0xFFFF,0,O4,3,49,0,0x000F,0x1000,0,0,dest = source1 + 1. jump if dest <= source2 (signed)
increment_compare/jump_sabove,0x101651,4,0xFFFF,0,O4,3,50,0,0x000F,0x1000,0,0,dest = source1 + 1. jump if dest > source2 (signed)
increment_compare/jump_sbeloweq,0x101751,4,0xFFFF,0,O4,3,51,0,0x000F,0x1000,0,0,dest = source1 + 1. jump if dest <= source2 (signed)
sub_maxlen/jump_pos,0x101652,4,0x200FFFD,0,,3,52,0,0x000F,0,0,18,dest -= (max vector length for operand type given by IM1). jump if result is positive
sub_maxlen/jump_npos,0x101752,4,0x200FFFD,0,,3,53,0,0x000F,0,0,18,dest -= (max vector length for operand type given by IM1). jump if result not positive
,,,,,,,,,,,,,
jump,0x101000,4,0x20010000,0xB,D0,1,58,0,0x000F,0,0,0,jump to address in memory operand with base and offset
call,0x111000,4,0x20010000,0xB,D0,1,59,0,0x000F,0,0,0,call to address in memory operand with base and offset
jump,0x101000,4,0x100000,0xD,D0,1,0,0,0x000F,0,0,0,direct jump to 24-bit relative address
call,0x111000,4,0x100000,0xD,D0,1,8,0,0x000F,0,0,0,direct call to 24-bit relative address
jump,0x101000,4,0x100,0xC,D0,1,58,0,0x000F,0,0,0,jump to 32 bit relative address
call,0x111000,4,0x100,0xC,D0,1,59,0,0x000F,0,0,0,call to 32 bit relative address
jump,0x101000,4,0x2000,0xC,D0,1,58,0,0x000F,0,0,21,direct jump to 64 bit absolute address
call,0x111000,4,0x2000,0xC,D0,1,59,0,0x000F,0,0,21,direct call to 64 bit absolute address
jump,0x101000,4,0x400000,0xC,D0,1,60,0,0x000F,0,0,0,jump to address in register
call,0x111000,4,0x400000,0xC,D0,1,61,0,0x000F,0,0,0,call to address in register
jump_relative,0x101001,4,0x20020000,0xA,D1,2,60,0,0x000F,0,0,0,"jump to relative address in table with base and index or offset, relative to arbitrary reference point"
call_relative,0x111001,4,0x20020000,0xA,D1,2,61,0,0x000F,0,0,0,"call to relative address in table with base and index or offset, relative to arbitrary reference point"
return,0x4001E,4,0x40000,0xB,D0,0,62,0,0x000F,0,0,0,return from function
sys_return,0x4101E,4,0x400000,0xC,D0,0,62,0,0x000F,0,0,0,return from system function or interrupt
sys_call,0x4001F,4,0x40000,0xA,D1,3,63,0,0x000F,0,0,0,system call to ID in register. 3 registers
sys_call,0x4001F,4,0x10000000,0xB,D0,4,63,0,0x080F,0,0,26,"system call to ID in constant fields. 2.5.1x two registers, two int16"
sys_call,0x4001F,4,0x100000000,0xB,D0,2,63,0,0x080F,0,0,27,"system call to ID in constant fields. 2.5.7, no registers, int16+int32"
sys_call,0x4001F,4,0x10000000000,0xB,D0,4,63,0,0x080F,0,0,28,"system call to ID in constant fields. 3.1.1X two registers, two int32"
breakpoint,0x4111F,4,0x800000,0xC,D0,0,63,0,0x000F,0,0,i1,debug breakpoint (trap 3)
filler,0x4121F,4,0x1000000,0xC,D0,0,63,0,0x00FF,0,0,i-1,filler indicating unused code (0x7FFFFFFF)
trap,0x4101F,4,0x800000,0xC,D0,1,63,0,0x080F,0,0,19,unconditional trap (interrupt)
compare_trap_uabove,0x42207,4,0x80000000,0xC,D0,2,63,0,0x0008,0,0,20,conditional trap if unsigned above. Not supported
,,,,,,,,,,,,,
Partial instruction names:,,,,,,,,,,,,,
test,0x0050,4,0,0,,2,-1,0,0,0,0,0,partial instruction name. part of test_bit/jump_zero
increment_compare,0x0051,4,0,0,,2,-1,0,0,0,0,0,partial instruction name. part of increment_compare/jump_above
sub_maxlen,0x0052,4,0,0,,2,-1,0,0,0,0,18,partial instruction name. part of sub_maxlen/jump_pos
fp_category defined above 0x0054 ,,,,,,,,,,,,,
,,,,,,,,,,,,,
jump_zero,0x101200,4,0,0,,3,-1,0,0,0,0,0,partial instruction name. jump if zero
jump_nzero,0x101300,4,0,0,,3,-1,0,0,0,0,0,partial instruction name. jump if not zero
jump_nonzero,0x101300,4,0,0,,3,-1,0,0,0,0,0,alias
jump_neg,0x101400,4,0,0,,3,-1,0,0,0,0,0,partial instruction name. jump if negative
jump_nneg,0x101500,4,0,0,,3,-1,0,0,0,0,0,partial instruction name. jump if zero or positive
jump_pos,0x101600,4,0,0,,3,-1,0,0,0,0,0,partial instruction name. jump if positive
jump_npos,0x101700,4,0,0,,3,-1,0,0,0,0,0,partial instruction name. jump if zero or negative
jump_overfl,0x101800,4,0,0,,3,-1,0,0,0,0,0,partial instruction name. jump if overflow
jump_noverfl,0x101900,4,0,0,,3,-1,0,0,0,0,0,partial instruction name. jump if not overflow
jump_borrow,0x102000,4,0,0,U0,3,-1,0,0,0,0,0,partial instruction name. jump if borrow
jump_nborrow,0x102100,4,0,0,U0,3,-1,0,0,0,0,0,partial instruction name. jump if not borrow
jump_carry,0x102000,4,0,0,,3,-1,0,0,0,0,0,partial instruction name. jump if carry
jump_ncarry,0x102100,4,0,0,,3,-1,0,0,0,0,0,partial instruction name. jump if not carry
jump_eq,0x101200,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if equal
jump_equal,0x101200,4,0,0,D1,2,-1,0,0,0,0,0,alias
jump_nequal,0x101300,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if not equal
jump_neq,0x101300,4,0,0,D1,2,-1,0,0,0,0,0,alias
jump_notequal,0x101300,4,0,0,D1,2,-1,0,0,0,0,0,alias
jump_sbelow,0x101400,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if below
jump_saboveeq,0x101500,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if above or equal
jump_sabove,0x101600,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if above
jump_sbeloweq,0x101700,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if below or equal
jump_below,0x101400,4,0,0,D1,2,-1,0,0,0,0,0,alias
jump_aboveeq,0x101500,4,0,0,D1,2,-1,0,0,0,0,0,alias
jump_above,0x101600,4,0,0,D1,2,-1,0,0,0,0,0,alias
jump_beloweq,0x101700,4,0,0,D1,2,-1,0,0,0,0,0,alias
jump_ubelow,0x102000,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if below
jump_uaboveeq,0x102100,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if above or equal
jump_uabove,0x102200,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if above
jump_ubeloweq,0x102300,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if below or equal
jump_eq_uo,0x109200,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if equal
jump_equal_uo,0x109200,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if equal
jump_neq_uo,0x109300,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if not equal
jump_notequal_uo,0x109300,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if not equal
jump_below_uo,0x109400,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if below or unordered
jump_aboveeq_uo,0x109500,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if above or equal or unordered
jump_above_uo,0x109600,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if above or unordered
jump_beloweq_uo,0x109700,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if below or equal or unordered
jump_unordered,0x109E00,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if unordered
jump_uo,0x109E00,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if unordered
jump_ordered,0x109F00,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if not unordered
jump_nuo,0x109F00,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if not unordered
jump_abs_below,0x102000,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if absolute value below
jump_abs_aboveeq,0x102100,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if absolute value below or equal
jump_abs_above,0x102200,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if absolute value above
jump_abs_beloweq,0x102300,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if absolute value above or equal
jump_abs_below_uo,0x10A000,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if absolute value below or unordered
jump_abs_aboveeq_uo,0x10A100,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if absolute value below or equal or unordered
jump_abs_above_uo,0x10A200,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if absolute value above or unordered
jump_abs_beloweq_uo,0x10A300,4,0,0,D1U0,2,-1,0,0,0,0,0,partial instruction name. jump if absolute value above or equal or unordered
jump_true,0x102400,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if condition is true
jump_false,0x102500,4,0,0,D1,2,-1,0,0,0,0,0,partial instruction name. jump if condition is false