Subversion Repositories forwardcom

Instruction list for ForwardCom instruction set. Version 1.11. 2021-07-09,,,,,,,,,,,,,

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,D04,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,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,O4,2,14,0,0x000F,0x906F,0xFF00,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,O4,2,16,0,0x000F,0x906F,0xFF00,0,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,,2,20,0,0x000F,0x906F,0x906F,0,minimum of unsigned integers

min_u,21,3,-1,0,U0,2,21,0,0x000F,0x100F,0x100F,0,minimum of unsigned integers

max,22,3,-1,0,,2,22,0,0x000F,0x906F,0x906F,0,maximum of signed numbers

max_u,23,3,-1,0,U0,2,23,0,0x000F,0x100F,0x100F,0,maximum of unsigned integers

min_abs,21,3,-1,0,,2,21,0,0x8060,0x8060,0x8060,0,minimum of absolute values of floating point numbers

max_abs,23,3,-1,0,,2,23,0,0x8060,0x8060,0x8060,0,maximum of absolute values of floating point 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_2pow,32,3,0x7F7F0FFFFAFFF,0,I2,2,32,0,0x0000,0x8060,0x8060,0,Multiply float by 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_h,0x50031,3,0xFFFFFFFFF700F,0,H0O4,3,48,0,0,0x0200,0x0200,0,"src1+src2*src3. half precision floating point vectors, optional sign change"

mul_add,49,3,0xFFFFFFFFF700F,0,O4,3,49,0,0x0F00,0xFF00,0xFF00,0,"src1+src2*src3. Fused multiply and add, optional sign change"

mul_add2,50,3,0xFFFFFFFFF700F,0,O4,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,,1,4,0,0x100F,0,0,0,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,,1,28,0,0,0xE000,0xE000,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,0x130,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,I2,2,12,0,0,0x926C,0x926C,18,convert floating point to integer

int2float,0x1300D,1,0x130,0xB,I2,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,I2,2,17,0,0,0x906C,0x906C,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,,1,22,0,0,0x100F,0x1F00,0,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,i0,AND/OR combination of all elements in boolean vector

category_reduce,0x1301B,1,0x130,0xB,,2,26,0,0,0x8060,0x8060,i0,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

truth_tab3,0x22603,1,0x206,0xE,O5I2,4,8,1,0x1F00,0x1F00,0x1F00,20,"boolean function of three inputs, given by truth table"

truth_tab3,0x22603,1,0x226,0xE,O5I2,4,8,1,0,0x1F00,0x1F00,20,"boolean function of three inputs, given by truth table"

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

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_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

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_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_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