Subversion Repositories forwardcom

% chapter included in forwardcom.tex

\documentclass[forwardcom.tex]{subfiles}

\begin{document}

\RaggedRight

\chapter{Instruction lists}\label{chap:InstructionLists}

The ForwardCom instructions are listed in a comma-separated file instruction\_list.csv. This file is intended for use by assemblers, disassemblers, debuggers and emulators. The list is preliminary and subject to possible changes. Please remember to keep the lists in this document and the list in the instruction\_list.cvs file synchronized.

\vv

The instruction list file has the following fields:

\begin{longtable} {|p{18mm}|p{100mm}|}

\caption{Fields in instruction list file}

\label{table:fieldsInInstructionListFile}

\\

\endfirsthead

\endhead

\hline

\bfseries Field & \bfseries Meaning  \\

\hline

Name & Name of instruction as used by assembler.  \\

\hline

Category & 1: single format instruction, \newline

           2: unused,  \newline

           3: multi-format instruction,  \newline

           4: jump instruction. \\

\hline

Formats & See table \ref{table:MeaningOfFormatsFieldInInstructionListFile} below.  \\

\hline

Template & Hexadecimal number:  \newline

           0xA - 0xE for template A - E,  \newline

           0x0 for multiple templates. \\

\hline

Variant &

D0:  No destination operand, no operand type.\newline

D1:  No destination operand, but operand type specified.\newline

D2:  Operand type ignored.\newline

D3:  Destination register used for other purpose.\newline

F0:  Can have mask register, but not fallback register.\newline

F1:  Can have fallback register without mask register.\newline

I2:  Immediate source operand is integer regardless of specified operand type.\newline

M0:  Memory operand is destination.\newline

%M1:  E formats with a memory operand use IM3 as an extra immediate operand.\newline (obsolete)

On: n bits of IM3 in E template format used for options (IM3 can be used for shift count only if it is not used for options).\newline

R0:  Destination is a general purpose register.\newline

R1:  First source operand is a general purpose register.\newline

R2:  Second source operand is a general purpose register.\newline

RL:  RT is a general purpose register specifying vector length.\newline

U0:  Integer operands are unsigned.\newline

U3:  Integer operands are unsigned if option bit 3 is set.\newline \hspace{6mm}

     (compare instruction).\newline

H0:  Half precision floating point instruction.\newline

X0:  Source register can be a special pointer (threadp, datap, ip).\newline

X1:  Source register is special register.\newline

X2:  Source register is capabilities register.\newline

X3:  Source register is performance monitor register.\newline

X4:  Source register is system register.\newline

Y0-4:Destination register is one of the above.

\\ \hline

Source operands & Number of source operands, including register, memory and immediate operands, but not including mask, option bits, vector length, and index. \\

\hline

OP1 & Operation code OP1. \\

\hline

OP2 & Additional operation code OP2. Zero if none. \\

\hline

Operand types general purpose registers & Hexadecimal number indicating required and optional support for each operand type with general purpose registers. See table \ref{table:OperandTypesInInstructionList} below for meaning of each bit. \\

\hline

Operand types scalar & Hexadecimal number indicating required and optional support for each operand type for scalar operations in vector registers. See table \ref{table:OperandTypesInInstructionList} below for meaning of each bit. \\

\hline

Operand types vector & Hexadecimal number indicating required and optional support for each operand type for vector operations. See table \ref{table:OperandTypesInInstructionList} below for meaning of each bit. \\

\hline

Immediate operand type & Type of immediate operand for single-format instructions. See table \ref{table:immediateOperantTypesInInstructionList} below. \\

\hline

Description & Description of the instruction and comments. \\

\hline

\end{longtable}

\pagebreak % The text in the multirow box below disappears if there is a page break in it.

           % Put page break here instead to prevent this

\label{table_format_field_in_list}

\begin{longtable} {|p{18mm}|p{20mm} p{80mm}|}

\caption{Meaning of formats field in instruction list file}

\label{table:MeaningOfFormatsFieldInInstructionListFile}

\\

\endfirsthead

\endhead

\hline

\bfseries Category & \multicolumn{2}{|l|}{\bfseries Interpretation of formats field} \\

\hline

1.  Single format instruction & \multicolumn{2}{|p{102mm}|}{

Number with three hexadecimal digits. \newline

The leftmost digit is the value of the IL field (0-3). \newline

The middle digit is he value of mode field or the combined M+mode field (0-9).\newline

The rightmost digit is the sub-mode defined by OP2 in E template modes or OP1 in mode 2.5.x. Zero otherwise. \newline

For example 0x223 means format 2.2.3.

}  \\

\hline

% \pagebreak % The text in the multirow box disappears if there is a page break in it.

% Put pagebreak here to prevent this, or before the table

% \hline

\multirow{27}{*}{\parbox[t]{18mm}{3. Multi-format instruction}}

  &  \multicolumn{2}{|l|}{

     Hexadecimal number composed of one bit for each format supported:} \\

  &  0x0000001 & Format 0.0: three general purpose registers. \\

  &  0x0000002 & Format 0.1: two general purpose registers, 8-bit immediate. \\

  &  0x0000004 & Format 0.2: Three vector registers. \\

  &  0x0000008 & Format 0.3: Two vectors, 8-bit immediate. \\

  &  0x0000010 & Format 0.4: One vector, memory operand. \\

  &  0x0000020 & Format 0.5: One vector, memory operand with negative index. \\

  &  0x0000040 & Format 0.6: One vector, scalar memory operand with index. \\

  &  0x0000080 & Format 0.7: One vector, scalar memory operand with 8-bit offset. \\

  &  0x0000100 & Format 0.8: One g. p. register, memory operand with index. \\

  &  0x0000200 & Format 0.9: One g. p. register, memory operand with 8-bit offset. \\

  &  0x0001000 & Format 2.8: Three g. p. registers, 32-bit immediate. \\

  &  0x0002000 & Format 2.1: Two g. p. registers, memory with 32-bit offset. \\

  &  0x0004000 & Format 2.3: Three vector registers, 32-bit immediate. \\

  &  0x0008000 & Format 2.4: One vector register, memory with 32-bit offset. \\

  &  0x0010000 & Format 2.0.0: Three g. p. reg., memory with 16-bit offset. \\

  &  0x0020000 & Format 2.0.1: Two g. p. reg., memory with unscaled index. \\

  &  0x0040000 & Format 2.0.2: Two g. p. reg., memory with scaled index. \\

  &  0x0080000 & Format 2.0.3: Two g. p. reg., memory with index and limit.\\

  &  0x0400000 & Format 2.0.6: Four g. p. reg.\\

  &  0x0800000 & Format 2.0.7: Three g. p. registers, 16-bit shifted immediate. \\

  &  0x1000000 & Format 2.2.0: Two vector reg., scalar memory w. 16-bit offset. \\

  &  0x2000000 & Format 2.2.1: Two vector reg., memory with 16-bit offset. \\

  &  0x4000000 & Format 2.2.2: Two vector reg., memory with negative index. \\

  &  0x8000000 & Format 2.2.3: Two vector reg., scalar memory w. index and limit. \\

  & 0x40000000 & Format 2.2.6: Four vector reg. \\

  & 0x80000000 & Format 2.2.7: Three vector registers, 16-bit shifted immediate.\\

  & 0x100000000 & Format 3.8:   Three g. p. registers, 64-bit immediate. \\

  & 0x40000 0000 & Format 3.3:   Three vector registers, 64-bit immediate. \\

  &  0x100000 0000 & Format 3.0.0: Three g. p. reg., memory with 32-bit offset. \\

  &  0x800000 0000 & Format 3.0.3: Two g. p. reg., memory with index and 32-bit limit.\\

  &  0x2000000 0000 & Format 3.0.5: One g. p. reg., memory with index and 16-bit offset, 32-bit immediate.\\

  &  0x8000000 0000 & Format 3.0.7: Three g. p. registers, 32-bit shifted immediate. \\

  &  0x10000000 0000 & Format 3.2.0: Two vector reg., scalar memory w. 32-bit offset. \\

  &  0x20000000 0000 & Format 3.2.1: Two vector reg., memory with 32-bit offset. \\

  &  0x80000000 0000 & Format 3.2.3: Two vector reg., scalar memory index and 32-bit limit. \\

  &  0x200000000 0000 & Format 3.2.5: One vector reg., memory with 16-bit offset, and 32-bit immediate. \\

  &  0x800000000 0000 & Format 3.2.7: Three vector registers, float or 32-bit shifted immediate.\\

\hline

\multirow{12}{*}{\parbox[t]{18mm}{4. Jump instruction}}

  &  \multicolumn{2}{|l|}{

     Hexadecimal number composed of one bit for each format supported:} \\

  &  0x00001 & Format 1.6.0 B: Two registers, 8 bit offset. \\

  &  0x00002 & Format 1.7.1 C: One register, 8 bit immediate, 8 bit offset. \\

  &  0x00010 & Format 2.5.0 A: Three registers, 24 bit offset. \\

  &  0x00020 & Format 2.5.1 B: Two registers, 16 bit immediate, 16 bit offset. \\

  &  0x00040 & Format 2.5.2 B: One register, memory operand with 16 bit address, 16 bit  offset. \\

  &  0x00080 & Format 2.5.3 B: Unused. \\

  &  0x00100 & Format 2.5.4 C: One register, 8 bit immediate, 32 bit offset. \\

  &  0x00200 & Format 2.5.5 C: One register, 32 bit immediate, 8 bit offset. \\

  &  0x01000 & Format 3.1.0 A: Two registers, memory operand w 32 bit address, 24 bit offset. \\

  &  0x02000 & Format 3.1.1 B: Two registers, 32 bit immediate, 32 bit offset. \\

  &  0x10000 & Format 1.6.1 B: Memory operand with 8 bit offset. \\

  &  0x20000 & Format 1.6.2 A: Reg. and memory w. scaled index. \\

  &  0x40000 & Format 1.6.3 A: Three registers. \\

  &  0x100000 & Format 1.7.0 D: No register, 24 bit address. \\

%  &  0x200000 & Format 1.7.2 C: 16-bit offset. Unused \\

  &  0x400000 & Format 1.7.3 C: One register. \\

  &  0x800000 & Format 1.7.4 C: 16 bit immediate. \\

  &  0x1000000 & Format 1.7.5 C: 16 bit fixed immediate. \\

  &  0x2000000 & Format 1.7.A C: Format 1.7 with 64 bit operand size. \\

  &  0x10000000 & Format 2.5.1 X: Two registers, 2x16 bit immediate. \\

  &  0x20000000 & Format 2.5.2 X: One register, memory operand with 32 bit offset. \\

  &  0x40000000 & Format 2.5.4 X: 64 bit operand size. \\

  &  0x80000000 & Format 2.5.5 X: Conditional trap. \\

  &  0x100000000 & Format 2.5.7 C: System call, 16 bit function, 32 bit module. \\

  & 0x1000000 0000 & Format 3.1.1 X: System call, 32 bit function, 32 bit module. \\

\hline

\end{longtable}

\begin{longtable} {|p{18mm}|p{100mm}|}

\caption{

Indication of operand types supported for general purpose registers, scalars in vector

registers, or vectors. The value is a hexadecimal number composed of one bit for each operand

type supported}

\label{table:OperandTypesInInstructionList} \\

\endfirsthead

\endhead

\hline

0x0001 & 8-bit integer supported. \\

0x0002 & 16-bit integer supported. \\

0x0004 & 32-bit integer supported. \\

0x0008 & 64-bit integer supported. \\

0x0010 & 128-bit integer supported. \\

0x0020 & single precision floating point supported. \\

0x0040 & double precision floating point supported. \\

0x0080 & quadruple precision floating point supported. \\

0x0100 & 8-bit integer optionally supported. \\

0x0200 & 16-bit integer optionally supported. \\

0x0400 & 32-bit integer optionally supported. \\

0x0800 & 64-bit integer optionally supported. \\

0x1000 & 128-bit integer optionally supported. \\

0x2000 & single precision floating point optionally supported. \\

0x4000 & double precision floating point optionally supported. \\

0x8000 & quadruple precision floating point optionally supported. \\

\hline

\end{longtable}

\begin{longtable} {|p{18mm}|p{100mm}|}

\caption{

Immediate operand type for single-format instructions}

\label{table:immediateOperantTypesInInstructionList}

\\

\endfirsthead

\endhead

\hline

% 1 & 4-bit signed integer. \\

2 & 8-bit signed integer. \\

3 & 16-bit signed integer. \\

4 & 32-bit signed integer. \\

5 & 64-bit signed integer. \\

6 & 8-bit signed integer shifted by specified count. \\

7 & 16-bit signed integer shifted by specified count. \\

8 & 16-bit signed integer shifted by 16. \\

9 & 32-bit signed integer shifted by 32. \\

% 17 & 4-bit unsigned integer. \\

18 & 8-bit unsigned integer. \\

19 & 16-bit unsigned integer. \\

20 & 32-bit unsigned integer. \\

21 & 64-bit unsigned integer. \\

24 & two 8-bit unsigned integers. \\

25 & two 8-bit and one 6-bit unsigned integers. \\

26 & two 16-bit unsigned integers. \\

27 & one 16-bit and one 32-bit unsigned integer. \\

28 & two 32-bit unsigned integers. \\

29 & one 16-bit and two 8-bit unsigned integers. \\

% 33 & 4-bit unsigned integer converted to float. \\

34 & 8-bit signed integer converted to float. \\

35 & 16-bit signed integer converted to float. \\

64 & half precision floating point. \\

65 & single precision floating point. \\

66 & double precision floating point. \\

100 & determined by operand type. \\

in & a number prefixed by 'i' indicates an implicit value.

The implicit immediate operand with this value does not need to be written in the assembly code. \\

\hline

\end{longtable}

Jump instructions are listed on page \pageref{table:controlTransferInstructions}. All other categories of instructions are listed in the following tables.

\section{List of multi-format instructions}

The following list covers general instructions that can be coded in most or all of the formats

assigned to multi-format instructions.

\begin{longtable} {|p{25mm}|p{12mm}|p{12mm}|p{100mm}|}

\caption{

List of multi-format instructions}

\label{table:ListOfMultiFormatInstructions} \\

\endfirsthead

\endhead

\hline

\bfseries Instruction & \bfseries OP1 & \bfseries Source ope-rands & \bfseries Description \\

\hline

nop          &  0 & 0 & No operation. \\

store        &  1 & 1 & Store value to memory. \\

move         &  2 & 1 & Copy value. \\

prefetch     &  3 & 1 & Prefetch from memory. \\

sign\_extend &  4 & 1 & Sign-extend smaller integer to 64 bits. \\

sign\_extend\_ add & 5 & 2 & Sign-extend smaller integer to 64 bits and add 64-bit register. \\

compare      &  7 & 2 & Compare. Uses condition codes, see p. \pageref{table:conditionCodesForCompareInstruction}. \\

add          &  8 & 2 & src1 + src2. \\

sub          &  9 & 2 & src1 - src2. \\

sub\_rev     & 10 & 2 & src2 - src1. \\

mul          & 11 & 2 & src1 $\cdot$ src2. \\

mul\_hi      & 12 & 2 & (src1 $\cdot$ src2) $>>$ OS, signed (integer only). \\

mul\_hi\_u   & 13 & 2 & (src1 $\cdot$ src2) $>>$ OS, unsigned (integer only). \\

div          & 14 & 2 & src1 / src2, signed division (optional for integer vectors). \\

div\_u       & 15 & 2 & src1 / src2, unsigned integer division (optional for vectors). \\

div\_rev     & 16 & 2 & src2 / src1, signed division (optional for integer vectors). \\

rem          & 18 & 2 & Modulo or remainder, signed (optional for integer vectors). \\

rem\_u       & 19 & 2 & Modulo or remainder, unsigned (optional for integer vectors). \\

min          & 20 & 2 & Signed minimum. \\

min\_u       & 21 & 2 & Minimum. unsigned for integers, abs for f.p. \\

max          & 22 & 2 & Signed maximum. \\

max\_u       & 23 & 2 & Maximum. unsigned for integers, abs for f.p. \\

and          & 26 & 2 & src1 \& src2. \\

or           & 27 & 2 & src1 \textbar{} src2. \\

xor          & 28 & 2 & src1 \^{} src2. \\

mul\_2pow    & 32 & 2 & src1 * $2^{src2}$. Multiply by integer power of 2. Floating point only. \\

shift\_left  & 32 & 2 & src1 $<<$ src2. Shift left. Integer only. \\

rotate       & 33 & 2 & Rotate left if src2 positive, right if negative. \\

shift\_right\_s & 34 & 2 & src1 $>>$ src2. Integer shift right with sign extension.\\

shift\_right\_u & 35 & 2 & src1 $>>$ src2. Integer shift right with zero extension.\\

clear\_bit   & 36 & 2 & Clear bit. src1 \& \~{} (1 $<<$ src2). \\

set\_bit     & 37 & 2 & Set bit. src1 \textbar{} (1 $<<$ src2). \\

toggle\_bit  & 38 & 2 & Toggle bit. src1 \^{} (1 $<<$ src2). \\

test\_bit    & 39 & 2 & Test single bit. (src1 $>>$ src2) \& 1. \\

test\_bits\_and & 40 & 2 & Test if all indicated bits are 1. (src1 \& src2) == src2 \\test\_bits\_or   & 41 & 2 & Test if at least one indicated bit is 1. (src1 \& src2) != 0 \\

add          & 44 & 2 & src1 + scr2 (float16. optional). \\

sub          & 45 & 2 & src1 - scr2 (float16. optional). \\

mul          & 46 & 2 & src1 * scr2 (float16. optional). \\

mul\_add     & 48 & 3 & $\pm$ src1 $\cdot$ src2 $\pm$ src3 (float16. optional). \\

mul\_add     & 49 & 3 & $\pm$ src1 $\cdot$ src2 $\pm$ src3 (optional). \\

mul\_add2    & 50 & 3 & $\pm$ src1 $\cdot$ src3 $\pm$ src2 (optional). \\

add\_add     & 51 & 3 & $\pm$ src1 $\pm$ src2 $\pm$ src3 (optional). \\

select\_bits & 52 & 3 & src1 \& src3 \textbar{} src2 \& \~{}src3 \\

funnel\_shift & 53 & 3 & Concatenate src1 and src2 and shift right by src3. \\

userdef56 - userdef62

             & 56-62 & 2 & Reserved for user-defined instructions. \\

undef        & 63 & 2 & Undefined code. Generates trap. \\

\hline

\end{longtable}

\section{List of single-format instructions}

These instructions are mostly available in only one or a few formats.

\begin{longtable} {|p{25mm}|p{14mm}|p{10mm}|p{95mm}|}

\caption{List of single-format instructions with general purpose registers}

\label{table:ListOfSingleFormatInstructionsGP} \\

\endfirsthead

\endhead

\hline

\bfseries Instruction & \bfseries Format &\bfseries OP1 & \bfseries Description \\

\hline

move          & 1.1 C &  0 & Move 16-bit sign-extended constant to 32-bit general purpose register. \\

move          & 1.1 C &  1 & Move 16-bit sign-extended constant to 64-bit general purpose register. \\

move          & 1.1 C &  3 & Move 16-bit zero-extended constant to 64-bit general purpose register. \\

move          & 1.1 C & 4  & RD = IM2 \textless\textless{} IM1. Sign-extend IM2 to 32 bits and shift left by the unsigned value IM1. \\

move          & 1.1 C & 5  & RD = IM2 \textless\textless{} IM1. Sign-extend IM2 to 64 bits and shift left by the unsigned value IM1. \\

add           & 1.1 C &  6  & Add 16-bit sign-extended constant to 32-bit general purpose register.. \\

mul           & 1.1 C &  8  & Multiply 32-bit general purpose register by 16-bit sign-extended constant. \\

add           & 1.1 C & 10  & RD += IM2 \textless\textless{} IM1. Sign-extend IM2 to 32 bits, shift left by the unsigned value IM1, add to RD. \\

add           & 1.1 C & 11  & RD += IM2 \textless\textless{} IM1. Sign-extend IM2 to 64 bits, shift left by the unsigned value IM1, add to RD. \\

and           & 1.1 C & 12  & RD \&= IM2 \textless\textless{} IM1. Sign-extend IM2 to 32 bits, shift left by the unsigned value IM1, AND with RD. \\

and           & 1.1 C & 13  & RD \&= IM2 \textless\textless{} IM1. Sign-extend IM2 to 64 bits, shift left by the unsigned value IM1, AND with RD. \\

or            & 1.1 C & 14  & RD \textbar{}= IM2 \textless\textless{} IM1. Sign-extend IM2 to 32 bits, shift left by the unsigned value IM1, OR with RD. \\

or            & 1.1 C & 15  & RD \textbar{}= IM2 \textless\textless{} IM1. Sign-extend IM2 to 64 bits, shift left by the unsigned value IM1, OR with RD. \\

xor           & 1.1 C & 16  & RD \^{}= IM2 \textless\textless{} IM1. Sign-extend IM2 to 32 bits, shift left by the unsigned value IM1, XOR with RD. \\

xor           & 1.1 C & 17  & RD \^{}= IM2 \textless\textless{} IM1. Sign-extend IM2 to 64 bits, shift left by the unsigned value IM1, XOR with RD. \\

add           & 1.1 C & 18  & RD += (IM1,IM2) \textless\textless{} 16. Shift 16-bit zero-extended constant left by 16 and add to 32-bit general purpose register. \\

abs           & 1.8 B &  0  & Absolute value of integer. IM1 determines handling of overflow: 0: wrap around, 1: saturate, 2: zero. \\

%shift\_add    & 1.8 B &  1  & Shift and add. RD += RS \textless\textless{} IM1 \\

bitscan       & 1.8 B &  2 & Bit scan forward or reverse. Find index to first or last set bit. \\

roundp2       & 1.8 B &  3 & Round up or down to nearest power of 2. \\

popcount      & 1.8 B &  4 & Count the number of bits that are 1.\\

read\_spec    & 1.8 B & 32  & Read special register RS into g. p. register RD. \\

write\_spec   & 1.8 B & 33  & Write g. p. register RS to special register RD. \\

read\_capabi-lities & 1.8 B & 34  & Read capabilities register RS into g. p. register RD. \\

write\_capabi-lities & 1.8 B & 35  & Write g. p. register RS to capabilities register RD. \\

read\_perf    & 1.8 B & 36  & Read performance counter. \\

read\_perfs   & 1.8 B & 37  & Read performance counter, serializing. \\

read\_sys     & 1.8 B & 38  & Read system register RS into g. p. register RD. \\

write\_sys    & 1.8 B & 39  & Write g. p. register RS to system register RD. \\

push          & 1.8 B & 56  & Push g. p. register RS to stack with pointer RD. \\

pop           & 1.8 B & 57  & Pop g. p. register RS from stack with pointer RD. \\

input         & 1.8 B & 62  & Read RD from input port with address IM1 or RS. (privileged instruction) \\

output        & 1.8 B & 63  & Write RD to output port with address IM1 or RS. (privileged instruction) \\

truth\_tab3   & 2.0.6 E & 8.1 & Boolean function of three inputs, given by a truth table. \\

move\_bits    & 2.0.7 E & 0.1 & Replace one or more contiguous bits at one position of RS with contiguous bits from another position of RT. Optional. \\

move          & 2.9 A &  0  & Load 32-bit constant into the high part of a general purpose register. The low part is zero. RD = IM2 \textless\textless{} 32. \\

insert\_hi    & 2.9 A &  1  & Insert 32-bit constant into the high part of a general purpose register, leaving the low part unchanged.

RD = (RT \& 0xFFFFFFFF) \textbar{} (IM2 \textless\textless{} 32). \\

add           & 2.9 A &  2  & Add zero-extended 32-bit constant to general purpose register. \\

sub           & 2.9 A &  3  & Subtract zero-extended 32-bit constant from general purpose register. \\

add           & 2.9 A &  4  & Add 32-bit constant to high part of general purpose register. RD = RT + (IM2 \textless\textless{} 32). \\

and           & 2.9 A &  5  & AND high part of general purpose register with 32-bit constant. RD = RT \& (IM2 \textless\textless{} 32). \\

or            & 2.9 A &  6  & OR high part of general purpose register with 32-bit constant. RD = RT \textbar{} (IM2 \textless\textless{} 32). \\

xor           & 2.9 A &  7  & XOR high part of general purpose register with 32-bit constant. RD = RT \^{} (IM2 \textless\textless{} 32). \\

address       & 2.9 A & 32  & RD = RT + IM2, RT can be THREADP (28), DATAP (29) or IP (30). \\

\hline

\end{longtable}

\begin{longtable} {|p{25mm}|p{14mm}|p{10mm}|p{95mm}|}

\caption{List of single-format instructions with vector registers and mixed register types}

\label{table:ListOfSingleFormatInstructionsVector} \\

\endfirsthead

\endhead

\hline

\bfseries Instruction & \bfseries Format &\bfseries OP1. OP2 & \bfseries Description \\

\hline

get\_len      & 1.2 A &  0 & Get length of vector register RT into general purpose register RD. \\

get\_num      & 1.2 A &  1 & Get length of vector register RT divided by the operand size. \\

set\_len      & 1.2 A &  2 & RD = vector register RS with length changed to value of RT. \\

set\_num      & 1.2 A &  3 & Change the length of vector register RS to RT$\cdot$OS. \\

insert        & 1.2 A &  4 & Replace one element in vector RD, starting at offset RT$\cdot$OS, with scalar RS. \\

extract       & 1.2 A & 5 & Extract one element from vector RS, starting at offset RT$\cdot$OS, with size OS into scalar in vector register RD. \\

broad         & 1.2 A & 6 & Broadcast first element of vector RS into all elements of RD with length RT bytes. \\

compress\_ sparse& 1.2 A &  8 & Compress sparse vector elements indicated by mask bits into contiguous vector. (optional). \\

expand\_sparse& 1.2 A & 9 & Expand contiguous vector into sparse vector with positions indicated by mask bits. RT = length of output vector. (optional). \\

bits2bool     & 1.2 A & 12 & The lower n bits of RT are unpacked into a boolean vector RD with length RS, with one bit in each element, where n = RS / OS. \\

shift\_expand & 1.2 A & 16 & Shift vector RS up by RT bytes and extend the vector length by RT. The lower RT bytes of RD will be zero. \\

shift\_reduce & 1.2 A & 17 & Shift vector RS down RT bytes and reduce the length by RT. The lower RT bytes are lost. \\

shift\_up     & 1.2 A & 18 & Shift elements of vector RS up RT elements. The lower RT elements of RD will be zero, the upper RT elements are lost. \\

shift\_down   & 1.2 A & 19 & Shift elements of vector RS down RT elements. The upper RT elements of RD will be zero, the lower RT elements are lost. \\

%rotate\_up  & 1.2 A & 20 & Rotate vector up one element. Optional. \\

%rotate\_down  & 1.2 A & 21 & Rotate vector down one element. Optional. \\

div\_ex    & 1.2 A & 24 & Divide vector of double-size signed integers RS by signed integers RT. RS has element size 2$\cdot$OS. These are divided by the even numbered

elements of RT with size OS. The truncated results are stored in

the even-numbered elements of RD. The remainders are stored in

the odd-numbered elements of RD. (Optional for vectors). \\

div\_ex\_u    & 1.2 A & 25 & Same, with unsigned integers. (Optional for vectors). \\

mul\_ex       & 1.2 A & 26 & Multiply even-numbered signed integer vector elements to double size result. \\

mul\_ex\_u    & 1.2 A & 27 & Multiply even-numbered unsigned integer vector elements to double size result. \\

sqrt          & 1.2 A & 28 & Square root (floating point, optional). \\

add\_ss       & 1.2 A & 32 & Add integer vectors, signed with saturation (optional). \\

add\_us       & 1.2 A & 33 & Add integer vectors, unsigned with saturation (optional). \\

sub\_ss       & 1.2 A & 34 & Subtract integer vectors, signed with saturation (optional). \\

sub\_us       & 1.2 A & 35 & Subtract integer vectors, unsigned with saturation (optional). \\

mul\_ss       & 1.2 A & 36 & Multiply integer vectors, signed with saturation (optional). \\

mul\_us       & 1.2 A & 37 & Multiply integer vectors, unsigned with saturation (optional). \\

add\_oc       & 1.2 A & 38 & add with overflow check (optional). \\

sub\_oc       & 1.2 A & 39 & subtract with overflow check (optional). \\

mul\_oc       & 1.2 A & 40 & multiply with overflow check (optional). \\

div\_oc       & 1.2 A & 41 & divide with overflow check (optional). \\

add\_c        & 1.2 A & 42 & Add with carry. Vector has two elements. The upper element is used as carry on input and output (optional). \\

sub\_b        & 1.2 A & 43 & Subtract with borrow. Vector has two elements. The upper element is used as borrow on input and output (optional). \\

read\_spev    & 1.2 A & 56 & read special vector register. Length RT. \\

read\_call\_ stack & 1.2 A & 58 & read internal call stack. RD = vector register destination of length RS, RT-RS = internal address (privileged instruction). \\

write\_call\_ stack & 1.2 A & 59 & write internal call stack. RD = vector register source of length RS, RT-RS = internal address (privileged instruction). \\

read\_memory\_ map & 1.2 A & 60 & read memory map. RD = vector register destination of length RS, RT-RS = internal address (privileged instruction). \\

write\_memory\_ map & 1.2 A & 61 & write memory map. RD = vector register source of length RS, RT-RS = internal address (privileged instruction). \\

input         & 1.2 A & 62 & read from input port. RD = vector register, RT = port address, RS = vector length (privileged instruction). \\

output        & 1.2 A & 63 & write to output port. RD = vector register source operand, RT = port address, RS = vector length (privileged instruction). \\

gp2vec        & 1.3 B &  0 & Move value of general purpose register RS to scalar in vector register RD. \\

vec2gp        & 1.3 B &  1 & Move value of first element of vector register RS to general purpose register RD. \\

make\_sequen-ce& 1.3 B & 3 & Make a vector with RS sequential numbers. First value is IM1. \\

insert        & 1.3 B &  4 & Replace one element in vector RD, starting at offset IM1$\cdot$OS, with first element in RS. \\

extract       & 1.3 B & 5 & Extract one element from vector RS, starting at offset IM1$\cdot$OS into a scalar in vector register RD. \\

compress      & 1.3 B  &  6 & Compress vector to half the length and half the element size. Double precision $\rightarrow$ single precision, 64-bit

integer $\rightarrow$ 32-bit integer, etc. \\

expand        & 1.3 B &  7 & Expand vector to the double length and the double element size. Half precision $\rightarrow$ single precision, 32-bit integer $\rightarrow$ 64-bit integer, etc. \\

float2int     & 1.3 B & 12 & Conversion of floating point to integer with the same operand size. The rounding mode is specified in IM1. \\

int2float     & 1.3 B & 13 & Conversion of integer to floating point with same operand size. \\

round         & 1.3 B & 14 & Round floating point to integer in floating point  representation. The rounding mode is specified in IM1. \\

round2n       & 1.3 B & 15 & Round to nearest multiple of $2^n$. \newline

RD = $2^n\cdot$ round($2^{-n}\cdot$ RS). $n$ is a signed integer constant in IM1 (optional). \\

abs           & 1.3 B & 16 & Absolute value of integer. IM1 determines handling of overflow: 0: wrap around, 1: saturate, 2: zero. \\

fp\_category  & 1.3 B & 17 & Check if floating point numbers belong to the categories indicated by constant. \\

broad         & 1.3 B & 18 & Broadcast 8-bit constant into all elements of RD with length RS (31 in RS field gives scalar output). \\

broadcast\_ max & 1.3 B & 19 & Broadcast 8-bit constant into all elements of RD with maximum vector length. \\

byte\_reverse & 1.3 B & 20 & Reverse the order of bytes in each element of vector. \\

bit\_reverse  & 1.3 B & 20 & Reverse the order of bits in each element of vector (optional). \\

bitscan       & 1.3 B & 21 & Bit scan forward or reverse. Find index to lowest set bit. \\

popcount      & 1.3 B & 22 & Count the number of bits that are 1 (optional for vectors). \\

bool2bits     & 1.3 B & 25 & A boolean vector with n elements is packed into the lower n bits of RD, taking bit 0 of each element. The length of RD is at least sufficient to contain n bits. \\

bool\_reduce  & 1.3 B & 26 & An integer vector is reduced by combining bit 0 of all elements. The output is a scalar integer where bit 0 is the

AND combination of all the bits, and bit 1 is the OR combination of

all the bits. The remaining bits are reserved for future use. \\

category\_ reduce & 1.3 B & 26 & A floating point vector is reduced to a scalar integer where each bit indicates that the source vector contains at least one element in a certain category, such as NAN, zero, normal positive, etc. \\

push          & 1.3 B & 56  & Push vector register RS to stack with pointer RD. \\

pop           & 1.3 B & 57  & Pop vector register RS from stack with pointer RD. \\

clear         & 1.3 B & 58  & Clear vector register RS. \\

move          & 1.4 C &  0 & Move 16 bit integer constant to 16-bit scalar (optional). \\

add           & 1.4 C &  1 & Add broadcasted 16 bit constant to 16-bit vector elements (optional). \\

and           & 1.4 C &  2 & AND broadcasted 16 bit constant with 16-bit vector elements (optional). \\

or            & 1.4 C &  3 & OR broadcasted 16 bit constant with 16-bit vector elements (optional). \\

xor           & 1.4 C &  4 & XOR broadcasted 16 bit constant with 16-bit vector elements (optional). \\

move          & 1.4 C &  8 & RD = IM2 \textless\textless{} IM1. Sign-extend IM2 to 32 bits and shift left by the unsigned value IM1 to make 32 bit scalar (optional). \\

move          & 1.4 C &  9 & RD = IM2 \textless\textless{} IM1. Sign-extend IM2 to 64 bits and shift left by the unsigned value IM1 to make 64 bit scalar (optional). \\

add           & 1.4 C & 10 & RD += IM2 \textless\textless{} IM1. Add broadcast shifted signed constant to 32-bit vector elements (optional). \\

add           & 1.4 C & 11 & RD += IM2 \textless\textless{} IM1. Add broadcast shifted signed constant to 64-bit vector elements (optional). \\

and           & 1.4 C & 12 & RD \&= IM2 \textless\textless{} IM1. AND broadcast shifted signed constant with 32-bit vector elements (optional). \\

and           & 1.4 C & 13 & RD \&= IM2 \textless\textless{} IM1. AND broadcast shifted signed constant with 64-bit vector elements (optional). \\

or            & 1.4 C & 14 & RD \textbar{}= IM2 \textless\textless{} IM1. OR broadcast shifted signed constant with 32-bit vector elements (optional). \\

or            & 1.4 C & 15 & RD \textbar{}= IM2 \textless\textless{} IM1. OR broadcast shifted signed constant with 64-bit vector elements (optional). \\

xor           & 1.4 C & 16 & RD \^{}= IM2 \textless\textless{} IM1. XOR broadcast shifted signed constant with 32-bit vector elements (optional). \\

xor           & 1.4 C & 17 & RD \^{}= IM2 \textless\textless{} IM1. XOR broadcast shifted signed constant with 64-bit vector elements (optional). \\

move          & 1.4 C & 32 & Move converted half precision floating point constant to single

precision scalar (optional). \\

move          & 1.4 C & 33 & Move converted half precision floating point constant to double

precision scalar (optional). \\

add           & 1.4 C & 34 & Add broadcast half precision floating point constant to single

precision vector (optional). \\

add           & 1.4 C & 35 & Add broadcast half precision floating point constant to double

precision vector (optional). \\

mul           & 1.4 C & 36 & Multiply broadcast half precision floating point constant with single precision vector (optional). \\

mul           & 1.4 C & 37 & Multiply broadcast half precision floating point constant with double precision vector (optional). \\

add\_h        & 1.4 C & 40 & add constant to half precision vector (optional). \\

mul\_h        & 1.4 C & 41 & multiply half precision vector with constant (optional). \\

concatenate   & 2.2.6 E & 0.1 & A vector RU of length RT and a vector RS of length RT are concatenated into a vector RD of length 2$\cdot$RT. \\

permute       & 2.2.6 E & 1.1 & The vector elements of RU are permuted within each block of size RT bytes, using indices in RS. Each index is relative to the

beginning of a block. An index out of range produces zero. The

maximum block size is implementation dependent. \\

interleave    & 2.2.6 E & 2.1 & Interleave elements of vectors RU and RS of length RT/2 to produce vector RD of length RT. Even-numbered elements of the destination come from RU and odd-numbered elements from RS. (optional). \\

truth\_tab3   & 2.2.6 E & 8.1 & Boolean function of three inputs, given by a truth table. \\

move\_bits    & 2.2.7 E & 0.1 & Replace one or more contiguous bits at one position of RS with contiguous bits from another position of RT. Optional \\

mask\_length  & 2.2.7 E & 1.1 & Make mask with true in the first RT bytes. Option bits in IM2. \\

repeat\_block  & 2.2.7 E & 8.1 & Repeat a block of data to make a longer vector. RS is input vector containing data block to repeat. IM2 is length in bytes of the block to repeat (must be a multiple of 4). RT is the length of destination vector RD. (optional). \\

repeat\_within \_blocks & 2.2.7 E & 9.1 & Broadcast the first element of each block of data in a vector to the entire block. RS is input vector containing data blocks. IM2 is length in bytes of each block (must be a multiple of the operand size). RT is length of destination vector RD. The operand size must be at least 4 bytes. (optional). \\

load\_hi      & 2.6 A & 0 & Make vector of two elements. dest[0] = 0, dest[1] = IM2. \\

insert\_hi    & 2.6 A & 1 & Make vector of two elements. dest[0] = src1[0], dest[1] = IM2. \\

make\_mask    & 2.6 A & 2 & Make vector where bit 0 of each element comes from bits in IM2, the remaining bits come from RT. \\

replace       & 2.6 A & 3 & Replace elements in RT by constant IM2. \\

replace\_even & 2.6 A & 4 & Replace even-numbered elements in RT by constant

IM2. \\

replace\_odd  & 2.6 A & 5 & Replace odd-numbered elements in RT by constant

IM2. \\

broad         & 2.6 A & 6 & Broadcast 32-bit or float32 constant into all elements of RD with length RT (31 in RT field gives scalar output). \\

permute       & 2.6 A & 8 & The vector elements of RS are permuted within each block of size RT bytes. The 4$\cdot$n bits of IM2 are used as index with 4 bits for

each element in blocks of size n. The same pattern is used in each

block. The number of elements in each block, n = RT / OS $\leq$ 8. \\

replace       & 3.1 A & 32 & Replace elements in RT by constant IM2,IM3. \\

broad         & 3.1 A & 33 & Broadcast 64-bit or float64 constant into all elements of RD with length RT (31 in RT field gives scalar output). \\

\hline

\end{longtable}

\begin{longtable} {|p{25mm}|p{14mm}|p{10mm}|p{95mm}|}

\caption{List of single-format instructions with memory operands.}

\label{table:ListOfSingleFormatInstructionsMemory} \\

\endfirsthead

\endhead

\hline

\bfseries Instruction & \bfseries Format &\bfseries OP1, OP2 & \bfseries Description \\

\hline

store         & 2.5 B &  8 & Store 32-bit constant IM2 to memory operand [RS+IM1] (optional). \\

fence         & 2.5 B & 16 & Memory fence at address [RS+IM2]. read, write or full indicated by IM1.\\

compare\_swap & 2.5 B & 18 & Atomic compare and exchange with address [RS+IM2].\\

read\_insert  & 2.5 A & 32 & Replace one element in vector RD, starting at offset

RT$\cdot$OS, with scalar memory operand [RS+IM2] (optional).  \\

extract\_store& 2.5 A & 40 & Extract one element from vector RD, starting at offset RT$\cdot$OS, with size OS into memory operand [RS+IM2] (optional). \\

\hline

\end{longtable}

\vspace{4mm}

\section{List of control transfer instructions}

\begin{longtable}

{|p{12mm}|p{16mm}|p{60mm}|p{55mm}|}

%\nopagebreak

\caption{Condition codes for control transfer instructions with integer operands in general purpose registers }

\label{table:controlTransferInstructions}

\endfirsthead

\endhead

\hline

\bfseries OPJ & \bfseries bit 0 \newline of OPJ & \bfseries Instruction & \bfseries Comment \\

\hline

0-7 & part of offset & Unconditional jump with 24-bit offset (jump) & Format 1.7 D. Bit 0-2 of OPJ are part of offset \\

\hline

8-15 & part of offset & Unconditional call with 24-bit offset (call) & Format 1.7 D.  Bit 0-2 of OPJ are part of offset \\

\hline

0-1 & invert & sub/jump\_zero, \newline sub/jump\_nzero & Not format 1.7. Not floating point \\

\hline

2-3 & invert & sub/jump\_neg, \newline sub/jump\_nneg & Not format 1.7. Not floating point  \\

\hline

4-5 & invert & sub/jump\_pos, \newline sub/jump\_npos & Not format 1.7. Not floating point \\

\hline

6-7 & invert & sub/jump\_overfl, \newline sub/jump\_noverfl & Not format 1.7. Not floating point \\

\hline

8-9 & invert & sub/jump\_borrow, \newline sub/jump\_nborrow & Not format 1.7. Not floating point \\

\hline

10-11 & invert & and/jump\_zero \newline and/jump\_nzero & Not format 1.7 \\

\hline

12-13 & invert & or/jump\_zero \newline or/jump\_nzero & Not format 1.7 \\

\hline

14-15 & invert & xor/jump\_zero, \newline xor/jump\_nzero & Not format 1.7 \\

\hline

16-17 & invert & add/jump\_zero, \newline add/jump\_nzero & Not floating point \\

\hline

18-19 & invert & add/jump\_neg, \newline add/jump\_nneg & Not floating point \\

\hline

20-21 & invert & add/jump\_pos, \newline add/jump\_npos & Not floating point \\

\hline

22-23 & invert & add/jump\_overfl, \newline add/jump\_noverfl & Not floating point \\

\hline

24-25 & invert & add/jump\_carry, \newline add/jump\_ncarry & Not floating point \\

\hline

26-27 & invert & test\_bit/jump\_true, \newline test\_bit/jump\_false &  \\

\hline

28-29 & invert & test\_bits\_and/jump\_true, \newline test\_bits\_and/jump\_false &  \\

\hline

30-31 & invert & test\_bits\_or/jump\_true, \newline test\_bits\_or/jump\_false & \\

\hline

32-33 & invert & compare/jump\_equal, \newline compare/jump\_nequal & \\

\hline

34-35 & invert & compare/jump\_sbelow, \newline compare/jump\_saboveeq &  \\

\hline

36-37 & invert & compare/jump\_sabove, \newline compare/jump\_sbeloweq &  \\

\hline

38-39 & invert & compare/jump\_ubelow, \newline compare/jump\_uaboveeq &  \\

\hline

40-41 & invert & compare/jump\_uabove, \newline compare/jump\_ubeloweq & \\

\hline

42-47 & invert & Reserved for future use. & \\

\hline

48-49 & invert & increment\_compare/jump\_below, \newline /jump\_aboveeq & \\

\hline

50-51 & invert & increment\_compare/jump\_above, \newline /jump\_beloweq & \\

\hline

52-53 & invert & sub\_maxlen/jump\_pos, \newline sub\_maxlen/jump\_npos &  \\

\hline

54-57 &  & Reserved for future use. & \\

\hline

58-59 & 0 jump \newline 1 call & Indirect jump or call with memory operand. & Format 1.6 B and 2.5.2. \\

\hline

58-59 & 0 jump \newline 1 call & Unconditional direct jump or call & 2.5.4, and 3.1.1. \\

\hline

60-61 & 0 jump\_ relative \newline 1 call\_ relative & Jump or call with relative address in memory, table index, and arbitrary reference point &

Format 1.6 A and 2.5.2 \\

\hline

60-61 & 0 jump \newline 1 call & Indirect jump or call to value of register & Format 1.7 C \\

\hline

62 & 0 & return  & Format 1.6 C  \\

\hline

62 & 0 & sys\_return & Format 1.7 C  \\

\hline

63 & 1 & sys\_call. ID in register & Format 1.6 A \\

\hline

63 & 1 & sys\_call. ID in constants & Format 2.5.7 and 3.1.1. \\

\hline

63 & 1 & trap or filler & Format 1.7 C \\

\hline

63 & 1 & Conditional traps & Format 2.5.5. \\

\hline

\end{longtable}

\begin{longtable}

{|p{10mm}|p{14mm}|p{65mm}|p{40mm}|}

%\nopagebreak

\caption{Condition codes for control transfer instructions with floating point operands in vector registers }

\label{table:controlTransferInstructionsFloat}

\endfirsthead

\endhead

\hline

OPJ & bit 0 \newline of OPJ & Instruction & Comment \\

\hline

32-33 & invert & compare/jump\_equal, \newline compare/jump\_nequal & false if unordered \\

\hline

0-1 & invert & compare/jump\_equal\_uo, \newline compare/jump\_nequal\_uo & true if unordered \\

\hline

34-35 & invert & compare/jump\_below, \newline compare/jump\_aboveeq & false if unordered \\

\hline

2-3 & invert & compare/jump\_below\_uo, \newline compare/jump\_aboveeq\_uo & true if unordered \\

\hline

36-37 & invert & compare/jump\_above, \newline compare/jump\_beloweq & false if unordered \\

\hline

4-5 & invert & compare/jump\_above\_uo, \newline compare/jump\_beloweq\_uo & true if unordered \\

\hline

38-39 & invert & compare/jump\_abs\_below, \newline compare/jump\_abs\_aboveeq & false if unordered \\

\hline

6-7 & invert & compare/jump\_abs\_below\_uo, \newline compare/jump\_abs\_aboveeq\_uo & true if unordered \\

\hline

40-41 & invert & compare/jump\_abs\_above, \newline compare/jump\_abs\_beloweq & false if unordered \\

\hline

8-9 & invert & compare/jump\_abs\_above\_uo, \newline compare/jump\_abs\_beloweq\_uo & true if unordered \\

\hline

24-25 & invert & fp\_category/jump\_true, \newline fp\_category/jump\_false &  \\

\hline

\multicolumn{4}{|c|}{} \\

\multicolumn{4}{|c|}{ The following instructions treat floating point operands as integers in vector registers: } \\

\multicolumn{4}{|c|}{} \\

\hline

10-11 & invert & and/jump\_zero \newline and/jump\_nzero & \\

\hline

12-13 & invert & or/jump\_zero \newline or/jump\_nzero &  \\

\hline

14-15 & invert & xor/jump\_zero, \newline xor/jump\_nzero &  \\

\hline

26-27 & invert & test\_bit/jump\_true, \newline test\_bit/jump\_false &  \\

\hline

28-29 & invert & test\_bits\_and/jump\_true, \newline test\_bits\_and/jump\_false &  \\

\hline

30-31 & invert & test\_bits\_or/jump\_true, \newline test\_bits\_or/jump\_false & \\

\hline

\end{longtable}

See page \pageref{descriptionOfControlTransferInstructions} for

detailed descriptions of control transfer instructions.

\end{document}