4.5. TIE Instructions

The byte-swapping function described in the previous chapter provides an excellent demonstration of the ability of new processor instructions to reduce cycle count. Figure 4.3 illustrates the byte-swap function, which converts a 32-bit word between big- and little-endian formats.

The nine instructions from the base Xtensa ISA that are required to perform this operation are:

Through TIE, it’s possible to define a BYTESWAP instruction that takes a 32-bit word from one of the processor’s general-purpose register-file entries, converts the word from one endian format to the other, and stores the result in another register-file entry. The TIE description to create this new instruction is remarkably short:

operation BYTESWAP {out AR outR, in AR inpR} { }
{
wire [31:0] reg_swapped = {inpR[7:0],inpR[15:8],inpR[23:16],inpR[31:24]};
     assign outR reg_swapped;
}

The operation section of a TIE description provides the name, format, and behavior of a TIE instruction. It is the simplest and most compact way to describe a new instruction. In some instances, it is the only section required to completely specify an instruction.

The interface to the BYTESWAP instruction is defined by the information contained in the first set of curly braces of the operation section:

operation BYTESWAP {out AR outR, in AR inpR} { }

Within the first set of braces, the argument outR specifies the destination entry in the AR register file for the result of the instruction. Argument inpR specifies the AR register-file entry that provides the source operand for the instruction. The second set of braces in the operation statement can be used to specify additional internal states for this operation extension but this feature isn’t used in this example.

The behavior of the BYTESWAP instruction is defined within the next set of curly braces:

{
wire [31:0] reg_swapped = {inpR[7:0],inpR[15:8],inpR[23:16],inpR[31:24]};
     assign outR = reg_swapped;
}

The first line in this group defines how the new machine instruction should compute the byte-swapped 32-bit value and assigns the result of the operation to a temporary variable named reg_swapped. Note that the values of the intermediate wires, states, and registers are visible in the tailored Xtensa debugger for a processor incorporating this instruction using the debugger’s info tie_wires command. This feature greatly facilitates the debugging of TIE instructions in a software environment. The second line above assigns the byte-swapped value to the output argument outR.

This 2-line definition is all that’s required to add an instruction to the Xtensa processor core. From this single instruction description, the TIE Compiler within the Xtensa Processor Generator builds the necessary execution-unit hardware, adds it to the processor’s RTL description, and adds constructs in the software-development tool suite so that the new BYTESWAP instruction can be used as an intrinsic in a C or C++ program.

The BYTESWAP instruction is an example of a fused instruction. The operations of nine dependent instructions (each instruction in the sequence depends on results from previous instructions) have been fused into one. In this example, the circuitry required to implement the function is extremely simple. The execution unit for this instruction adds little more than some additional wires to scramble byte lanes, yet this new instruction speeds endian conversion by a factor of 9x. This example demonstrates that a small addition to a processor’s hardware can yield large performance gains.

In addition, the new BYTESWAP instruction doesn’t need the intermediate-result registers that are used in the 9-instruction byte-swap routine. Some additional gates are included in the processor’s instruction decoder to add the new instruction to the processor’s instruction set, but these few gates do not make the processor core noticeably larger than the base processor.

In general, most new instructions described in TIE use more complex operations than BYTESWAP. In addition to the wire statement used in the above example, the TIE language includes a large number of operators and built-in functions that are used to describe new instructions. These operators and function modules appear in Tables 4.2 and 4.3, respectively. Nearly any sort of data manipulation can be performed using the wire statement in conjunction with the other TIE operators and built-in functions.