KR100267089B1 - Single instruction multiple data processing with combined scalar/vector operations - Google Patents

Abstract

PURPOSE: A method for processing signal instruction multiple data with a scalar/vector computation is provided to use a single instruction multiple data architecture having a RISC type instruction set, so that a programmer easily adapts to a programming environment of a vector processor based on a user friendly programming environment of a universal processor. CONSTITUTION: A multimedia processor(100) includes a processing core(105) which includes a universal processor(110) and a vector processor(120). The processing core(105) is connected with the remaining portion of the multimedia processor(100) through a cache sub-system(130) which includes a SRAM(160 and 190), a ROM(170) and a cache controller(180). The cache controller(180) configures a SRAM(160) based on an instruction cache(162) and a data cache(164) for the processor(110) and configures the SRAM(190) based on the instruction processor(192) and the data cache(194) for the vector processor(120). An on-chip ROM(170) includes a data and instruction for the processor(110) and is configured as a cache. The cache sub-system(130) is connected with the processors(110 and 120) and is oriented to two system buses(140 and 150) and operates as a cache and switching station for the processors(110 and 120) and is connected with the device buses(140 and 150).

Description

Single instruction multiple data processing with a combination of scalar / vector operations

TECHNICAL FIELD The present invention relates to digital signal processors, and more particularly to processors for parallel processing of multiple data elements per instruction for multimedia functions such as video and audio encoding and decoding.

Programmable digital signal processors (DSPs) for multimedia applications such as real-time video encoding and decoding require significant processing power for large amounts of data that must be processed in a limited time. Several architectures for digital signal processors are known. General purpose architectures, such as those used in most microprocessors, typically require high frequencies to provide a DSP with sufficient margin to encode or decode in real time. This makes the DSP expensive.

Very long instruction word (VLIW) processors are DSPs with many functional units that perform differently, such as relatively simple tasks. A single instruction for a VLIW DSP can be longer than 128 bytes and has separate components that the individual functional units execute in parallel. VLIW DSPs have high computing power because many functional units can execute in parallel. VLIW DSPs are also relatively inexpensive because each functional unit is relatively small and simple. Problems with the VLIW DSP are inefficiencies in the processing of input / output control, communication with the host computer, and other functions that are not suitable for parallel execution on the functional units of the VLIW DSP. Incidentally, VLIW software is different from conventional software and can be difficult to develop because of the lack of programmers and programmers unfamiliar with the VLIW software architecture.

There is a need for multimedia applications that provide an affordable price, high computing power, and familiar programming environment.

In accordance with a feature of the present invention, a multimedia digital signal processor (DSP) includes a vector processor that manipulates vector data (ie, multiple data elements per operand) to provide high processing power. The processor uses a single instruction multiple data architecture with a RISC type instruction set. Programmers can easily adapt to the programming environment of the vector processor because most of them are familiar with the programming environment of the general-purpose processor they are familiar with.

The DSP has a set of general purpose vector registers. Each vector register has a fixed size, but is partitioned into individual data elements of user-selectable size. Thus, the number of data elements stored in the vector register depends on the size selected for the element. For example, a 32 byte register can be divided into 32 8 bit data elements, 16 16 bit data elements, or 8 32 bit data elements. The selection of data size and type is made by an instruction that processes the data associated with the vector register, and the execution data path for the instruction performs a number of parallel operations in accordance with the data size indicated by the instruction.

An instruction for a vector processor may have a vector register or a scalar register as an operand, and manipulates multiple data elements of the vector register in parallel to be highly computational. Exemplary instructions for a vector processor in accordance with the present invention include: coprocessor interface operations: flow control operations: load / store operations: and logic / arithmetic operations. The logical / arithmetic operation includes an operation that combines data elements from one vector register with corresponding data elements from one or more other vector registers to produce data elements of the resulting data vector. Other logic / arithmetic operations either synthesize several data elements from one or more vector registers or synthesize data elements and scalar amounts from the vector registers.

The extension of the vector processor architecture adds scalar registers, each containing a scalar data element. The combination of scalar and vector registers facilitates the expansion of the instructions of the vector processor set to include operations that combine each data element of the vector in parallel with the scalar value. For example, one instruction multiplies the vector's data elements by scalar values. Scalar registers also provide a place for storing a single data element to be extracted from or stored in a vector register. The scalar registers also facilitate the transfer of information between vector processors and coprocessors having architectures that provide only scalar registers, and efficient computation of addresses for load / store operations.

According to another feature of the invention, the vector register of the vector processor is organized into banks. Each bank is selected as a "current" bank, while the other bank is an "alternative" bank. The "current bank" bit in the control register of the vector processor indicates the current bank. To reduce the number of bits needed to identify a vector register, some instructions only provide a register number to identify the vector register in the current bank. The load / store instruction has additional bits to identify the vector register from either bank. Thus, the load / store operation may fetch data into the alternate bank during manipulation of the data in the current bank. This facilitates a software pipeline for image processing and graphics procedures, and reduces processor delay when fetching data because logical / arithmetic operations can be performed in a different order than load / store operations that access alternate register banks. . In another instruction, the replacement bank enables the use of a double-size vector register that includes a vector register from the current bank and a corresponding vector register from the replacement bank. Such double size registers can be identified from the command syntax. The control bits in the vector processor may be set such that the default vector size is either one or two vector registers. Alternate banks can also identify fewer explicit phrases in complex command syntax, such as shuffle, unshuffle, saturate, conditional moves with two source and two destination registers. Enable the use of operands.

Vector processors also implement new instructions such as quad, shuffle, unshuffle, pair-wise maximum and exchange, and segmentation. These instructions perform operations common to multimedia functions such as video encoding and decoding, and supersede two or more instructions that a set of other instructions would need to perform the same function. Thus, the vector processor instruction set improves the efficiency and speed of programs in multimedia applications.

1 is a block diagram of a multimedia processor according to an embodiment of the present invention.

2 is a block diagram of a vector processor for the multimedia processor of FIG.

3 is a block diagram of an instruction fetch unit for the vector processor of FIG.

4 is a block diagram of an instruction fetch unit for the vector processor of FIG.

5A, 5B, and 5C illustrate stages of an execution pipeline for register-to-register, load, and store instructions of the vector processor of FIG.

6A is a block diagram of an execution data path for the vector processor of FIG.

FIG. 6B is a block diagram of a register file for the execution data path of FIG. 6A. FIG.

6C is a block diagram of parallel processing logic for the execution data path of FIG. 6A.

7 is a block diagram of a load / store unit for the vector processor of FIG.

8 is a format diagram for an instruction set of a vector processor according to an embodiment of the present invention.

* Explanation of symbols for the main parts of the drawings

100: multimedia signal processor (MSP) 105: core processing

110: general purpose processor 120: vector processor

130: cache subsystem 140, 150: system bus

142: system timer 146: bit stream processor

148: interrupt controller 152: device interface

156 local bus interface 158 memory controller

162, 192: instruction cache 164, 194: data cache

180: cache control unit 220: decoder

230: scheduler 310: main command buffer

312: auxiliary instruction buffer 340, 342, 344: register

350: adder 420: control pipe

421 to 427: execution registers 514 and 515: execution stage

610: register files 612, 614, 616, 618: selection circuit

620, 626: multiplier 630: arithmetic logic

640: Accumulator

1 shows a block diagram of a multimedia signal processor (MSP) 100 in accordance with an embodiment of the present invention. The multimedia processor 100 includes a processing core 105 that includes a general purpose processor 110 and a vector processor 120. Processing core 105 is connected to the remainder of multimedia processor 100 via cache subsystem 130, which includes SRAM 160 and 190, ROM 170, and cache controller 180. The cache controller 180 may configure the SRAM 160 as the instruction cache 162 and the data cache 164 for the processor 110, and the instruction cache 192 and the data cache for the vector processor 120. SRAM 190 can be configured as 194.

On-chip ROM 170 includes data and instructions for processor 110 and may also be configured as a cache. In an exemplary embodiment, ROM 170 includes: reset and initialization procedures: self-test diagnostic procedures: interrupt and exception handlers: and subroutines for soundblast emulation: V, 34 subroutines for modem signal processing: general Telephony features: 1-D and 3-D graphics surroutine libraries: and subroutine libraries for audio and video standards such as MPEG-1, MPEG-2 H.261, H.263, G.728, and G.723. Include.

Cache subsystem 130 is connected to processors 110 and 120, directed to two system buses 140 and 150, and acts as both a cache and switching station for processors 110 and 120, and device buses 140 and 150). System bus 150 operates at a high clock frequency and provides a memory controller 158 that provides an interface for external local memory, a local bus of a host computer, direct memory access, and multiple analog-to-digital and digital-to-analog converters, respectively. , Local bus interface 156, DMA controller 154, and device interface 152. Connected to bus 140 are system timer 142, UART (Universal Asynchronous Receiver Transceiver) 144, bitstream processor 146, and interrupt controller 148. The patent application incorporated herein by reference, entitled “Multiprocessor Operations in Multimedia Signal Processors” and “Methods and Apparatuses for Processing Video Data,” discloses that the processors 110 and 120 have a cache subsystem 130. And the operation of example device and cache subsystem 130 for accessing buses 140 and 150 in more detail.

Processors 110 and 120 are structurally different for executing individual program threads and for more efficient execution of specific tasks assigned to them. Processor 110 is primarily for control functions, such as the execution of a real-time computing system, and similar functions that do not require many individual operations. Thus, the processor 110 does not require a high level of computing power and can be implemented using a conventional general purpose processor architecture. The vector processor 120 performs number crushing, which includes repetitive operations on data blocks that are common to multimedia processing. For high computational power and relatively simple programming, the vector processor 120 has a single instruction multimedia data (SIMD) architecture, and in an exemplary embodiment, most of the paths in the vector processor 120 support vector data manipulation. 288 or 576 bits wide. Incidentally, the instruction set for the vector processor 120 includes instructions which are particularly suitable for multimedia problems.

In an exemplary embodiment, processor 110 is a 32-bit RISC processor operating at 40 MHz and fits into the architecture of an ARM 7 processor that includes a set of registers as defined by the ARM 7 standard. The architecture and instructions set up for the ARM 7 RISC processor are described in "ARM 7 DM Data Sheet", Article No.: Advance RISC Machines Ltd. It is described in ARM DDI 0010G available from. The ARM 7 DM data sheet is incorporated herein by reference in its entirety. Appendix A describes extensions of the ARM 7 instructions in an example embodiment.

Vector processor 120 manipulates both vectors and scalars. In an exemplary embodiment, the vector data processor 120 is configured with a pipelined RISC engine operating at 80 MHz. The register of vector processor 120 has a 32 bit scalar register, a 32 bit special purpose register, two banks of 288 bit vector registers, and two vector accumulator registers of dual size (ie, 576 bits). Appendix C describes a register set for an example embodiment of vector processor 120. In an exemplary embodiment, processor 120 is identified in an instruction by 5-bit register numbers ranging from 0 to 31. There are also 64 288-bit vector registers consisting of two banks of 32 vector registers. Each vector register can be identified as a 1 bit bank number (0 or 1) and a 5 bit vector register number ranging from 0 to 31. Most instructions access the vector register in the current bank, indicated by the default bank bit CBANK stored in the control register VCSR of the vector processor 120. The second control bit VEC 4 by default indicates whether the register number identifies a dual size vector register containing registers from each bank. The syntax of the instruction distinguishes the register number identifying the vector register from the register number identifying the scalar register.

Each vector register can be partitioned into data elements of programmable size. Table 1 shows the data types that support data elements in the 288 bit vector register.

TABLE 1

Appendix D provides a detailed description of the data sizes and types supported in an exemplary embodiment of the present invention.

For the int 9 data type, the 9-bit byte is packed sequentially into the 288-bit vector register, but for other data types, every 9th bit of the 288-bit vector register is not used. The 288 bit vector register can hold 328 bit or 9 bit integer data elements, 16 16 bit integer data elements, or 8 32 bit integer or floating point elements. Incidentally, two vector registers may be combined in a data element of a double sized vector. In an exemplary embodiment of the present invention, by setting the control bit VEC 64 in the control and status register VCSR, the dual size (576 bits) is placed in mode VEC 64, which is the default size of the vector register.

The multimedia processor 100 also houses a set of 32-bit extension registers 115 that can access both processors 110 and 120. Appendix B describes an extension register set and its function in an exemplary embodiment of the present invention. The extension registers and scalar and special purpose registers of the vector processor 120 can access the processor 110 in some circumstances. Two special "user" extension registers have two read ports so that processors 110 and 120 can read the registers simultaneously. Other extension registers cannot be accessed at the same time.

Vector processor 120 has two optional states VP_RUN and VP_IDLE indicating whether vector processor 120 is running or idle. Processor 110 may read or write a scalar or special purpose register of vector processor 120 when vector processor 120 is in state VP_IDLE, while vector processor 120 may be in state VP_RUN while vector processor 120 is in state VP_RUN. The result of the processor 110 that reads or writes a register of) is not defined.

The extension of the ARM 7 instruction set for the processor 110 includes instructions to access the extension registers and scalar or special purpose registers of the vector processor 120. The instructions MFER and MFEP move data from the scalar or special purpose registers of the extension register and the vector processor 120 to the general purpose registers of the processor 110, respectively. The instructions MTER and MTEP move data from the general register of the processor 110 to the expansion register and the vector processor 120 and to the scalar or special purpose register, respectively. The TESTSET instruction reads an extension register and sets bit 30 of the extension register to all ones. The instruction TESTSET facilitates user / producer synchronization by setting bit 30 to signal processor 120 from which processor 110 has read (or used) the results. Other instructions for STARTVP and INTVP control the operating state of the vector processor 120.

The processor 110 acts as a master processor to control the operation of the vector processor 120. The use of asynchronous partitioning of control between processors 110 and 120 simplifies the synchronization problem of processors 110 and 120. Processor 110 initializes vector processor 120 by writing an instruction address to a program counter for vector processor 120 while vector processor 120 is in state VP_IDLE. Processor 110 then executes a STARTVP instruction that changes vector processor 120 to state VP_RUN. In state VP_RUN, vector processor 120 executes such instructions in parallel with processor 110 while fetching instructions through cache subsystem 130 and continuing execution of its program. When started, the vector processor 120 continues executing until it encounters an exception and, if the appropriate condition is met, executes a VCJOIN or VCINT instruction or is interrupted by the processor 120. The vector processor 120 writes the result to the extension register when the vector processor 120 reenters the state VP_IDLE and writes the result to the shared address space of the processors 110 and 120 or writes the result to the processor 110. The result of program execution is passed to the processor 120 by placing it in a scalar or special purpose register that is accessed by.

Vector processor 120 does not handle its own exception. Upon executing the instruction causing the exception, vector processor 120 enters state VP_IDLE and signals an interrupt request to processor 110 via a direct line. Vector processor 120 remains in state VP_IDLE until processor 110 executes another STARTVP instruction. The processor 110 reads the register VISRC of the vector processor 120 to determine the nature of the exception, handles the exception as much as possible by reinitializing the vector processor 120, and then restarts the exception if necessary. Responsible for directing 120.

The INTVP instruction executed by processor 110 causes vector processor 120 to enter idle state VP_IDLE. For example, the instruction INTVP can be used in a multitasking system that switches the vector processor from one task, such as video decoding, to another, such as sound card emulation.

The vector processor instructions VCINT and VCJOIN stop execution by the vector processor 120 if the condition indicated by the instruction is satisfied, place the vector processor 120 in state VP_IDLE and interrupt the request until such a request is masked. Flow control instructions issued to the processor 110. The program counter (special purpose register) of the vector processor 120 points to the instruction address after the VCINT or VCJOIN instruction. The processor 110 checks the interrupt source register VISRC of the vector processor 120 to determine whether the VCINT or VCJOIN instruction caused the interrupt request. Since vector processor 120 has a larger data bus and is more efficient at storing and restoring its registers, software executed by vector processor 120 must save and restore the registers during syntax conversion. The integrated patent pending invention titled "Efficient Syntax Storage and Recovery in Microprocessors" describes an exemplary system for syntax conversion.

2 is a main functional block diagram of an exemplary embodiment of the vector processor 120 of FIG. The vector processor 120 includes an instruction fetch unit (IFU) 210, a decoder 220, a scheduler 230, an execution data path 240, and a load / store unit (LSU) 250. IFU 210 fetches instructions and processes flow control instructions such as branches. The instruction decoder 220 decodes one instruction per cycle in the order of arrival from the IFU 210, and writes the decoded field value from the instruction to the FIFO of the scheduler 230. The scheduler 230 selects the field value issued to the execution control register if necessary for the execution stage of the operation. The issue selection depends on the availability and dependence of processing resources, such as execution data path 240 or load / store 250. Execution data path 240 executes logic / arithmetic instructions to manipulate vector or scalar data. The load / store 25 executes load / store instructions for accessing the address space of the vector processor 120.

3 shows a block diagram of an embodiment of an IFU 210 that includes an instruction buffer divided into a primary instruction buffer 310 and an auxiliary instruction buffer 312. Main buffer 310 accommodates eight consecutive instructions including instructions corresponding to the current program count. The auxiliary buffer 312 accommodates eight instructions that immediately follow the instructions of the buffer 310. IFU 210 also includes a branch target buffer 314 that contains eight consecutive instructions that include the target of other flow control instructions in buffer 310 or 312. In an exemplary embodiment, vector processor 120 uses a RISC type instruction set where each instruction is 32 bits long, and buffers 310, 312, and 314 are cached over a 256 bit instruction bus with an 8 x 32 bit buffer. Connected to subsystem 130. IFU 210 may load eight instructions in cache subsystem 130 into any buffer 310, 312, or 314 in a single clock cycle. Registers 340, 342, and 344 indicate the base addresses for instructions loaded into buffers 310, 312, and 314, respectively.

Multiplexer 332 selects the current instruction from main instruction buffer 310. If the current instruction is not a flow control instruction and the instruction stored in the instruction register 330 proceeds to the decode stage of execution, the current instruction is stored in the instruction register 330 and the program count is incremented. After selecting the last instruction in buffer 310 by incrementing the program count, the next set of 8 instructions is loaded into buffer 310. If buffer 312 contains some eight instructions, the contents of buffer 312 and register 342 are immediately moved to buffer 310 and register 340, and eight or more instructions are cache system 130. Is prefetched into the auxiliary buffer 312 from. Adder 350 determines the address of the next instruction set and the offset selected by multiplexer 352 from the base address in register 342. The resulting address from adder 350 is stored in register 342 after register 342 has moved or moved to register 340. The calculated address is also passed to the cache subsystem 130 as a request for eight instructions. If the previous call to the cache control system 130 did not provide the next 8 instructions to the buffer 312 requested by the buffer 310, the previously requested instruction was buffered when received from the cache subsystem 130. Are stored immediately at 310.

If the current instruction is a flow control instruction, IFU 210 processes the instruction by evaluating the condition for the flow control instruction and updating the program count following the flow control instruction. The IFU 210 is suspended if the condition is not determined because the previous instruction that could change the condition has not been completed. If no branch is taken, the program counter is incremented and the next instruction is selected as described above. If a branch is taken and branch target buffer 314 contains the target of the branch, the contents of buffer 314 and register 344 are moved to buffer 310 and register 340 so that IFU 210 Instructions may continue to be provided to decoder 220 without waiting for instructions from subsystem 130.

To prefetch instructions for branch target buffer 314, scanner 320 scans buffers 310 and 312 to find the next flow control instruction that follows the current program count. If a flow control instruction is found in the buffer 310 or 312, the scanner 320 sorts eight instructions from the base address of the buffer 310 or 312 containing the instruction, including the target address of the flow control instruction. Determine the offset with the set. Multiplexers 352 and 354 supply an offset from the flow control instruction and a base address from register 340 or 342 to adder 350 which generates a new base address for buffer 314. The new base address is then passed to the cache subsystem 130 which supplies 8 instructions to the branch target buffer 314.

In dealing with flow control instructions, such as the " reduce and condition branch " instructions VD1CBR, VD2CBR and VD3CBR, and the " change control register " If the IFU 210 finds an instruction that is not a flow control instruction, that instruction passes from the instruction register 330 to the decoder 220 there.

The decoder 220 decodes the instruction by writing the control value in the field of the FIFO buffer 410 of the scheduler 230 as shown in FIG. The FIFO buffer 410 can accommodate four rows of flip-flops, each of which can contain five fields of information for controlling the execution of one instruction. Rows 0 through 3 each hold information about the oldest to the most recent command, and the information in the FIFO buffer 410 shifts down to the lower row when the old information is removed as the command completes. The scheduler 230 issues an instruction to the execution stage by selecting the required field of the instruction to be loaded into the control pipe 420 containing the execution registers 421-427. Most instructions can be scheduled for issuing and executing out of order. In particular, the order of load / store operations and logic / arithmetic operations is arbitrary as long as there are no operand dependencies between load / store operations and logic / arithmetic operations. The comparison of field values in the FIFO buffer 410 indicates whether any operand dependencies exist.

5A shows six stage execution pipelines for instructions to perform register-to-register operations without accessing the address space of vector processor 120. In instruction fetch stage 511, IFU 210 fetches an instruction as described above. The fetch stage requires one clock cycle unless the IFU 210 is suspended by a delay in the cache subsystem 130 that provides pipeline delays, outstanding branch conditions, or prefetched instructions. In the decode stage 512, the decoder 220 decodes an instruction from the IFU 210 and writes information about the instruction to the scheduler 230. Decode stage 512 also requires one clock cycle as long as no row of FIFO 410 is available for a new operation. The operation may occur to the control pipe 420 during the first cycle in the FIFO 410, but may be delayed by the issuance of an older margin.

Execution data path 240 performs register-to-register operations and supplies data and addresses by load / store operations. 6A shows a block diagram of an embodiment of an execution data path 240 and is described in conjunction with execution stages 514, 515 and 515. Execution register 421 provides signals that identify two registers to register file 610 read in clock cycles during read stage 514. 6B shows a block diagram of a register file 610. Register file 610 has two read and two write ports to accommodate two reads and two writes each clock cycle. Each port includes select circuits 612, 614, 616 and 618 and 288 bit data buses 613, 615, 617 and 619. Selection circuits such as circuits 612, 614, 616, and 618 are known in the art and include address signals WRADDR1, WRADDR2, RDADDR1 or RDADDR2, which decoder 220 derives from a 5-bit register number that is typically extracted from an instruction. The bank bits from the instruction or control status register VCSR and instruction syntax indicating whether the register is a vector register or a scalar register are used. The data read may be routed through the multiplexer 656 to the load / store 250 or through the multiplexers 622 and 624 through the multiplier 640, the arithmetic logic 620, or the accumulator 640. Most of the operations read two registers, and the read stage 514 is completed in one cycle. However, some instructions, such as multiply and add instructions VMAD and instructions for manipulating double sized vectors, require data from more than two registers so that read stage 514 is longer than one clock cycle.

During execution stage 515, multiplier 620, arithmetic logic 630 and accumulator 640 process previously read data from register file 610. Execution stage 515 may overlap read stage 514 if multiple cycles are required to read a given data. The duration of execution stage 515 depends on the type (integer or floating point) and amount (number of read cycles) of data elements processed. Signals from the execution registers 422, 423, and 425 control input data to the arithmetic logic 630, accumulator 640, and multiplier 620 during the first operation performed during the execution stage. The signals from the run registers 432, 433, and 435 control the second operation performed during the run stage 515.

6C is a block diagram of an embodiment of multiplier 620 and ALU 630. Multiplier 620 is an integer multiplier that includes eight independent 36x36 bit multipliers 626. Each multiplier 626 includes four 9x9 bit multipliers connected together by a control circuit. For 8 bit and 9 bit data element sizes, the control signal from scheduler 230 is separated from the four 9x9 bit multipliers so that each multiplier 626 performs four multiplications, and multiplier 620 cycles. While 32 independent multiplications are performed. For 16 bit data elements, the control circuitry connects pairs of 9x9 bit multipliers working together, and multiplier 620 performs 16 parallel multiplications. For the 32 bit integer data element type, eight multipliers 626 perform eight parallel multiplications per clock cycle. The result of the multiplication gives 576 bits for the 9 bit data element size and 512 bits for the other data size.

ALU 630 may process the resulting 576-bit or 512-bit result from multiplier 620 for two clock cycles. ALU 630 includes eight independent 36-bit ALUs 636. Each ALU 636 includes a 32 x 32 bit floating point portion for floating point addition and multiplication. Ancillary circuits perform integer shifts, arithmetic and logic functions. For integer operations, each ALU 636 includes four parts that can perform independent 8-bit and 9-bit operations and can be linked together in two or four sets for 16-bit and 32-bit integer data elements. .

Accumulator 640 accumulates the result and includes two 576-bit registers for higher accuracy in intermediate results.

During the write stage 516, the results from the run stage are stored in the register file 610. Two registers can be written for a single clock cycle, and input multipliers 602 and 605 select the two data values to be written. The duration of the write stage 516 for the operation depends on the amount of data to be written as a result of the operation and the completion from the LSU 250 that can complete the load instruction by writing to the register file 610. The signals from the execution registers 426 and 427 select the registers into which data from the logic unit 630, accumulator 640 and multiplier 620 is written.

5B shows execution pipeline 520 for execution of load instructions. The instruction fetch stage 511, decode stage 512, and generation stage 513 for the execution pipeline 520 are the same as described for register-to-register operations. Read stage 514 is also the same as described above except execution data path 240 uses the data from register file 610 to determine an address for a call to cache subsystem 130. At address stage 525, multiplexers 652, 654, and 656 select addresses provided to load / store 250 for execution stages 526 and 527. Information for the load operation is maintained in the FIFO 410 during stages 526 and 527 while the load / store 250 handles the operation.

7 illustrates an embodiment of a load / store 250. During stage 256, it is called for cache subsystem 130 for data from the address determined at stage 525. An example embodiment utilizes a transaction based cache call where multiple devices, including processors 110 and 120, can access the local address space through cache subsystem 130. The requested data is not available for several cycles after calling cache subsystem 130, but load / store 250 may call the cache subsystem while another call is pending. Thus, the load / store 250 is not suspended. The number of clock cycles required for cache subsystem 130 to provide the requested data depends on whether data cache 194 has been hit or missed.

At drive stage 527, cache subsystem 130 asserts a data signal to load / store 250. Cache subsystem 130 may provide 256 bits (32 bytes) of data per cycle to load / store 250. The byte sorter 710 aligns each 32 byte into its corresponding 9 bit storage location to provide a 288 bit value. The 288 bit format is sometimes easy for multimedia applications such as MPEG encoding and decoding using 9 bit data elements. The 288 bit value is written to read data buffer 720. For write stage 528, scheduler 230 writes field 4 to Execute register 426 or 427 in FIFO buffer 410 to write the amount of 288 bits from data buffer 720 to register file 610. Haul)

5C shows an execution pipeline 530 for execution of stored instructions. The instruction fetch stage 511, decode stage 512, and generation stage 513 for the execution pipeline 530 are the same as described above. The read stage 514 is also as described above except that the read stage reads the data to be magnetized and the data for address calculation. The data to be stored is recorded in the data buffer 730 of the load / store unit 250. Multiplexer 740 changes the data, which is a format for providing 9 bit bytes, to a conventional format having 8 bit bytes. The translated data from the buffer 730 and the associated address from the address calculation stage 525 are sent in parallel to the cache subsystem 130 during the SRAM stage 536.

In an exemplary embodiment of the vector processor 120, each instruction is 32 bits long, has nine of the formats shown in FIG. 8, and has REAR, REAI, RRRM5, RRRR, RICT, RRRM9, RRRM9 *, and RRRM9 * It has a * sign. Appendix E describes an instruction set for the vector processor 120.

Some load, store, and cache operations that use scalar registers to determine efficient addresses have a REAR format. The REAR format instruction is identified by bits 29--31 which are 000b, and is identified by two register numbers SRb for the scalar register and the register number Rn of the register, which may be a scalar or vector depending on SRi and bit D. Have a parent Bank bit B identifies the bank for register Rn or indicates if the vector register Rn is a double size vector register if the default vector register size is double size. Opcode field Opc identifies the operation performed on the operand, and field TT identifies the type of transmission as load or store. A typical REAR format instruction is instruction VL which loads register Rn from an address determined by adding the contents of scalar registers SRb and SRi. If bit A is set, the calculated address is stored in scalar register SRb.

The REAI format instruction is identical to the REAR instruction except that an 8 bit intermediate value from the field IMM is used instead of the contents of the scalar register SRi. The REAR and REAI formats do not have a data element size field.

The RRRM 5 format is for instructions with two source operations and one destination operation. These instructions have a 5-bit intermediate value with either three register funds or two register operations. As shown in Appendix E, encoding of fields D, S, and M indicates whether the first source operator Ra is a scalar or vector register: the second source operator Rb / IM 5 is a scalar register, a vector register, or a 5-bit intermediate value. Acknowledge: And determine whether destination register Rd is a scalar or vector register.

The RRRR format is for instructions with four register operations. Register numbers Ra and Rb indicate source registers. Register number Rd points to the destination register, and register number Rc points to either the source or destination register, depending on the field Opc. All operands are vector registers unless bit S is set to point to register Rb. Field DS indicates the data element size for the vector register. Field Opc selects the data type for the 32 bit data element.

The RI format instruction loads the intermediate value into a register. The field IMM accepts intermediate values up to 18 bits. Register number Rd points to a destination register which is either a vector register in the current bank or a scalar register according to bit D. Fields DS and F indicate the data element size and type, respectively. For 32-bit integer data elements, the 18-bit intermediate value is the extended sign before loading into register Rd. For floating point data elements, bits 18, bits 17-10, and bits 9-0, respectively, indicate the sign, exponent, and mantissa of the 32-bit floating point value.

The CT format is for flow control instructions and includes an opcode field Opc, a condition field Cond, and a 23 bit intermediate value IMM. A branch is taken when the condition indicated by the condition field is true. Possible conditions are "always", "less than", "like", "less or equal", "greater than", "not equal", "greater than or equal to" and "overflow". Bits GT, EQ, LT, and SO in the status and control registers VCSR are used to evaluate the condition.

Format RRRM9 provides a 9 bit intermediate value with either three register operations or two register funds. The combination of bits D, S, and M indicates which operand is a vector register, a scalar register, or a 9-bit intermediate value. Field DS indicates the data element size. The RRRM9 * and RRRM9 ** formats are a special case of the RRRM9 format and are identified by the opcode field Opc. The RRRM9 * format replaces source register number Ra with condition code Cond and ID fields. The RRRM * format replaces the most significant bit of the intermediate value with condition codes Cond and bit K. Additional descriptions of RRRM9 * and RRRM9 ** are given in Appendix E with respect to the conditional shift command VCMOV, conditional shift CMOVM with an element mask and compare and set the mask CMPV instruction.

Although the present invention has been described with reference to specific embodiments, the description is only an example of the present application and should not be considered as limiting. Various modifications and combinations of the disclosed embodiments are encompassed within the scope of the invention as defined by the following claims.

<Appendix A>

In an exemplary embodiment, processor 110 is a general purpose processor compliant with the standard for ARM7 processors. See the ARM Architecture Documentation or ARM7 Data Sheet (document number ARM DDI 0020C, published December 1994) for a description of the registers in ARM7.

In order to interact with the vector processor 120, the processor 110 starts and stops the vector processor: tasks the vector processor state, including for synchronization: data from the scalar / special purpose registers in the vector processor 120; Is sent to the general register of the processor 110, and the data from the general register is transferred to the vector processor scalar / special purpose register. There is no direct transfer between the general purpose register and the vector processor vector register. This transfer requires memory as an intermediate.

Table a1 describes the extensions to the ARM7 instruction set for vector processor instructions.

TABLE A1

Table a2 lists the ARM7 exceptions detected and reported before executing the faulty instruction. Exception vector addresses are given in hexadecimal comments.

TABLE A2

The following describes the extended syntax to the ARM7 instruction set. For nomenclature descriptions and instruction formats, see the ARM Architecture Documentation or ARM7 Data Sheet (Document No. ARM DDI 0020C, published December 1994).

The ARM architecture provides three instructions for the coprocessor interface.

1. Coprocessor Data Operations (CDP)

2. Coprocessor Data Transfer (LDC, STC)

3. Coprocessor Register Transfer (MRC, MCR)

The MSP architecture extension uses all the new formats.

The coprocessor data operation format (CDP) is used for operations that do not require communication back to ARM7.

CDP format

Fields in the CDP format have the following conventions:

Coprocessor data transfer formats (LDC, STC) are used to load or store a subset of the vector processor's registers directly into memory. The ARM7 processor is responsible for supplying the word processor, the vector processor supplies the data, or accepts and controls the number of words transmitted. See the ARM7 data sheet for details.

LDC, STC format

Fields in the format have the following conventions:

Coprocessor register transfer formats (MRC, MCR) are used to communicate information directly between ARM7 and vector processors. This format is used to move between ARM7 registers and vector processor scalar or special purpose registers.

MRC, MCR format

Fields in the format have the following conventions:

Extended ARM instruction description

Extended ARM instructions are described in alphabetical order.

CACHE Cache operation

format

Assembler Syntax

STC {cond} p15, c0pc, <Address>

CACHE {cond} 0pc, <Address>

Where cond = {eq, he, cc, mi, pl, vs, vc, hi, Is, ge, It, gt, Ie, ai, nv} and 0pc = {0, 1, 3}. Note that since the CRn field in the LDC / STC format is used to specify 0pc, the decimal representation of the opcode must be preceded by the letter 'c' in the first syntax (ie use c 0 instead of 0). See the ARM7 data sheet for the address mode syntax.

Explanation

This command is executed only when Cond is true. 0pc <3: 0> specifies the following operation.

calculate

See the ARM7 data sheet for how the EA is calculated.

exception

ARM7 protection violation

INTVP Interrupt Vector Processor

format

Assembler Syntax

CDP {cond} p7, 1, c0, c0, co

INTVP {cond}

Where cond = {eq, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, lt, gt, le, al, ns}

Explanation

This command is executed when Cond is true. This instruction signals the vector processor to stop. ARM7 continues executing the next instruction without waiting for the vector processor to stop.

The MFER busy-wait loop is used to determine if the vector processor has stopped after executing this instruction. This instruction has no effect if the vector processor is already in VP_IDLE state.

Bits 19:12, 7:15 and 3: 0 are assigned.

exception

Vector processor not available

More from MFER Extension Register

format

Assembler Syntax

MRC {cond} p7, 2, Rd, cp, 0

MFER {cond} Rd, RNAME

Where cond = {eq, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd = {r0 ..... r15}, P = {0, 1}, ER = {0, ..15} and RNAME refer to the architecturally specified register mnemonics (ie, PERO or CSR).

Explanation

This command is executed only when Cond is true. The ARM7 register Rd is moved out of the extended ER register specified as P: ER <3: 0, as shown in the table below. See Sections 1 and 2 for extended register descriptions.

Bits 19:17 and 7: 5 are reserved.

Explanation

Attempting to access PERx while in user mode is a protection violation.

Move from the MFVP vector processor

format

Assembler Syntax

MRC {cond} p7. 1. Rd. Crn.Crm.0

MFER {cond} Rd.RNAME

Where cond = {eq, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd = {r0 .... r15}, CRn = ({c0 .... c15}, CRm = {c0 .... c15} and RNAME point to the architecturally specified register mnemonic (ie SP0 or VSR).

Explanation

This command is executed only when Cond is true. The ARM7 register Rd is moved from the scalar / special purpose register CRn <1: 0>: CRm <3: 0> of the vector processor. Refer to Section 3.2.3 for vector processor register number assignment for register transfer.

Bit 7.5 as well as CRn <3: 2> is reserved.

The vector processor register map is shown in the table below. See Table 15 for the vector processor special purpose registers (SP0-SP15).

SR0 is always read as 32 bits of zero and writing to it is ignored.

Explanation

Vector processor not available.

Move to MTER Extension Register

format

Assembler Syntax

MRC {cond} p7, 2, Rd, cp, cER, 0

MFER {cond} Rd, RNAME

Where cond = {eq, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd = {r0 .... r15}, P = {0, 1}, ER = {0 .... 15} and RNAME point to the architecturally specified register mnemonic (ie PER0 or CSR).

Explanation

This command is executed only when Cond is true. The ARM7 register Rd is moved out of the extension register ER specified as P: ER <3: 0> as shown in the table below.

Bits 19:17 and 7: 5 are reserved.

Explanation

Attempting to access PERx while in user mode is a protection violation.

Moving from the MTVP Vector Processor

format

Assembler Syntax

MRC {cond} p7.1.Rd.Crn.Crm.0

MFVP {cond} Rd.RNAME

Where cond = {eq, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, lt, gt, le, al, nv} Rd = {r0 .... r15}, CRn = ( {c0 .... c15}, CRm = {c0 .... c15} and RNAME point to the architecturally specified register mnemonic (ie SP0 or VCS).

Explanation

This command is executed only when Cond is true. The ARM7 register Rd is moved from the scalar / special purpose register CRn <1: 0>: CRm <3: 0> of the vector processor.

Bit 7.5 as well as CRn <3: 2> is reserved.

The vector processor register map is shown in the table below.

exception

Vector processor not available.

FETCH prefetch

format

Assembler Syntax

LDC {cond} p15, 2, <Address>

PFTCH {cond} <Address>

Where cond = {eq, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}. See the ARM7 data sheet for the address mode syntax.

Explanation

This command is executed only when Cond is true. The cache line specified by the EA is prefetched into the ARM7 data cache.

calculate

See the ARM7 data sheet for how EA is computed.

Exception: none

STARTVP start vector processor

format

Assembler Syntax

LDP {cond} p7, 0, c0, c0

STARTVP {cond}

Where cond = {eq, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}.

Explanation

This command is executed only when Cond is true. This instruction signals the vector processor to start execution and automatically clears VISRC <vjp> and VISRC <vip>. ARM7 continues executing the next instruction without waiting for the vector processor to start executing.

The state of the vector processor must be initialized to a predetermined state before this instruction is executed. This instruction has no effect if the vector processor is already in VP_RUN state.

Bits 19:12, 7: 5, and 3: 0 are reserved.

exception

Vector processors are not available.

TESTSET TEST AND SET

format

Assembler Syntax

MRC {cond} p7, 0, Rd, c0, cER, 0

TESTSET {cond} Rd, RNAME

Where cond = {eq, he, cs, cc, mi, pl, rs, ve, hi, ls, ge, lt, gt, le, al, nv}. Rd = {r0 .... r15}, ER = {0 .... 15} and RNAME point to the architecturally specified register mnemonic (ie UER1 or VASYNC).

Explanation

This command is executed only when Cond is true. This command returns the contents of UERx to RD and sets UERx <30> to one. If ARM7 register 15 is specified as the destination register, UERx <30> is returned in the Z bit of the CPSR so that a short busywait loop can be implemented.

Exception: none

<Appendix B>

The architecture of the multimedia processor 100 defines extension registers that the processor 110 accesses as MFER and MTER instructions. The extension register includes a dedicated extension register and a user extension register.

The dedicated extension registers are mostly used to control the operation of the multimedia signal processor. These are shown in Table b1.

TABLE b1

Dedicated expansion register

The control register controls the operation of the MSP 100. The mode bits in the CTR are cleared on reset. The register definitions are shown in Table b2.

TABLE b2

CTR definition

The status register indicates the status of the MSP 100. All bits in field STR are cleared on reset. The register definitions are shown in Table b3.

TABLE b3

STR definition

The processor version register identifies a special version of a particular processor of the multimedia signal processor family of processors.

The vector processor interrupt mask register VIMSK eliminates reporting of vector processor exceptions to the processor 110. Each bit in VIMSK interrupts ARM7 by enabling an exception when set with the corresponding bit in the VISRC register.

It does not affect how vector processor exceptions are detected, but only affects whether the exception should interrupt ARM7. All bits in VIMSK are cleared on reset. The register definitions are shown in Table B4.

Table b4

The ARM7 instruction address breakpoint registers help to debug an ARM7 program. The register definitions are shown in Table b5.

TABLE b5

The ARM7 data address breakpoint registers help you debug ARM7 programs. The register definitions are shown in Table b6.

TABLE b6

The scratch pad register configures the address and size of the scratch pad formed using the SRAM in the cache subsystem 130. The register definitions are shown in Table b7.

TABLE b7

SPREG

User extension registers are mostly used for synchronization of processors 110 and 120. The user extension register is currently defined to have only one bit mapped to bit 30, for example an instruction such as "MFER R15, UERx" returns the bit value as the Z flag. Bits UERx <31> and UERx <29: 0> are always read to zero. User extension registers are described in Table b8.

TABLE b8

Extension register

Table b9 shows the state of the expansion register at the power-on reset.

TABLE b9

Expansion Register Power-On State

<Appendix C>

The architecture state of the vector processor 120 is: 32 32-bit scalar registers; 2 banks of 32 288 bit vector registers; A pair of 576-bit vector accumulation registers; It has a set of 32-bit special purpose registers. Scalar, vector, and accumulator registers are intended for general purpose programming and support many other data types.

The following comments are used in these and subsequent sections. VR points to a vector register; VRi points to the i th vector register (zero offset); VR [i] points to the i th data element in the vector register VR; VR <a: b> points to bits a to b in the vector register VR; And VR [i] <a: b> points to a to b of the i th data element in the vector register VR.

Vector architectures have added dimensions of data type and size for multiple elements in one vector register. Since the vector register is of fixed size, the number of data elements it can accommodate depends on the size of the element. The MSP architecture has five element sizes, as shown in Table c1.

TABLE c1

Data element size

The MSP architecture interprets vector data according to the data type and size specified in the instruction. Two's complement format is currently supported for the byte, byte 9, halfword, and word element sizes of most architecture instructions. In addition, the IEEE 754 single accuracy format is supported as a word element for most architecture instructions.

The programmer can freely interpret the data in any desired manner as long as the instruction sequence yields meaningful results. For example, a programmer can store an 8-bit unsigned number using byte 9 size, freely store an 8-bit unsigned number in a bike size data element, and allow the programmer to handle "false" overflow results. As long as you can, you can operate them freely using the provided two's complement architecture instructions.

There are 32 scalar registers called SR0 to SR31. Scalar registers are 32 bits wide and can accommodate one data element of any size defined. Scalar register SR0 is special in that register SR0 is always read as 32 bits of zero, and writing to register SR0 is ignored. Byte, byte 9, and halfword data types are stored in the least significant bit of the scalar register, where the most significant bit has an undefined value.

Since the register does not have a data type indicator, the programmer must know the data type of the register being used for each instruction. This is different from other architectures in which 32-bit registers are considered to accept 32-bit values. The MSP architecture specifies that the result of data type A correctly modifies only the bits specified for data type A. For example, the result of byte 9 addition only modifies the lower 9 bits of the 32-bit destination scalar register. The value of the upper 23 bits is undefined unless otherwise indicated for the instruction.

The 64 vector registers are organized in 2 banks with 32 registers each. Bank 0 holds the first 32 registers, and Bank 1 holds the second 32 registers. Two banks are used in such a way that one bank is set as one bank to the current bank and the other bank is set as an alternate bank. All vector instructions use registers in the current bank as default, except that load / store and move registers that can access vector registers in the alternate bank. The CBANK bit in the vector control and status register VCSR is used to set bank 0 or bank 1 to the current bank (the other bank becomes the alternate bank). The vector register in the current bank is called VR0 to VR31, The vector register in the replacement bank is called VRA0 through VRA31.

Optionally, two banks can be conceptually merged to provide 32 double size vector registers of 576 bits, respectively. The VEC64 bit in the control register VCSR specifies this mode. There are no current and alternate banks in VEC64 mode, and the vector register number refers to the corresponding 288 bit vector register pair from the two banks. In other words

VRi <576: 0> = VR ₁ i <287: 0>: VR ₀ i <287: 0>

Here, VR ₀ and VR ₁ i refer to a vector register having register numbers VRi of banks 1 and 0 respectively. The dual size vector registers are called VR0 through VR31.

The vector register can accommodate multiple elements of byte, byte 9, halfword or word size as shown in Table c2.

Table c2

Number of elements per vector register

Mixing element sizes in one vector register is not supported. Except for the byte 9 element size, only 256 of 288 bits are used. In particular, every ninth bit is not used. Unused 32 bits in byte, halfword and word size are reserved and the programmer must not make any assumptions about their values.

The vector accumulator register is intended to provide storage for intermediate results that are more accurate than the result in the destination register. The vector accumulation register consists of four 288-bit registers called VAC1H, VAC1L, VAC0H, and VAC0L. VAC0H: The VAC0L pair is used by three instructions by default. Only VEC64 models use the VAC1H: VAC1L pair to emulate a 64 byte 9 vector operation. Although Bank 1 is set to the current bank in VEC32 mode, the VAC0H: VAC0L pair is used.

Extended accuracy elements are saved across register pairs as shown in Table c3 to produce extended accuracy results with the same number of elements as in the source vector register.

Table c3

Vector accumulator format

The VAC1H and VAC1L pairs are used only in VEC64 mode, where the number of elements is 64, 32 or 16 for byte 9 (and byte), halfword and word respectively.

There are 33 special purpose registers that cannot be loaded directly from or stored directly in memory. Sixteen special purpose registers, called RASR0 to RASR15, form an internal return address stack and are used by subroutine call and return instructions. Seventeen 32-bit special purpose registers are shown in Table C4.

Table c4

Special purpose registers

Vector control and status register VCSR definitions are shown in Table c5.

Table c5

VCSR definition

The vector program counter register VPC is the address of the next instruction to be executed by the vector processor 120. The AMR7 processor 110 must load the register VPC before generating the STARTVP instruction to begin the operation of the vector processor 120.

The vector exception program counter VEPC specifies the address of the instruction that is likely to cause the most recent exception. MSP 100 does not support the exact exception, ie the "most likely" term.

The vector interrupt source register VISRC points to the interrupt source for the ARM7 processor 110. Appropriate bit (s) are set by the hardware upon detection of the exception (s). Software must clear register VISRC before vector processor 120 can resume execution. Any bit set in the register VISRC causes the vector processor 120 to enter the state VP_IDLE. If the corresponding interrupt enable bit is set to VIMSK, an interrupt to processor 110 is signaled. Table c6 defines the contents of the register VISRC.

Table c6

VISRC Definition

The vector interrupt instruction register VIINS is updated as a VCINT or VCJOIN instruction when the VCINT or VCJOIN instruction is executed to interrupt the ARM7 processor 110.

The vector counter registers VCR1, VCR2 and VCR3 are the decrement and branch instructions VD1CBR, VD2CBR and VD3CBR and are initialized as loop counts to be executed. When the instruction VD1CBR is executed, the register VCR1 is decremented by one. If the count value is not zero and the condition specified in the instruction matches VFLAG, then an atmosphere is taken. If not, no branch is taken. The register VCR1 is decremented by 1 in either case. Registers VCR2 and VCR3 are used equally.

The vector global mask register VGMR0 points to the element in the destination vector register that will affect VEC32 and the element in VR <287: 0> in VEC64 mode.

Each bit of VGMR0 controls an update of 9 bits of the vector destination register. In particular, VGMR0 <i> is VEC32 mode of VRd <9i + 8: 9i> : controls the update of the <9i 9i + 8> and VEC64 mode of VR ₀ d. VR ₀ d points to the destination register of bank 0 in VEC64 mode, and VRd points to the destination register in the current bank, which can be either bank 0 or 1 in VEC32 mode. The vector global mask register VGMRO is used to execute all instructions except the VCMOVM instruction.

The vector global mask register VGMR1 points to an element in VR <575: 288> that is affected in the VEC64 mode. Each bit of VGMR1 controls the update of 9 bits in the vector destination register in bank 1. In particular, VGMR1 <i> d is VR _1: controls the update of the <9i + 8 9i>. The register VGMR1 <i> controls the update of VR ₁ d <9i + 8: 9i>. Register VGNR1 is not used in VEC32 mode, but is not used in VEC32 instructions except the VCMOVM instruction in VEC64 mode.

The vector overflow register VOR0 points to an element in VEC 32 mode and an element in VR <287: 0> in VEC 64 mode that contains the overflow result after the vector arithmetic operation. This register is not modified by scalar arithmetic. Bit VORO <i> to be set indicates that the i th element of the byte or byte 9, the (i idiv 2) th element of the halfword, or the (i idiv 4) th element of the word data type operation contains the overflow result. Point. For example, bits 1 and 3 will be set to indicate the overflow of the first halfword and word element, respectively.

This mapping of the bits in VOR0 is different from the bit mapping in VGMR0 or VGR1.

The vector overflow register VOR1 is used to point to an element in VR <575: 288> in the VEC64 mode which contains the overflow result after the vector arithmetic operation. Register VOR1 is not used in VEC32 mode, nor is it modified by scalar arithmetic. The set bit VOR1 <i> is the i-th element of the byte or byte 9, the (i idiv 2) th element of the halfword, or the (i idiv 4) th element of the word data type operation containing the result of the overflow. Points to. For example, bits 1 and 3 will be set to indicate the overflow of the first halfword and word element, respectively, in VR <575: 288>. The mapping of the bits in VOR1 is different from the mapping of the bits in VGMR0 or VGMR1.

The vector instruction address breakpoint register VIABR helps to debug vector programs. The register definitions are shown in Table c7.

Table c7

VIABR Definition

The vector data address breakpoint register VDABR helps to debug vector programs. This register definition is shown in Table c8.

Table c8

VDABR Definition

The vector shift mask register VMMR0 is used by the VCMOVM instruction in all cases as well as when VCSR <SMM> = 1 for all instructions. The register VMMR0 points to the element of the destination vector register that will be affected in VEC32 mode and the element in VR <287: 0> in VEC64 mode. Each bit of VMMR0 controls an update of 9 bits of the vector destination register. In particular, VMMR0 <i> is VRd <9i + 8: 9i> in VEC32 mode: controls the update of the _{<9i 9i + 8> VR 0} d in and VEC64 mode. VR ₀ d points to the destination register of bank 0 in VEC64, and VRd points to the destination register in the current bank, which can be either bank 0 or 1 in VEC32 mode.

The vector shift mask register VMMR1 is used by the VCMOVM instruction in all cases as well as when VCSR <SMM> = 1 for all instructions. The register VMMR1 points to the element in VR <575: 287> that will be affected in the VEC64 mode. Each bit of VMMR1 controls the updating of 9 bits of the vector destination register in bank 1. In particular, VGMR1 <i> controls the update of VR1d <9i + 8: 9i>. Register VGMR1 is not used in VEC32 mode.

The vector and ARM7 synchronization registers VASYNC provide the producer / consumer of synchronization between the processors 110 and 120. Currently, only bit 30 is defined. The ARM7 processor can access the register VASYNC using the instructions MFER, MTER and TESTSET while the vector processor 120 is in the state VP_RUN or VP_IDLE. Register VASYNC cannot access the ARM7 process via a TVP or MFVP instruction because these instructions cannot be accessed outside the special purpose registers of the first 16 vector processor. The vector processor can access the register VASYNC through the VMOV instruction.

Table c9 shows the state of the vector processor upon power-on reset.

Table c9

Vector processor on power-on reset

The special purpose register is initialized by the ARM7 processor 110 before the vector processor can execute the instruction.

<Appendix D>

Each instruction implies or specifies the data types of the source and destination operands. Some instructions have semantics that apply equally to one or more data types. Some commands have semantics that take one data type for the source and produce another data type for the result. This appendix describes data types supported by the example embodiments. Table 1 in this chapter describes the supported data types int8, int9, int16, int32, and floating data. Unsigned integer formats are not supported and unsigned integer values must be converted to a two's complement format before being used first. The programmer is free to use arithmetic instructions as unsigned integers or any other format he chooses so long as the overflow is handled properly. The architecture defines the overflow of only two's complement integers and 32-bit floating point data types. The architecture cannot detect the carry out of 8, 9, 16, or 32 bit operations required for unsigned overflow.

Table d1 shows the data size supported by the load operation.

TABLE D1

Data size supported by the load operation

The architecture specifies a memory address alignment that will be data type bound. That is, in the case of bytes, there is no sort condition. For halfwords, the alignment condition is a halfword boundary. For words, the alignment condition is a word boundary.

Table d2 shows the data sizes supported by the store operation.

TABLE D2

Data size supported by the save operation

Because a scalar or vector or more than one dam type is mapped to a register, there may be bits in the destination register that do not have a defined result for some data types. In fact, in addition to byte 9 data size operations for vector destination registers and word data size operations for scalar destination registers, the values are present in bits in destination registers not defined by the operation. For these bits, the architecture specifies that their values are to be defined. Table d3 shows the undefined bits for each data size.

TABLE D3

Undefined bit for data size

In programming, the programmer must always know the data types of the source and destination registers or memory. Data type conversion from one element size to another results in a potentially different number of elements stored in the vector register. For example, the conversion of a vector register from halfword to word data type requires two vector registers to store the same number of converted elements. Conversely, the conversion from word data type to half format, which can have a user-defined format in the vector register, results in the same number of elements in one half of the vector register and the remaining bits in the other half. In either case, data type conversion poses an architectural problem for arrays of converted elements that are of a different size than the source element.

In principle, the MSP architecture provides the result of an operation that implicitly converts the number of elements. The architecture assumes that the programmer must know the consequences of changing the number of elements in the destination register. The architecture provides only operations that convert from one data type to another of the same size, and requires the programmer to adjust the difference in data size when converting from one data type to another.

As described in Appendix E, special instructions such as VSHFLL and VUNSHFLL simply simplify the conversion from one vector with one data size to another with a different data size. For example, the basic steps involved in converting a two's complement data type to a smaller element size int8, for example int8, in VR _a are as follows.

1. Using the byte data type, shuffle the elements in VR _a with different vectors VR _b into two vectors VR _c : VR _d . The element in VR _a is moved to the lower byte of the int16 data element in the dual size register VR _c : VR _d , and the element of VR _b whose value is irrelevant is moved to the upper byte of VR _c : VR _d . This operation doubles the size of each element from byte to half word, effectively moving one element of VR _a to VR _c and the other half to VR _d .

2. 8-bit arithmetic shift to sign-extend the elements in VR _c . For example, the basic steps involved in converting an element size larger than that in vector VR _a , a smaller size in int16, for example smaller, and a two's complement data type from int6 are

Check that each element of int16 data type is representable in bytes. If necessary, saturate the elements on both sides to fit the smaller size.

2. Unshuffle the elements of VR _a into two vectors VR _c : VR _d as other VR _b . The upper half of each element in VR _a and VR _b is moved to VR _c and the lower half to VR _d . This effectively collects the bottom half of all elements of VR _a in the bottom half of VR _d .

3. Special instructions are provided for the following data type conversions: int32 for single-precision floating point; Single-precision floating point (X, Y annotations) for fixed point; single precision floating point for int32; int8 for int9; int9 for int16; And int16 for int9.

To provide flexibility in vector programming, most vector instructions use element masks to operate only on selected elements in the vector. The vector global mask registers VGMRO and VGMR1 identify the elements modified in the destination register and the vector accumulator by the vector instruction. For byte and byte 9 data size operations, each of the 32 bits in VGMR0 (or VGMR1) identifies the element to be operated on. The set bit VGMR0 &lt; i &gt; here indicates that an element i of byte size where i is from 0 to 31 will be affected. For halfword data size operations, each pair of 32 bits in VGMR0 (or VGMR1) identifies the element to be operated on. The bits VGMR0 <2i: 2i + 1> being set here indicate that element i with i from 0 to 15 will be affected. If only one bit of the pair in VGMR0 is set for halfword data size operation, only the bits in the corresponding byte are modified. For word data size operations, each set of four bits in VGMR0 (or VGMR1) identifies the element to be operated on. The bits VGMR0 <4i: 4i + 3> being set here indicate that element i with i from 0 to 7 will be affected. If all bits in the four sets in VGMR0 are not set for word data size operations, only the bits in the corresponding byte are modified.

VGMR0 and VGMR1 can be set by comparing a vector register with a vector or scalar register or an increment using a VCMPM instruction. This command sets the mask appropriately according to the specified data size. Because scalar registers are defined to accept only one data element, scalar operations (ie, destination registers are scalar) are not affected by the element mask.

For flexibility in vector programming, most MSP instructions support three forms of vector and scalar operations. These are as follows.

1.vector = vector op vector

2. Vector = vector op scalar

3. scalar = scalar op scalar

In the case of 2, where a scalar register is specified as the B operand, one element in the scalar register is duplicated as many times as necessary to match the number of elements in the vector A operand. The duplicated element is the same value as the element in the specified scalar operand. Scalar operands can come from scalar registers or instructions in the form of intermediate operations. In the case of an intermediate operation, if the specified data type uses a larger data size than is available as the intermediate field size, it is appropriately sign extended.

In many multimedia applications, much attention must be paid to the precision of the source, intermediate, and result. In addition, integer multiplication instructions produce "double precision" intermediate results that can be stored in two vector registers.

The MSP architecture currently supports IEEE 754 single accuracy format for two's complement integer format 32-bit elements for 8, 9, 16, and 32-bit elements. Overflow is defined as the result of being outside the most positive or negative value that can be represented as a specified data type. When an overflow occurs, the value written to the destination register is not an invalid number. An overflow is defined only for floating point operations.

Unless defined otherwise, all floating point operations use one of the four rounding modes specified in VCSR <RMODE>. Some commands use what is known as round away from zero (round even) rounding mode.

Saturation is an important feature in many multimedia applications. The MSP architecture supports saturation in all four integer and floating point operations. Bit ISAT in the register VCSR specifies the integer saturation mode. Floating point saturation mode, also known as fast IEEE mode, is specified as FSAT in the VCSR. When the saturation mode is enabled, the result that is out of the most positive or most negative value is set to the most positive or most negative value respectively. In this case, no overflow can occur and the overflow bit cannot be set.

Table d4 lists the exact exceptions that are detected and reported before the faulty instruction is executed.

TABLE D4

Exact exception

Table d5 lists inaccurate exceptions detected and reported after executing several instructions in subsequent programs other than the faulty instruction.

TABLE D5

Inaccurate exception

<Appendix E>

Instructions set for the vector processor may be classified into eleven as shown in Table e1.

TABLE e1

Vector instruction classification summary

Table e2 lists flow control commands.

TABLE e2

Flow control command

Logical classifications support Boolean data types and are affected by element masks. Table e3 lists the flow control commands.

TABLE e3

Logical command

The shift / rotation sort instruction operates on int8, int9, int16 and int32 data types (no floating data types) and is affected by the element mask. Table E4 lists the shift / rotation sort commands.

Table e4

Shift & turn classification

Arithmetic classification instructions generally support the int8, int9, int16, and int32 floating data types and are affected by the element mask. See the description of each command below for specific restrictions on unsupported data types.

The VCMPV instruction is not affected by the element mask because it operates on the element mask. Table e5 lists the arithmetic classification commands.

Table e5

Arithmetic classification

MPEG instructions are a class of instructions specifically suited for MPEG encoding and decoding, but various methods may be used. MPEG instructions support int8, int9, int16, and INT32 data types, and are affected by element masks. Table e6 lists MPEG commands.

TABLE e6

MPEG classification

Each data type conversion instruction supports a particular data type and is not affected by the element mask because the architecture does not support more than one data type in a register. Table E7 lists the data type conversion instructions.

Table e7

Data type conversion command

The inter-element arithmetic classification of instructions supports int8, int9, int16, int32, and floating data types. Table e8 lists the inter-element arithmetic classifications.

Table e8

Arithmetic classification between elements

Inter-element transfer classification of instructions supports byte, byte 9, halfword and word data sizes. Table e9 lists the inter-element movement classification of the command.

Table e9

Move between elements

Load / store instructions support special byte 9 related data size operations in addition to byte, halfword and word data sizes and are not affected by element masks. Table e10 lists the commands in the load / store category.

Table e10

Load / Save Classification

Most register move instructions support int8, int9, int16, int32, and floating data types, and are not affected by the element mask. Only VCMOVM instructions are affected by the element mask. Table E11 lists the register move classifications of the instructions.

TABLE e11

Register move classification

Table e12 lists the instructions in the cache operation classification that control cache subsystem 130.

TABLE e12

Cache operation classification

Command Description Naming

To simplify the specification of the instruction set, special terms are used throughout the appendix. For example, an instruction operand is a signed two's complement integer of byte, byte 9, halfword, or word size, unless otherwise defined. The term "register" is used to refer to a general purpose (scalar or vector) register. Other types of registers are explicitly described. In assembly language syntax, the subscripts b, b9, h, and w refer to both data size (byte, byte 9, halfword, and word) and integer data types (int8, int9, int16, and int32). In addition, the terms and symbols used to describe instruction operands, operations, and assembly language syntax are:

Rd: destination register (vector, scalar or special purpose)

Ra, Rb: Source registers a and b (vector, scalar or special purpose)

Rc: source or destination register c (vector or scalar)

Rs: Store data source registers (vector or scalar)

S: 32-bit scalar or special purpose register

VR: current bank vector register

VRA: Alternate Bank Vector Register

VR ₀ : Bank 0 Vector Register

VR ₁ : Bank 1 vector register

VRd: vector destination register (default for current bank unless VRA is specified)

VRa, VRb: vector source registers a and b

VRc: vector source or destination register c

VRs: Vector Store Data Source Registers

VAC0H: Vector Accumulator Register 0 High

VAC0L: Vector Accumulator Register 0 Low

VAC1H: Vector Accumulator Register 1 High

VAC1L: Vector Accumulator Register 1 Low

SRd: scalar destination register

SRa, SRb: scalar source registers a and b

SRb +: Update base register to valid address

SRs: Scalar Stored Data Source Registers

SP: Special Purpose Registers

VR [i]: i-th element in the vector register VR

VR [i] <a: b>: i th element bits a to b in the vector register VR

VR [i] <msb>: most significant bit of the i th element in the vector register VR

EA: Effective Address for Memory Access

MEM: memory

BYTE [EA]: One byte of memory addressed by EA

HALF [EA]: Word of memory addressed by EA. Bits <15: 8> are addressed by EA + 1.

WORD [EA]: Halfword of the memory addressed by EA. Bits <31:24> are addressed by EA + 3.

NumElem indicates the number of elements for a given data type. This is 32, 16 or 8 for byte and byte 9, halfword or word data sizes, respectively, in VEC32 mode. This is 64, 32 or 16 for byte and byte 9, halfword or word data sizes, respectively, in VEC64 mode. NumElem is 0 for scalar operations.

EMASK [i] points to the element mask for the i th element. This represents VGMRO / 1, -VGMR0 / 1, VMMR0 / 1, -VMMR0 / 1 for byte and byte 9, halfword or word data sizes, respectively. For scalar operations, the element mask is assumed to be set even if EMASK [i] = 0.

MMASK [i]: refers to the element mask for the i-th element. It represents one, two or four bits in VMMR0 or VMMR1 for byte and byte 9, halfword or word data sizes, respectively.

VCSR: Vector Control and Status Register

VCSR <x>: Indicates a bit or a bit in the VCSR. "X" is a field name.

VPC: Vector Processor Program Counters

VECSIZE: The vector register size is 32 for VEC32 and 64 for VEC64.

SPAD: Scratch Pad

The C programming construct is used to describe the control flow of an operation. The exception is as follows:

= Assignment

: connect

y}는 x 또는 y 사이의 선택을 가르킨다.(논리적이 아님 또는){x

y} indicates a choice between x or y (not logical or)

sex Sign extension to specified data size

sex_dp Sign expansion with double precision of specified data size

sign ＞＞ sign extended (arithmetic) right shift

zex Zero expansion to the specified data size

zero >＞ Zero extended (logical) right shift

<< left shift (zero fill in)

trnc7 Trunk the first 7 bits (from halfword)

trnc1 Trunk the first 1 bit (from byte 9)

% Modulo operator

expression

식의 절대값

expression

The absolute value of an expression

/ Dividing (for floating data types, use one of the four IEEE rounding modes)

// share (uses Round Away Prom Zero rounding mode)

For the saturate () integer data type, instead of generating an overflow, saturate to the most negative or most positive value; for floating data types, saturation is positive infinity, negative zero, positive zero, or negative It can be up to infinity.

The overall instruction format is shown in FIG. 8 and described below.

The REAR format is used by load, store and cache operation instructions, and the fields in the REAR format have the following meanings as shown in Table e13.

TABLE e13

REAR format

Bits 17:15 are reserved and must be zero to be compatible with future extensions in the architecture. Some encodings of B: D and TT fields are not defined.

Programmers should not use these encodings because the architecture does not specify the expected results when such encoding is used. Table e14 shows scalar load operations supported in both VEC32 and VEC64 modes (encoded in TT field as LT).

TABLE e14

REAR Load 0ps in VEC32 and VEC64 Modes

Table e15 shows the vector load operations supported in VEC32 mode (encoded in TT field as LT) when bit VCSR <0> is cleared.

Table e15

REAR load 0ps in VEC32 mode.

The B bit is used to indicate the current or alternate bank.

Table e16 shows the vector load operations supported in VEC64 mode (encoded in the TT field as LT) when the VCSR <0> bit is clear.

TABLE e16

REAR Load Ops. In VEC64 Mode.

The B bit is used to indicate a 64 byte vector operation because the concept of the current and alternate banks does not exist in VEC 64 mode.

Table e17 lists scalar store operations supported in both VEC32 and VEC64 modes (encoded in TT field as ST).

Table e17

REAR scalar store operation.

Table e18 lists the vector store operations supported in VEC32 mode (encoded in TT field as ST) when the VCSR <0> bit is clear.

Table e18

REAR vector storage operation in VEC32 mode.

Table e19 lists the vector store operations supported in the VEC64 mode (encoded in the TT field as ST) when the VCSR <0> bit is set.

Table e19

REAR vector storage operation in VEC32 mode.

The B bit is used to indicate a 64 byte vector operation because the concept of the current and alternate banks does not exist in VEC 64 mode.

The REAI format is used by load, store, and cache operation instructions. Table e20 shows the meaning of the fields in the REAI format.

Table e20

REAl format.

The RAER and REAI formats use the same encoding for the transfer type. See the REAR format for additional encoding.

The RRRM5 format provides three registers or two registers and a 5-bit intermediate operation. Table e21 indicates the fields for the RRRM5 format.

Table e21

RRRM5 format.

Bits 19: 15 are reserved and must be zero to be compatible with future extensions in the architecture.

All the collector register operands refer to the current bank (which may be either bank 0 or bank l) unless otherwise defined. Table e22 lists the D: S: M encoding when DC <1: 0> is 00, 01 or 10.

Table e22

RRRM5 D: S: M encoding when DS is not equal to 11.

When DS <1: 0> is 11, the D: S: M encoding has the following meaning.

Table e23

When DS is 11, RRRM5 D: S: M encoding.

The RRRR format provides four register operations.

Table e24 shows the fields in the RRRR format.

Table e24

RRRR format.

All vector register operands refer to the current bank (which may be either bank 0 or bank 1) unless otherwise defined.

The RI format is used by load intermediate temporary instructions. Table e25 indicates fields of the RI format.

Table e25

RI format.

F: Any encoding of the DS <1: 0> field is not defined. Programmers should not use these encodings because the architecture does not specify the expected results when such encodings are used. The value loaded into Rd depends on the data type as shown in Table e26.

Table e26

The CT format includes the fields shown in Table e27.

Table e27

CT format.

Branch conditions use the VCSR [GT: EQ: LT] field. When the overflow condition is set, it uses the VCSR [SO] bit that precedes the GT, EQ, and LT bits. VCCS and VCBARR interpret the Cond <2: 0> field differently than described above. See their command descriptions for details.

The RRRM9 format specifies three registers or two registers and a 9-bit intermediate operation. e28 points to a field in the RRRM9 format.

Table e28

RRRM9 format.

Bits 19: l5 are reserved when the D: S: M encoding does not specify an intermediate operation, and must be zero to ensure future compatibility.

All vector register operands refer to the current bank (which may be either bank 0 or bank 1) unless otherwise defined. The D: S: M encoding is the same as shown in Tables e22 and e23 for the RRRM5 format, except that the median value extracted from the middle field follows the DS <1: 0> encoding as shown in Table E29. .

Table e29

Intermediate value in RRRM9 format.

Intermediate formats cannot be used with floating data types.

In the following, MSP vector instructions appear in alphabetical order. week:

1. Instructions are affected by element masks unless otherwise defined. CT format instructions are not affected by the element mask. REAR and REAI format instructions, consisting of load, store, and cache instructions, are also unaffected by the element mask.

2. 9-bit intermediate operands cannot be used with floating data types.

3. In the operation description, only vector form is presented. For scalar operations, assuming only one, the zeroth element is defined.

4. For the RRRM5 and RRRM9 formats, the following encodings are used for integer data types (b, b9, h, w).

5. For the RRRM5 and RRRM9 formats, the following encodings are used for floating data types.

6. For all instructions that cause an overflow, the saturation up to the int8, int9, int16, int32 maximum or minimum threshold is applied when the VCSR <ISAT> bit is set. Thus, the floating point result is saturated to -infinity, -zero, + zero or + infinity when the VCSR <FSAT> bit is set.

7. Syntactically, n can be used instead of .b9 to indicate the byte 9 data size.

8. For all instructions, the floating point result returned in the destination register or vector accumulator is in IEEE 754 single precision format. The floating point result is written to the bottom of the accumulator and the top is not modified.

VAAS3 addition and sign addition of (-1, 0, 1)

format

Assembler Syntax

Supported Mode

Explanation

The contents of the vector / scalar register Ra are added to Rb to yield an intermediate result, which is then added to the sign of Ra; The final result is stored in the vector / scalar register Rd.

calculate

exception

Overflow.

VADAC Addition and Accumulation

format

Explanation

Add each element of the Ra and Rb operands to each double precision element of the vector accumulator, and store the double accuracy sum of each element in both the vector accumulator and the destination registers Rc and Rd. Ra and Rb use the specified data types, while VAC uses the appropriate double precision data types (16, 18, 32, and 64 bits for int8, int9, int16, and int32, respectively). The top of each dual size accuracy element is stored in VACH and Rc, and the result in Rc is undefined.

VADACL Addition and Low Accumulation

format

Explanation

Add each element of the Ra and Rb / middle operands with each extended accuracy element of the vector accumulator, store the extended accuracy sum in the vector accumulator, and return the lower precision to the destination register Rd. Ra and Rb / middle use the specified data types, while VAC uses the appropriate double precision data types (16, 18, 32, and 64 bits for int8, int9, intl6, and int32, respectively). The top of each extended accuracy element is stored in the VACH.

calculate

VADD addition

format

Explanation

Add the Ra and Rb / middle operands and return the sum to the destination register Rd.

calculate

exception

Overflow, floating-point invalid operation

VADDH Add two adjacent elements

format

Explanation

calculate

exception

Overflow, floating-point invalid operation

Programming comments

This command is not affected by the element mask.

VAND AND

format

Note that dt = {b, b9, h, w}, .w and .f specify the same operation.

Supported Mode

Explanation

Logically AND the Ra and Rb / middle operations and return the result in the destination register Rd.

calculate

exception

none.

VANDC AND reward

format

Where dt = {b, b9, h, w}. Note that .w and .f specify the same operation.

Supported Mode

Explanation

Logically add the complement of Ra and Rb / middle operands and return the result to the destination register Rd.

calculate

exception

none.

VASA Arithmetic Shift Accumulator

format

Where dt = {b, b9, h, w} and R refers to the left or right shift direction.

Supported Mode

Explanation

Each data element of the vector accumulator register is shifted by one bit position with zeros padding from the right (if R = 0) or by one bit position by sign extension (if R = 1). The result is stored in a vector accumulator.

exception

Overflow.

VASL left arithmetic shift

format

Supported Mode

Explanation

Each data element of the vector / scalar register Ra is shifted from zero right to one bit left by the shift amount given in the scalar register Rb or lMM field, and the result is saturated to the maximum positive or maximum negative value depending on the sign. The shift amount is defined to be an unsigned integer.

calculate

exception

none.

Programming comments

shift-amount is taken as a 5-bit number from SRb or IMM <4: 0>. For byte and halfword data types, the programmer is responsible for specifying exactly the shift amount less than or equal to the number of bits in the data size. If the shift amount is greater than the specified data size, the element will be filled with zeros.

VASR right arithmetic shift

format

Explanation

Each data element in the vector / scalar register Ra is shifted to the right by expanding the sign at the most significant bit position by the shift amount given in the scalar register Rb or the least significant bit of the IMM field, and the result is stored in the vector / scalar register Rd. do. The shift amount is defined to be an unsigned integer.

calculate

exception

none.

Programming comments

shift-amount is taken as a 5-bit number from SRb or IMM <4: 0>. For byte, byte 9, and halfword data names, the programmer is responsible for specifying exactly the amount of shift less than or equal to the bit's equivalent in data size. If the shift amount is greater than the specified data size, the element will be filled with sign bits.

format

Explanation

The contents of the vector / scalar register Ra are added to Rb to give an intermediate result, then the sign of Ra is subtracted from the intermediate result, and the final result is stored in the vector / scalar register Rd.

calculate

exception

Overflow.

VASUB subtraction absolute value

format

Explanation

The contents of the vector / scalar register Rb or the IMM field are subtracted from the contents of the vector / scalar register Ra and the result is stored in the vector / scalar register Rd.

calculate

exception

Overflow.

VAVG average of two elements

format

Where dt = {b, b9, h, w, f}. Use VAVGT to specify the "truncate" rounding mode for integer data types.

Supported Mode

Explanation

The contents of the vector / scalar register Ra are added to the contents of the vector / scalar register Rb to yield an intermediate result, dividing the intermediate result by two, and the final result is stored in the vector / scalar register Rd. For integer data types, the rounding mode truncates if T = l and rounds away from zero if T = 0 (default). For floating data types, the rounding mode is specified in VCSR <RMODE>.

calculate

exception

none.

VAVGH Average of two adjacent elements

format

Where dt = {b, b9, h, w, f}. VAVGHT is used to specify a "truncate" rounding mode for integer data types.

Supported Mode

Explanation

For each element, two adjacent pairs of elements are averaged. For integer data types, the rounding mode truncates if T = 1 and rounds away from zero if T = 0 (default). For unequal data types, the rounding mode is specified in VCSR <RMODE>.

calculate

exception

none.

Programming comments

This command is not affected by the element mask.

VAVGQ Quad Average

format

Assembler Syntax

Here, dt = {b, b9, h, w}, VAVGQT is used to specify the "truncate" rounding mode for integer data types.

Supported Mode

Explanation

This command is not supported in VEC64 mode.

As shown in the figures below, the rounding mode specified in T (1 for trunkcate, 0 for roundaway away, default) is used to calculate the average of the four elements. The leftmost element Dn _-1 is not defined.

calculate

exception

none.

VCACHE Cache Operation

format

Assembler Syntax

Where f _c = {0.1}

Explanation

This command is provided for software management of the vector data cache. When some or all of the data cache is configured with a scratch pad, this command does not affect the scratch pad.

The following choices are supported.

calculate

exception

none.

Programming comments

This command is not affected by the element mask.

V'CAND Compensation AND

format

Where dt = {b, b9, h, w}. Note that .w and .f specify the same operation.

Supported Mode

Explanation

Logically ANDs the complement of the Ra and Rb / middle operands and returns the result to the destination register Rd.

calculate

exception

none.

VCBARR Condition Barrier

format

Where cond = {0, -7}. Each condition will later be given a mnemonic.

Explanation

As long as the condition is valid, the instruction and all subsequent instructions (commands that appear later in program order) are stagnated. The Cond <2: 0> field is interpreted unlike other conditional instructions in CT format.

The following conditions are currently defined:

calculate

exception

none.

Programming comments

This command is provided to the software by forcing serialization of command execution. This command can be used to force accurate reporting of incorrect execution. For example, if this instruction is used immediately after an arithmetic instruction that may cause an exception, this example would be reported as a program counter addressing this instruction.

VCBR conditional branch

format

Assembler Syntax

VCBR.cond #Offset

Where cond = {un, lt, eq, le, gt, ne, ge, ov}.

Explanation

If Cond is true, branch. This is not a delayed branch.

calculate

exception

Invalid instruction address.

VCBRI Conditional Branch Indirect

format

Assembler Syntax

VCBRI.cond SRb

Where cond = {un, lt, eq, le, gt, ne, ge, ov}.

Explanation

If Cond is true, branch. This is not a delayed branch.

calculate

exception

Invalid instruction address.

VCCS condition context switch

format

Explanation

If VIMSK <cse> is true, jump to the context switch subroutine. This is not a delayed branch.

If VIMAK <cse> is true, VPC + 4 (return address) is stored in the return address stack. Otherwise, execution continues to VPC + 4.

calculate

exception

Return address stack overflow.

VCHGCR Control Register Change

format

Assembler Syntax

VCHGCR Mode

Explanation

This instruction changes the operating mode of the vector processor.

Each bit in mode specifies the following:

calculate

exception

none.

Programming comments

This command is provided to the hardware to change the control bits in the VCSR in a more efficient way than is possible with the VMOV command.

VCINT condition interrupt ARM7

format

Assembler Syntax

VCINT.cond #ICODE

Where cond = {un, lt, eq, le, gt, ne, ge, ov}.

Explanation

If Cond is true, execution stops and if enabled interrupts ARM7.

calculate

exception

VCINT interrupt.

Combine conditions with VCJOIN ARM7 tasks

format

Where cond = {un, lt, eq, le, gt, ne, ge, ov}.

Explanation

If Cond is true, execution stops and if enabled interrupts ARM7.

calculate

exception

VCJOIN interrupt

Condition jumps to VCJSR subroutines

format

Assembler Syntax

VCJSR.cond #Offset

Where cond = {un, lt, eq, le, gt, ne, ge, ov}.

Explanation

If Cond is true, jump to the subroutine. This is not a delayed branch.

If Cond is true, VPC + 4 (return address) is stored in the return address stack. If not, execution continues as VPC + 4.

calculate

exception

Return address stack overflow.

Conditional Jump to VCJSRI Subroutine Indirect

format

Assembler Syntax

VCJSRI.cond SRb

Where cond = {un, lt, eq, le, gt, ne, ge, ov}.

Explanation

If Cond is true, indirect jump to subroutine. This is not a delayed branch.

If Cond is true, VPC + 4 (return address) is stored in the return address stack. If not, execution continues as VPC + 4.

calculate

exception

Return address stack overflow.

Move VCMOV Condition

format

Assembler Syntax

VCMOV.dt Rd, Rb, cond

VCMOV.dt Rd, #IMM, cond

Where dt = {b, b9, h, w, f}, cond = {un, lt, eq, le, gt, ne, ge, ov}. . Note that .f and .w specify the same operation, except that the f data type is not supported with a 9-bit intermediate operation.

Supported Mode

Explanation

If Cond is true, the contents of register Rb are moved to register Rd. ID <l: 0> additionally specifies the source and destination registers:

VR Current Bank Vector Register

SR scalar register

SY Synchronization Register

VAC vector accumulator register (see VMOV description for VAC register encoding)

calculate

exception

none.

Programming comments

This command is not affected by the element mask. VCMOVM is affected by the element mask.

The extended floating point accuracy representation in the vector accumulator uses all 576 bits for 8 elements. Thus, vector register shifts involving accumulators must specify a .b9 data size.

Moving VCMOVM Element Masks and Conditions

format

Where dt = {b, b9, h, w, f}, cond = {un, lt, eq, le, gt, ne, ge, ov}. Note that .f and .w specify the same operation, except that the .f data type is not supported with 9-bit intermediate operations.

Supported Mode

Explanation

If Cond is true, the contents of register Rb are moved to register Rd. 1D <1: 0> additionally specifies the source and destination registers:

VR Current Bank Vector Register

SR scalar register

VAC vector accumulator register (see VMOV description for VAC register encoding)

calculate

exception

none.

Programming comments

This command is affected by the VMMR element mask-VCMOV is not affected by the element mask.

The extended floating point accuracy representation in the vector accumulator uses all 576 bits for 8 elements. Thus, a vector register move relative to the accumulator must specify the .b9 data size.

Comparison and set of VCMPV masks

format

Assembler Syntax

Where dt = {b, b9, h, w, f}, cond = {1t, eq, le, gt, ne, ge}. Mask = {VGRM, VMMR}. If no mask is specified, VGRM is assumed.

Supported Mode

Explanation

The contents of the vector registers VRa and VRb are element-wise compared by performing (VRa [i] -VRb [I]) and the corresponding bit # in the VGRM (if K = 0) or VMMR register (if K = 1). i is set if the result of the comparison matches the Cond field of the VCMPV instruction, eg, if the Cond field is less than (LT), then the VGRM [i] or VMMR [i] bits are set to VRa [i] <VRb. If it is [i], it will be set.

calculate

exception

none.

Programming comments

This command is not affected by the element mask.

VCNTLZ leading zero count

format

Assembler Syntax

VCNTLZ.dt VRd, VRb

VCNTLZ.dt SRd, SRb

Where dt = {b, b9, h, w}.

Supported Mode

Explanation

For each element in Rb, count the number of leading zeros and return the count in Rd,

calculate

exception

none.

Programming comments

If all bits in the element are zero then the result is equal to the element size (8, 9, 16 or 32 for each byte, byte 9, halfword or word).

The count of leading zeros is inversely related to the index of the element position (if used after the VCMPR instruction). To convert to element position, subtract the result of VCNTLZ from NumElem for a given data type.

VCOR OR complement

format

Assembler Syntax

VCOR.dt VRd, VRa, VRb

VCOR.dt VRd, VRa, SRb

VCOR.dt VRd, VRa, #IMM

VCOR.dt SRd, SRa, SRb

VCOR.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}. Note that .w and .f specify the same operation.

Supported Mode

Explanation

Logically ORs the complement of the Ra and Rb / middle operands and returns the result to the destination register Rd.

calculate

exception

none.

Return condition from VCRSR subroutine

format

Assembler Syntax

VCRSR.cond

Where cond = {un, lt, eq, le, gt, ne, ge, ㅇ}.

Explanation

If Cond is true, execution continues from the return address stored in the return address stack. If not, continue execution as VPC + 4.

calculate

exception

Invalid instruction address. Return address stack overflow

VCVTB9 byte9 data type conversion

format

Assembler Syntax

VCVTB9.md VRd, VRb

VCVTB9.md SRd, SRb

Where md = {bb9, b9h, hb9}.

Supported Mode

Explanation

Each element in Rb is converted from byte to byte 9 (bb9), byte 9 to halfword (b9h), or halfword to byte 9 (hb9).

calculate

exception

none.

Programming comments

Before using this instruction with b9h mode, the programmer needs to adjust the reduced number of elements in the vector register with a shuffle operation. After using this instruction with hb9 mode, the programmer needs to adjust the increased number of elements in the destination vector register with a shuffle operation. This command is not affected by the element mask.

Convert VCVTFF floating point to fixed point

format

Assembler Syntax

VCVTFF VRd, VRa, SRb

VCVTFF VRd, VRa, #IMM

VCVTFF SRd, SRa, SRb

VCVTFF SRd, SRa, #IMM

Supported Mode

Explanation

The contents of the vector / scalar register Ra are formatted in 32-bit floating point. Y> is converted to a fixed-point real number, where the width of Y is specified by Rb (modulo 32) or the IMM field, and the width of X is specified by (width of 32-Y). X refers to the integer part and Y refers to the fraction part. The result is stored in the vector / scalar register Rd.

calculate

exception

Overflow

Programming comments

This command only supports word data sizes. This instruction does not use element masks because the architecture does not support multiple data types in registers. This instruction uses round away from zero rounding mode for integer data types.

VCVTIF Integer to Floating Point Conversion

format

Assembler Syntax

VCVTIF VRd, VRb

VCVTIF VRd, SRb

VCVTIF SRd, SRb

Supported Mode

Explanation

The contents of the vector / scalar register Rb are converted from int32 to a floating data type and the result is stored in the vector / scalar register Rd.

calculate

exception

none.

Programming comments

This command only supports word data sizes. This instruction does not use element masks because the architecture does not support multiple data types in registers.

Reduction and Conditional Branching of VD1CBR VCR1

format

Assembler Syntax

VD1CBR.cond #Offset

Where cond = {un, lt, eq, gt, ne, ge, ov}

Explanation

Decrease VCR1 and branch if Cond is true. This is not a delayed branch.

calculate

exception

Invalid instruction address.

Programming comments

Note that VCR1 is reduced before the branch condition is checked. Execution of this instruction when VCR1 is zero effectively sets the loop count to 2 ³² -1.

VD2CBR VCR2 Reduction and Conditional Branching

format

Assembler Syntax

VD2CBR.cond #Offset

Where cond = {un, lt, eq, gt, ne, ge, ov}

Explanation

Decrease VCR2 and branch if Cond is true. This is not a delayed branch

calculate

exception

Invalid instruction address

Programming comments

Note that VCR2 is reduced before the branch condition is checked. Execution of this instruction when VCR2 is zero effectively sets the loop count to 2 ³² -1.

VD3CBR VCR3 reduction and conditional branching

format

Assembler Syntax

VD3CBR.cond #Offset

Where cond = {un, 1t, eq, gt, ne, ge, ov}

Explanation

Decrease VCR3 and branch if Cond is true. This is not a delayed branch.

calculate

exception

Invalid instruction address.

Programming comments

Note that VCR3 is reduced before the branch condition is checked. VCR3 is at zero the execution of this command will effectively set a loop count to 2 ³² -1,

Divide by VDIV2N 2 ⁿ

format

Assembler

VDIV2N.dt VRd, VRa, SRb

VDIV2N.dt VRd, VRa, #IMM

VDIV2N.dt SRd, SRa, SRb

VDIV2N.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}

Supported Mode

Explanation

The contents of the vector / scalar register Ra are divided by 2 ⁿ where n is the positive integer content of the scalar register Ra or IMM, and the result is stored in the vector / scalar register Rd. This command uses truncates (round-forward zero) as the rounding mode.

calculate

exception

none.

Programming comments

N is taken as 5 bits from SRb or IMM <4: 0>. For byte, byte 9, and halfword data types, the programmer is responsible for specifying exactly N values less than or equal to the accuracy in the data size. If greater than the accuracy of the specified data size, the element will be filled in the sign bit. This command uses a round-toward zero rounding mode.

VDLV2N.F 2 ⁿ Divide by Float

format

Assembler Syntax

VDIV2N.f VRd, VRa, SRb

VDIV2N.f VRd, VRa, #IMM

VDIV2N.f SRd, SRa, SRb

VDIV2N.f SRd, SRa, #IMM

Supported Mode

Explanation

The contents of the vector / scalar register Ra are divided by 2 ⁿ where n is the positive integer content of the scalar register Rb or IMM, and the result is stored in the vector / scalar register Rd.

calculate

exception

none.

Programming comments

Note that N is taken as a 5-bit number from SRb or IMM <4: 0>.

VDIV initialization divide-incomplete

format

Assembler Syntax

VDIVI.ds VRb

VDIVI.ds SRb

Where ds = {b, b9, h, w}

Supported Mode

Explanation

Performs the initial stage of unsigned integer division. The pidget number is a double precision signed integer in the accumulator. If the number of jets is single precision, the sign must be extended to double accuracy and stored in VACOH and VACOL. The jet number is a single precision signed integer in Rb.

If the sign of the number of jets is the same as the sign of the number of jets, Rb is subtracted from the accumulator high. If not, Rb is added to accumulator high.

calculate

exception

none.

Programming comments

The programmer is responsible for detecting overflow or division into zero cases before the division step.

VDIVS Division Steps-Incomplete

format

Assembler Syntax

VDIVS.ds VRb

VDIVS.ds SRb

Where ds = {b, b9, h, w}

Supported Mode

Explanation

Performs one recursive step of unsigned division. This command must be executed for the size of the data (ie 8 times for int8 for type int9, 9 times for int9, 16 for int16 and 32 for int32). The VDIVI instruction must be used before the division step to create the initial partial remainder in the accumulator. The jet number is a signed single precision integer in Rb. Once the exponent bit is extracted step by step, it is shifted to the least significant bit of the accumulator.

If the sign of the remainder of the part in the accumulator is the same as the sign of the jet number in Rb, Rb is subtracted from the accumulator high. Otherwise Rb is added to the accumulator high.

If the resulting remainder of the result in the accumulator (the result of addition or subtraction) is the same as the sign of the jet number, the exponent bit is l. Otherwise, the exponent bit is zero. The accumulator is shifted left by one bit position to fill the exponent bit.

In the result of the division step, the rest is at accumulator high and the exponent is at accumulator low. The exponent is in the form of l's complement.

calculate

Shift element left by VESL 1

format

Assembler Syntax

VESL.dt SRc, VRd, VRa, SRb

Where dt = {b, b9, h, w}. Note that .w and .f specify the same operation.

Supported Mode

Explanation

The element in the vector register Ra is shifted left by one position to fill it from the scalar register Rb. The leftmost element that is shifted out is returned to scalar register Rc and the other element is returned to vector register Rd.

calculate

exception

none.

Programming comments

This command is not affected by the element mask.

Right shift element by VESR 1

format

Assembler Syntax

VESL.dt SRc, VRd, VRa, SRb

Where dt = {b, b9, h, w}. Note that .w and .f specify the same operation.

Supported Mode

Explanation

Shift the element in vector register Ra to the right by position l and fill it from scalar register Rb. The rightmost element shifted out is returned to scalar register Rc and the other element is returned to vector register Rd.

calculate

exception

none.

Programming comments

This command is not affected by the element mask.

Extracting One VEXRT Element ”

format

Assembler Syntax

VEXTRT.dt SRd, VRa, SRb

VEXTRT.dt SRd, VRa, #IMM

Where dt = {b, b9, h w}. Note that .f and .w specify the same operation.

Supported Mode

Explanation

Extract the element from the Ra vector register whose index is specified as a scalar register Rb or an IMM field and store it in the scalar register Rd.

calculate

exception

none.

Programming comments

This command is not affected by the element mask.

Extract sign of VEXTSGN2 (1, -1)

format

Assembler Syntax

VEXTSGN2.dt VRd, VRa

VEXTSGN2.dt SRd, SRa

Where dt = {b, b9, h, w}.

Supported Mode

Explanation

The sign value of the contents of the vector / scalar register Ra elementwise is calculated and the result is stored in the vector / scalar register Rd.

calculate

exception

none.

Sign extraction of VEXTSGN3 (1, 0, -1)

format

Assembler Syntax

VEXTSGN3.dt VRd, VRa

VEXTSGN3.dt SRd, SRa

Where dt = {b, b9, h, w}.

Supported Mode

Explanation

The sign value of the contents of the vector / scalar register Ra elementwise is calculated and the result is stored in the vector / scalar register Rd.

calculate

exception

none.

Insert one element of VlNSRT

format

Assembler Syntax

VINSRT.dt VRd, SRa, SRb

VINSRT.dt VRd, SRa, #IMM

Where dt = {b, b9, h, w}. Note that .w and .f specify the same operation.

Supported Mode

Explanation

Inserts the element in scalar register Ra into vector register Rd at the index specified by the scalar register Rb or IMM field.

calculate

exception

none.

Programming comments

This command is not affected by the element mask.

VL load

format

Assembler Syntax

VL.lt Rd, SRb, SRi

VL.lt Rd, SRb, #IMM

VL.lt Rd, SRb +, SRi

VL.lt Rd, SRb +, #IMM

Where lt = {b, bz9, ds9, h, w, 4, 8, l6, 32, 64}, Rd = {VRd, VRAd, SRd}. Note that .b and ds9 specify the same operation, and that .64 and VRAd cannot be specified together. Use VLOFF for cache-off loads.

Explanation

Load a vector or scalar register in the current or alternate bank.

calculate

exception

Invalid data address, unaligned access.

Programming comments

This command is not affected by the element mask.

Load from VLCB circular buffer

format

Assembler Syntax

VLCB.lt Rd, SRb, Sri

VLCB.lt Rd, SRb, #IMM

VLCB.lt Rd, SRb +, SRi

VLCB.lt Rd, SRb +, #IMM

Where lt = {b, bz9, ds9, h, w, 4, 8, 16, 32, 64}, Rd = {VRd, VRAd, SRd}. Note that .b and .ds9 specify the same operation, and that .64 and VRAd cannot be specified together. Use VLCBOFF for cache-off loads.

Explanation

From the circular buffer pointed to by pointers in the BEGIN END pointers and SR _{+ b 2 + b} in the SR 1 must load a vector register or a scalar register.

If the address update operation is larger than the END address before loading, of course, the valid address is adjusted. In addition, the circular buffer bounds must be aligned on halfword and word boundaries for the .h and .w scalar registers, respectively.

calculate

exception

Invalid data address, incorrect access.

Programming comments

This command is not affected by the element mask. The programmer must ensure the following conditions to work as expected.

BEGlN <EA <2 * END-BEGIN

That is, EA> BEGIN as well as EA-END <END-BEGIN

VLD dual load

format

Assembler Syntax

VLD.lt Rd, SRb, SRi

VLD.lt Rd, SRb, #IMM

VLD.lt Rd, SRb +, SRi

VLD.lt Rd, SRb +, #IMM

Where 1t = {b, bz9, ds9, h, w, 4, 8, 16, 32, 64}, Rd = {VRd, VRAd, SRd}. . Note that b and .ds9 specify the same operation, and that .64 and VRAd cannot be specified together. Use VLDOFF for cache-off loads.

Explanation

Load two vector registers or two scalar registers in the current or alternate bank,

calculate

exception

Invalid data address, unaligned access.

Programming comments

This command is not affected by the element mask.

VLI Medium Load

format

Assembler Syntax

VLI.dt VRd, #IMM

VLI.dt SRd, #IMM

Where dt = {b, b9, h, w, f}

Explanation

Load the intermediate value into a scalar or vector register

For scalar register loads, bytes, byte 9, halfwords, or words are loaded depending on the data type. For byte, byte 9, and halfword data types, the unaffected byte (byte 9) is not modified.

calculate

Rd = See the table below:

exception

none.

VLQ Quad Rod

format

Assembler Syntax

VLQ.lt Rd. SRb, SRi

VLQ.lt Rd, SRb, #IMM

VLQ.lt Rd, SRb +, SRi

VLQ.lt Rd, SRb +, #IMM

Where 1t = {b, bz9, ds9, h, w, 4, 8, 16, 32, 64}, Rd = {VRd, VRAd, SRd}. Note that .b and .ds9 specify the same operation, and that .64 and VRAd cannot be specified together. Use VLQOFF for cache-off loads.

Explanation

Load four vector registers or four scalar registers in the current or alternate bank.

calculate

sex(IMM＜7:0＞)};EA = SR _b + {SR _i

sex (IMM <7: 0>)};

if (A = 1) SR _b = EA ;;

R _d : R _{d + 1} : R _{d + 2} : R _{d + 3} = see table below;

exception

Invalid data address, unaligned access.

Programming comments

This command is not affected by the element mask.

VLR Inverted Load

format

Assembler Syntax

VLR.lt Rd, SRb, SRi

VLR.lt Rd, SRb, #IMM

VLR.lt Rd, SRb +, SRi

VLR.lt Rd, SRb +, #IMM

Where 1t = {4, 8, 16, 32, 64}, Rd = {VRd, VRAd}. Note that 64 and VRAd cannot be specified together. Use VLROFF for cache-off loads.

Explanation

Load vector registers in reverse element order. This instruction does not support the scalar destination register.

calculate

exception

Invalid data address, unaligned access.

Programming comments

This command is not affected by the element mask.

VLSL logical left shift

format

Assembler Syntax

VLSL.dt VRd, VRa, SRb

VLSL.dt VRd, VRa, #IMM

VLSL.dt SRd, SRa, SRb

VLSL.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}.

Supported Mode

Explanation

Each element in the vector / scalar register Ra is bitwise logically left shifted to zero at the least significant bit (LSB) position by the amount of shift given in the scalar register Rb or IMM field, and the result is stored in the vector / scalar register Rd. .

calculate

exception

none.

Programming comments

Note that shift-amount is taken as a 5-bit number from SRb or IMM <4: 0>. For byte, byte 9, and halfword data types, the programmer is responsible for specifying exactly the shift amount less than or equal to the number of bits in the data size. If the sheet amount is greater than the specified data size, the element will be filled with zeros.

VLSR logical right shift

format

Assembler Syntax

VLSR.dt VRd, VRa, SRb

VLSR.dt VRd, VRa, #IMM

VLSR.dt SRd, SRa, SRb

VLSR.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}.

Supported Mode

Explanation

Each element in the vector / scalar register Ra is logically shifted bitwise with zero filled in the most significant bit (MSB) place by the amount of shift given in the scalar register Rb or IMM field, and the result is stored in the vector / scalar register Rd. .

calculate

exception

none.

Programming comments

Note that shift-amount is taken as a 5-bit number from SRb or IMM <4: 0>. For byte, byte 9, and halfword data types, the programmer is responsible for specifying exactly the shift amount less than or equal to the number of bits in the data size. If the sheet amount is greater than the specified data size, the element will be filled with zeros.

Load into VLWS stride

format

Assembler Syntax

VLWS.lt Rd, SRb, SRi

VLWS.lt Rd, SRb, #IMM

VLWS.lt Rd, SRb +, SRi

VLWS.lt Rd, SRb +, #IMM

Where 1t = {4, 8, l6, 32}, Rd = {VRd, VRAd}. 64 mode is not supported-use VL instead. Use VLWSOFF for cache-off loads.

Explanation

Starting at the effective address, 32 bytes are loaded from memory into the vector register VRd using the scalar register SR _{b + 1} as the stride control register.

LT specifies the block size, the number of consecutive bytes to load for each block. SRb + 1 specifies a stride, the number of bytes separating the beginning of two consecutive blocks.

The stride must be equal to or larger than the block size. EA must be aligned in size. Stride and block size must be multiple data sizes.

calculate

exception

Invalid data address. Unsorted access.

VMAC multiplication and accumulation

format

Assembler Syntax

VMAC.dt VRa, VRb

VMAC.dt VRa, SRb

VMAC.dt VRa, #IMM

VMAC.dt SRa, SRb

VMAC.dt SRa, #IMM

Where dt = {b, h, w, f}.

Supported mode

Explanation

Multiply each element of Ra by each element in Rb to produce a double accuracy intermediate result; Add each double precision element of the intermediate result to each double accuracy element of a vector accumulator; The double precision sum of each element is stored in the vector accumulator.

Ra and Rb use the specified data types, while VAC uses the appropriate double-precision data types (16, 32, and 64 for int8, int16, and int32, respectively). The top of each double precision element is stored in the VACH.

For floating data types, all operands and results are of single precision type.

calculate

exception

Overflow, floating point invalid operand.

Programming comments

This command does not support the int9 data type-use the int16 data type instead.

Multiply and Accumulate VMACF Fractions

format

Assembler Syntax

VMACF.dt VRa, VRb

VMACF.dt VRa, SRb

VMACF.dt VRa, #IMM

VMACF.dt SRa, SRb

VMACF.dt SRa, #IMM

Where dt = {b, h, w}.

Supported Mode

Explanation

Multiply each element of VRa by each element in Rb to produce a double accuracy intermediate result; Shift the double precision intermediate result left by one bit; Add each double precision element of the shifted intermediate result to each double accuracy element of the vector accumulator; The double precision sum of each element is stored in the vector accumulator.

VRa and Rb use the specified data types, while VAC uses the appropriate double-accuracy data types (16, 32 and 64 for int8, int16 and int32 respectively). The top of each double precision element is stored in the VACH.

calculate

exception

Overflow.

Programming comments

This command does not support int9 data names-use the int16 data type instead.

Multiply and Accumulate VMACL Rows

format

Assembler Syntax

VMACL.dt VRd, VRa, VRb

VMACL.dt VRd, VRa, SRb

VMACL.dt VRd, VRa, #IMM

VMACL.dt SRd, SRa, SRb

VMACL.dt SRd, SRa, #IMM

Where dt = {b, h, w, f}.

Supported mode

Explanation

Multiply each element of VRa by each element in Rb to produce a double accuracy intermediate result; Add each double accuracy element of the intermediate side to each double accuracy element of a vector accumulator; Store the double precision sum of each element in the vector accumulator; The lower part is stored in the destination register VRd.

VRa and Rb use the specified data types, while VAC uses the appropriate double-precision data types (16, 32 and 64 for int8, int16 and int32 respectively). The top of each double precision element is stored in the VACH.

For floating data types, all operands and results are of single precision type.

calculate

exception

Overflow, floating point invalid operand.

Programming comments

This command does not support the int9 data type. -Use int16 data type instead

VMAD multiplication and addition

format

Assembler Syntax

VMAD.dt VRc, VRd, VRa, VRb

VMAD.dt SRc, SRd, SRa, SRb

Where dt = {b, h, w}.

Supported Mode

Explanation

Multiply each element of Ra by each element in Rb to produce a double accuracy intermediate result; Add each double precision element of the intermediate result to each element of Rc; The double precision sum of each element is stored in the destination register Rd + 1: Rd.

calculate

exception

none.

Multiply and Add VMAD L Rows

format

Assembler Syntax

VMADL.dt VRc, VRd, VRa, VRb

VMADL.dt SRc, SRd, SRa, SRb

Where dt = {b, h, w, f}.

Supported Mode

Explanation

Multiply each element of Ra by each element in Rb to produce a double accuracy intermediate result; Add each double precision element of the intermediate result to each element of Rc; The double precision sum of each element is stored in the destination register Rd.

For floating data types, all operands and results are of single precision type.

calculate

exception

Overflow, floating point invalid operand.

Multiplication and Subtraction from the VMAS Accumulator

format

Assembler Syntax

VMAS.dt VRa, VRb

VMAS.dt VRa, SRb

VMAS.dt VRa, #IMM

VMAS.dt SRa, SRb

VMAS.dt SRa, #IMM

Where dt = {b, h, w, f}.

Supported Mode

Explanation

Multiply each element of Ra by each element in Rb by producing a double accuracy intermediate result; Subtract each double precision element of the intermediate result from each double precision element of a vector accumulator; The double precision sum of each element is stored in the vector accumulator.

Ra and Rb use the specified data types, while VAC uses the appropriate double-precision data hooks (l6, 32, and 64 for int8, int16, and int32, respectively). The top of each double precision element is stored in the VACH.

For floating data types, all operands and results are of single precision type.

calculate

exception

Overflow, floating point invalid operand.

Programming comments

This command does not support the int9 data type-use the intl6 data type instead.

Multiplication and Subtraction from VMASF Accumulator Fractions

format

Assembler Syntax

VMASF.dt VRa, VRb

VMASF.dt VRa, SRb

VMASF.dt VRa, #IMM

VMASF.dt SRa, SRb

VMASF.dt SRa, #IMM

Where dt = {b, h, w}.

Supported Mode

Explanation

Multiply each element of VRa by each element in Rb to produce a double accuracy intermediate result; Shift the double precision intermediate result by one: subtract each double accuracy element of the shifted intermediate result from each double accuracy element of a vector accumulator; The double precision sum of each element is stored in the vector accumulator.

VRa and Rb use the specified data types, while VAC uses the appropriate double-accuracy data types (16, 32 and 64 for int8, int16 and int32 respectively). The top of each double precision element is stored in the VACH.

calculate

exception

Overflow.

Programming comments

This command does not support the int9 data type-use the int16 data type instead.

Multiplication and Subtraction from VMASL Accumulator Rows

format

Assembler Syntax

VMASL.dt VRd, VRa, VRb

VMASL.dt VRd, VRa, SRb

VMASL.dt VRd, VRa, #IMM

VMASL.dt SRd, SRa, SRb

VMASL.dt SRd, SRa, #IMM

Where dt = {b, h, w, f}.

Supported Mode

Explanation

Multiply each element of VRa by each element in Rb to produce a double accuracy intermediate result; Subtract each double precision element of the intermediate result from each double precision element of a vector accumulator; Store the double precision sum of each element in the vector accumulator; Return the bottom part to the destination register VRd.

VRa and Rb use the specified data types, while VAC uses the appropriate double-accuracy data types (16, 32 and 64 for int8, int16 and int32 respectively). The top of each double precision element is stored in the VACH.

For floating data types, all operands and results are of single precision type.

calculate

exception

Overflow, floating point invalid operand.

Programming comments

This command does not support the int9 data type-use the int6 data type instead.

VMAXE pairwise max and exchange

format

Assembler Syntax

VMAXE.dt VRd, VRb

Where dt = {b, b9, h, w, f}.

Supported Mode

Explanation

VRa is the same as VRb. If VRa is different from VRb, the result is undefined.

Each odd / even data element of the vector register VRb is compared in pairs, and the large value of each data element pair is stored in the even place and the small value of each data element pair is stored in the odd place of the vector register Rd.

calculate

exception

none.

Move VMOV

format

Assembler Syntax

VMOV.dt Rd, Rb

Where dt = {b, b9, h, w, f}, Rd and Rb refer to the architecturally designated register name. Note that .w and .f specify the same operation.

Supported Mode

Explanation

The contents of register Rb are moved to register Rd. The group field specifies the source and destination register groups. The register group comments are as follows:

VR Current Bank Vector Register

VRA Alternate Bank Vector Register

SR scalar register

RASR Return Address Stack Register

VAC vector accumulator registers (see VAC register encoding below).

Note that the vector register cannot be moved to the scalar register with this instruction. The VEXTRT command is provided for this purpose.

Use the following table for VAC register encoding:

calculate

Rd = Rb

exception

Setting the exception status to VCSR or VISRC will result in the corresponding exception.

Programming comments

This command is not affected by the element mask. Since the alternate bank concept does not exist in VEC64 mode, this command cannot be used to move from or to the alternate bank in VEC64 mode.

VMUL multiplication

format

Assembler Syntax

VMUL.dt VRc, VRd, VRa, VRb

VMUL.dt SRc, SRd, SRa, SRb

Where dt = {b, h, w}.

Supported Mode

Explanation

To produce a double precision result, each element of Ra is multiplied with each element in Rb and the double precision sum of each element is returned to the destination registers Rc: Rd.

Ra and Rb use the specified data types, whereas Rc: Rd uses the appropriate double precision data types (16, 32, and 64 for int8, int16, and int32, respectively). The top of each double precision element is stored in Rc.

calculate

exception

none

Programming comments

This command does not support the int9 data type-use the intl6 data type instead. This command also does not support floating data types because the extended result is not a supported data type.

Multiplication for VMULA Accumulator

Format

Assembler Syntax

VMULA.dt VRa, VRb

VMULA.dt VRa, SRb

VMULA.dt VRa, #IMM

VMULA.dt SRa, SRb

VMULA.dt SRa, #IMM

Where dt = {b, h, w, f}.

Supported Mode

Explanation

Multiply each element of VRa by each element in Rb to produce a double accuracy result; Record the results in the accumulator.

For floating data types, all operands and results are of single precision type.

calculate

exception

none

Programming comments

This command does not support the int9 data type-use the int16 data type instead.

Multiplication for VMULAF Accumulator Fraction

format

Assembler Syntax

VMULAF.dt VRa, VRb

VMULAF.dt VRa, SRb

VMULAF.dt VRa, #IMM

VMULAF.dt SRa, SRb

VMULAF.dt SRa, #IMM

Where dt = {b, h, w}.

Supported Mode

Explanation

Multiply each element of VRa by each element in Rb to produce a double accuracy intermediate result; Shift the double precision intermediate result one bit to the left; Record the results in the accumulator.

calculate

exception

none

Programming comments

This command does not support the int9 data type-use the int6 data type instead.

VMULF fractional multiplication

format

Assembler Syntax

VMULF.dt VRd, VRa, VRb

VMULF.dt VRd, VRa, SRb

VMULF.dt VRd, VRa, #IMM

VMULF.dt SRd, SRa, SRb

VMULF.dt SRd, SRa, #IMM

Where dt = {b, h, w}.

Supported Mode

Explanation

Multiply each element of VRa by each element in Rb to produce a double precision intermediate result: shift the double precision intermediate result one bit to the left; Return the top of the result to destination register VRd + 1 and destination register VRd. VRd must be an even numbered register.

calculate

exception

none

Programming comments

This command does not support the int9 data type-use the int6 data type instead.

VMULFR Fraction Multiplication and Rounds

format

Assembler Syntax

VMULFR.dt VRd, VRa, VRb

VMULFR.dt VRd, VRa, SRb

VMULFR.dt VRd, VRa, #IMM

VMULFR.dt SRd, SRa, SRb

VMULFR.dt SRd, SRa, #IMM

Where dt = {b, h, w}.

Supported Mode

Explanation

Multiply each element of VRa by each element in Rb to produce a double accuracy intermediate result; Shift the double precision intermediate result one bit to the left; Round the shifted intermediate result to the top; The upper part registers the destination.

calculate

exception

none

Programming comments

This command does not support the int9 data type-use the int16 data type instead.

VMULL low multiplication

format

Assembler Syntax

VMULL.dt VRd, VRa, VRb

VMULL.dt VRd, VRa, SRb

VMULL.dt VRd, VRa, #IMM

VMULL.dt SRd, SRa, SRb

VMULL.dt SRd, SRa, #IMM

Where dt = {b, h, w, f}.

Supported Mode

Explanation

Multiply each element of VRa by each element in Rb to produce a double accuracy result; Return the top of the result to the destination register VRd.

For floating data types, all operands and results are of single purity type

calculate

exception

Overflow, floating point invalid operand.

Programming comments

This command does not support the int9 data type-use the int16 data type instead.

VMULF NAND

format

Assembler Syntax

VNAND.dt VRd, VRa, VRb

VNAND.dt VRd, VRa, SRb

VNAND.dt VRd, VRa, #IMM

VNAND.dt SRd, SRa, SRb

VNAND.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}. .w and .f specify the same operation.

Supported Mode

Explanation

Logically NAND each bit of each element in Ra with a corresponding bit in the Rb / middle operation; Return the result to Rd.

calculate

exception

none

VNOR NOR

format

Assembler Syntax

VNOR.dt VRd, VRa, VRb

VNOR.dt VRd, VRa, SRb

VNOR.dt VRd, VRa, #IMM

VNOR.dt SRd, SRa, SRb

VNOR.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}. .w and .f specify the same operation.

Supported Mode

Explanation

Logically NOR each bit of each element in Ra with the corresponding bit in Rb / intermediate open; Return the result to Rd.

calculate

exception

none

VOR OR

format

Assembler Syntax

VOR.dt VRd, VRa, VRb

VOR.dt VRd, VRa, SRb

VOR.dt VRd, VRa, #IMM

VOR.dt SRd, SRa, SRb

VOR.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}. .w and .f specify the same operation.

Supported Mode

Explanation

Logically OR each bit of each element in Ra with the corresponding bit in the Rb / middle operation; Return the result to Rd.

calculate

exception

none

VORC OR reward

format

Assembler Syntax

VORC.dt VRd, VRa, VRb

VORC.dt VRd, VRa, SRb

VORC.dt VRd, VRa, #IMM

VORC.dt SRd, SRa, SRb

VORC.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}. .w and .f specify the same operation.

Supported Mode

Explanation

Logically OR each bit of each element in Ra with the corresponding bit in the Rb / middle operation; Return the result to Rd.

calculate

exception

none

VPFTCH Prefetch

format

Assembler Syntax

VPFTCH.dt SRb, SRi

VPFTCH.dt SRb, #IMM

VPFTCH.dt SRb +, SRi

VPFTCH.dt SRb +, #IMM

Where In = {1, 2, 4, 8}.

Explanation

Prefetch a plurality of vector data cache lines starting from a valid address. The number of cache lines is specified as follows:

LN <1: 0> = 00: 1 The 64 byte cache line is prefetched.

LN <1: 0> = 01: 2 The 64 byte cache line is prefetched.

LN <1: 0> = 10: 4 The 64 byte cache line is prefetched.

LN <l: 0> = 1l: 8 The 64 byte cache line is prefetched.

calculate

exception

Invalid data address exception

Programming comments

EA <31: 0> refers to the byte address in local memory.

Prefetch for VPFTCHSP Scratch Pads

format

Assembler Syntax

VPFTCHSP.ln SRp, SRb, SRi

VPFTCHSP.ln SRp, SRb, #IMM

VPFTCHSP.ln SRp, SRb +, SRi

VPFTCHSP.ln SRp, SRb +, #IMM

Where In = {1, 2, 1, 8}. VPFTCH and VPFTCHSP have the same opcode.

Explanation

Transfer multiple 64 byte blocks from memory to the scratch pad. The effective address provides the start address in memory and the SRp provides the start address in the scratch pad. The number of 64 byte blocks is specified as follows:

LN <1: 0> = 00: 1 A 64 byte block is transmitted.

LN <1: 0> = 01: 2 64 byte blocks are transmitted.

LN <1: 0> = 10: 4 64 byte blocks are transmitted.

LN <1: 0> = 11: 8 A 64 byte block is transmitted.

If the effective address is not on a 64 byte boundary, it is truncated to be aligned to the 64 byte boundary first. If the scratch pad pointer address in SRp is not on a 64 byte boundary, it is also truncated to align on a 64 byte boundary. The aligned scratch pad pointer address is incremented by the number of bytes transmitted.

calculate

exception

Invalid data address exception

Rotate VROL Left

format

Assembler Syntax

VROL.dt VRd, VRa, SRb

VROL.dt VRd, VRa, #IMM

VROL.dt SRd, SRa, SRb

VROL.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w} ..

Supported Mode

Explanation

Each data element of the vector / scalar register Ra is rotated left by the amount of bits given in the scalar register Rb or IMM field, and the result is stored in the vector / scalar register Rd.

calculate

exception

none.

Programming comments

rotate-amount is taken as a 5-bit number from SRb or IMM <4: 0>. For byte, byte 9, and halfword data types, the programmer is responsible for specifying exactly the amount of rotation less than or equal to the number of bits in the data size. If the amount of rotation is greater than the specified data size, the result is undefined.

Left n rotation equals ElemSize-n rotation to the right. Here, ElemSize refers to the number of bits in a predetermined data size.

Turn right to VROR

format

Assembler Syntax

VROR.dt VRd, VRa, SRb

VROR.dt VRd, VRa, #IMM

VROR.dt SRd, SRa, SRb

VROR.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}.

Supported Mode

Explanation

Each data element of the vector / scalar register Ra is rotated right by the amount of bits given in the scalar register Rb or IMM field, and the result is stored in the vector / scalar register Rd.

calculate

exception

none.

Programming comments

rotate_amount is taken as a 5-bit number from SRb or IMM <4: 0>. For byte, byte 9, and halfword data types, the programmer is responsible for specifying exactly the amount of rotation less than or equal to the number of bits in the data size. If the amount of rotation is greater than the specified data size, the result is undefined.

Left n rotation equals ElemSize-n rotation to the right. Here, ElemSize refers to the number of bits in a predetermined data size.

VROUND floating point to integer

format

Assembler Syntax

VROUND.rm VRd, VRb

VROUND.rm SRd, SRb

Where rm = {ninf, zero, near, pinf}.

Supported Mode

Explanation

The contents of the vector / scalar register Rb in the floating point data format are rounded to the nearest 32-bit integer (word), and the result is stored in the vector / scalar register Rd. The rounding mode is defined in the RM.

calculate

exception

none.

Programming comments

This command is not affected by the element mask.

Saturate up to the lower round than VSAT1

format

Assembler Syntax

VSATL.dt VRd, VRa, VRb

VSATL.dt VRd, VRa, SRb

VSATL.dt VRd, VRa, #IMM

VSATL.dt SRd, SRa, SRb

VSATL.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}. Note that the .f data type is not supported with a 9-bit middle.

Supported mode

Explanation

Each data element of the vector / scalar register Ra is checked against its corresponding lower limit in the vector / scalar register Rb or IMM field. If the value of the data element is less than the lower limit, it is set equal to the lower limit and the final result is stored in the vector / scalar register Rd.

calculate

exception

none.

Saturation Up to Round Above VSATU

format

Assembler Syntax

VSATU.dt VRd, VRa, VRb

VSATU.dt VRd, VRa, SRb

VSATU.dt VRd, VRa, #IMM

VSATU.dt SRd, SRa, SRb

VSATU.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w, f}. Note that the .f data type is not supported with a 9-bit middle.

Supported Mode

Explanation

Each data element of the vector / scalar register Ra is checked against its corresponding upper limit in the vector / scalar register Rb or IMM field. If the value of the data element is greater than the upper limit, it is set equal to the upper limit and the final result is stored in the vector / scalar register Rd.

calculate

exception

none.

VSHFL Shuffle

format

Assembler Syntax

VSHFL.dt VRc, VRd, VRa, VRb

VSHFL.dt VRc, VRd, VRa, SRb

Where dt = {b, b9, h, w, f}. . Note that w and f specify the same operation.

Supported Mode

Explanation

The contents of the vector register Ra are shuffled with Rb, and the result is stored in the vector registers Rc: Rd as shown below.

calculate

exception

none.

Programming comments

This command does not use an element mask.

VSHFLH High Shuffle

format

Assembler Syntax

VSHFLH.dt VRd, VRa, VRb

VSHFLH.dt VRd, VRa, SRb

Where dt = {b, b9, h, w, f}. w and. Note that f only specifies the operation.

Supported Mode

Explanation

The contents of the vector register Ra are shuffled with Rb, and the top of the result is stored in the vector register Rd as shown below.

calculate

exception

none.

Programming comments

This command does not use an element mask.

VSHFLL Low Shuffle

format

Assembler Syntax

VSHFLL.dt VRd, VRa, VRb

VSHFLL.dt VRd, VRa, SRb

Where dt = {b, b9, h, w, f}. Note that w and .f specify the same operation.

Supported Mode

Explanation

The contents of the vector register Ra are shuffled with Rb, and the lower part of the result is stored in the vector register Rd as shown below.

calculate

exception

none.

Programming comments

This command does not use an element mask.

VST storage

format

Assembler Syntax

VST.st Rs, SRb, SRi

VST.st Rs, SRb, #IMM

VST.st Rs, SRb +, SRi

VST.st Rs, SRb +, #IMM

Where st = {b, b9t, h, w, 4, 8, 16, 32, 64}. Rs = {VRs, VRAs, SRS} Note that .b and .b9t specify the same operation, and that .64 and VRAs cannot be specified together. Use VSTOFF for cache-off storage.

Explanation

Stores a vector or scalar register.

calculate

exception

Invalid data address, unaligned access

Programming comments

This command is not affected by the element mask.

Save to VSTCB circular buffer

format

Assembler Syntax

VSTCB.st Rs, SRb, SRi

VSTCB.st Rs, SRb, #IMM

VSTCB.st Rs, SRb +, SRi

VSTCB.st Rs, SRb +, #IMM

Where st = {b, b9t, h, w, 4, 8, 16, 32, 64}, Rs = {VRs, VRAs, SRs}. Note that .b and .b9t specify the same operation and that .64 and VRAd cannot be specified together. Use VSTCBOFF for cache-off loads.

Explanation

And from SR _{b +} pointed to by the pointer BEGIN and END pointers in the SR _{+ b 2} in the _first circular buffer storing a vector or a scalar register.

If the address update operation is larger than the END address before storing, of course, the effective address is adjusted. In addition, circular buffer bounds must be aligned on halfword and word boundaries, respectively, for .f and .w scalar loads.

calculate

exception

Invalid data address, unaligned access.

Programming comments

This command is not affected by the element mask.

The programmer must ensure that the following instructions work as expected.

BEGlN <EA <2 * END-BEGIN

In other words, EA-END <END-BEGIN as well as EA <BEGIN.

VSTD dual storage

format

Assembler Syntax

VSTD.st Rs, SRb, SRi

VSTD.st Rs, SRb, #IMM

VSTD.st Rs, SRb +, SRi

VSTD.st Rs, SRb +, #IMM

Where st = {b, b9t, h, w, 4, 8, l6, 32, 64}, Rs = {VRs, VRAs, SRs}. Note that .b and .b9t specify the same operation, and that .64 and VRAs cannot be specified together. Use VSTDOFF for cache-off storage.

Explanation

Store two vector registers or four scalar registers from the current or alternate bank.

calculate

exception

Invalid data address, unaligned access.

Programming comments

This command is not affected by the element mask.

VSTQ Quad storage

format

Assembler Syntax

VSTQ.st Rs, SRb, SRi

VSTQ.st Rs, SRb, #IMM

VSTQ.st Rs, SRb +, SRi

VSTQ.st Rs, SRb +, #IMM

Where st = {b, b9t, h, w, 4, 8, 16, 32, 64}, Rs = {VRs, VRAs, SRs}. Note that .b and .b9t specify the same operation, and that .64 and VRAs cannot be specified together. Use VSTQOFF for cache-off storage.

Explanation

calculate

Stores four vector registers or four scalar registers from the current or alternate bank.

exception

Invalid data address, unaligned access.

Programming comments

This command is not affected by the element mask.

VSTR Invert Save

format

Assembler Syntax

VSTR.st Rs, SRb, SRi

VSTR.st Rs, SRb, #IMM

VSTR.st Rs, SRb +, SRi

VSTR.st Rs, SRb +, #IMM

Where st = {4, 8, 16, 32, 64}, Rs = {VRs, VRAs}. Note that .64 and VRAs cannot be specified together. Use VSTROFF for cache-off storage.

Explanation

calculate

Store vector registers in reverse element order. This command does not support the scalar data source register.

calculate

exception

Invalid data address, unaligned access.

Programming comments

This command is not affected by the element mask.

Save as VSTWS stride

format

Assembler Syntax

VSTWS.st Rs, SRb, SRi

VSTWS.st Rs, SRb, #IMM

VSTWS.st Rs, SRb +, SRi

VSTWS.st Rs, SRb +, #IMM

Where st = {8, 16, 32}, Rs = {VRs, VRAs}. .64 loading is not supported-use VST instead. Use VSTWSOFF for cache-off storage.

Explanation

Starting at the effective address, 32 bytes are stored in memory at the vector register VRs using the scalar register SR _{b + 1} as the stride control register.

ST specifies the block size, the number of consecutive bytes stored in each block, and SRb + 1 specifies the stride, the number of bytes separating the beginning of two consecutive blocks.

The stride must be equal to or larger than the block size. EAs must be aligned on data size. Stride and block size must be of multiple data size types.

calculate

exception

Invalid data access, unsorted access.

VSUB subtraction

format

Assembler Syntax

VSUB.dt VRd, VRa, VRb

VSUB.dt VRd, VRa, SRb

VSUB.dt VRd, VRa, #IMM

VSUB.dt SRd, SRa, SRb

VSUB.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w, f}.

Supported Mode

Explanation

The contents of the vector / scalar register Rb are subtracted from the contents of the vector / scalar register Ra, and the result is stored in the vector / scalar register Rd.

calculate

exception

Overflow, floating point invalid operand.

VSUBS subtraction and set

format

Assembler Syntax

VSUBS.dt SRd, SRa, SRb

VSUBS.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w, f}.

Supported Mode

Explanation

SRb is subtracted from SRa; The result is stored in SRd, and the VFLAG bit in the VCSR is set.

calculate

exception

Overflow, floating point invalid operand.

VUNSHFL Unshuffle

format

Assembler Syntax

VUNSHFL.dt VRc, VRd, VRa, VRb

VUNSHFL.dt VRc, VRd, VRa, SRb

Where dt = {b, b9, h, w, f}. Note that .w and .f specify the same operation.

Supported Mode

Explanation

The contents of the vector register VRb are unshuffled with Rb into the vector register VRc: VRd as shown below.

calculate

exception

none.

Programming comments

This command does not use an element mask.

VUNSHFLH High Low Unshuffle

format

Assembler Syntax

VUNSHFLH.dt VRd, VRa, VRb

VUNSHFLH.dt VRd, VRa, SRb

Where dt = {b, b9, h, w, f}. Note that .w and .f specify the same operation.

Supported Mode

Explanation

The contents of the vector register VRa are unshuffled with Rb, and the top of the result is returned to the vector register VRd as shown below.

calculate

exception

none.

Programming comments

This command does not use an element mask.

Unshuffle VUNSHFLL Low

format

Assembler Syntax

VUNSHFLL.dt VRd, VRa, VRb

VUNSHFLL.dt VRd, VRa, SRb

Where dt = {b, b9, h, w, f}. Note that w and .f specify the same operation

Supported Mode

Explanation

The contents of the vector register VRa are unshuffled with Rb, and the bottom of the result is returned to the vector register VRd as shown below.

calculate

exception

none.

Programming comments

This command does not use an element mask.

VWBACK record

format

Assembler Syntax

VWBACK.ln SRb, SRi

VWBACK.ln SRb, #IMM

VWBACK.ln SRb +, SRi

VWBACK.ln SRb +. #IMM

Where In = {1, 2, 4, 8}.

Explanation

The cache line whose index is specified by the EA in the vector data cache (as opposed to its matching EA) is updated in memory if it contains modified data. If more than one cache line is specified, the next sequential cache line is updated in memory if it contains modified data. The number of cache lines is specified as follows.

LN <1: 0> = 00: 1 A 64 byte cache line is written.

LN <1: 0> = 01: 2 A 64 byte cache line is written.

LN <1: 0> = 10: 4 A 64 byte cache line is written.

LN <1: 0> = 11: 8 A 64 byte cache line is written.

If the effective address is not on a 64 byte boundary, it is truncated to be aligned first on the 64 byte boundary.

calculate

exception

Invalid data address exception.

Programming comments

EA <31: 0> refers to bytes in local memory

Record from VWBACKSP scratch pad

format

Assembler Syntax

VWBACKSP.ln SRp, SRb, SRi

VWBACKSP.ln SRp, SRb, #IMM

VWBACKSP.ln SRp, SRb +, SRi

VWBACKSP.ln SRp, SRb +, #IMM

Where In = {l, 2, 4, 8}. Note that VWBACK and VWBACKSP use the same opcode.

Explanation

Transfer multiple 64 byte blocks from scratch pad to memory. The effective address provides the start address in memory and the SRp provides the start address in the scratch pad. The number of 64-byte blocks is specified as follows:

LN <1: 0> = 00: 1 64 blocks are transmitted.

LN <1: 0> = 01: 2 64 blocks are transmitted.

LN <1: 0> = 10: 4 68 blocks are transmitted.

LN <1: 0> = 11: 8 64 blocks are transmitted.

If the effective address is not on a 64 byte boundary, it is truncated to be aligned first on the 64 byte boundary. If the scratch pad pointer address in SRp is not on a 64 byte boundary, it is also truncated to align on a 64 byte boundary. The aligned scratch pad pointer address is incremented by the number of bytes transmitted.

calculate

exception

Invalid data address exception.

Programming comments

EA <31: 0> refers to the bytes in local memory.

VXNOR XNOR (Exclusive NOR)

format

Assembler Syntax

VXNOR.dt VRd, VRa, VRb

VXNOR.dt VRd, VRa, SRb

VXNOR.dt VRd, VRa, #IMM

VXNOR.dt SRd, SRa, SRb

VXNOR.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}.

Supported Mode

Explanation

The contents of the vector / scalar register Ra are logically XNORed to the contents of the vector / scalar register Rb and the result is stored in the vector / scalar register Rd.

calculate

exception

none.

VXOR XOR (Exclusive OR)

format

Assembler Syntax

VXOR.dt VRd, VRa, VRb

VXOR.dt VRd, VRa, SRb

VXOR.dt VRd, VRa, #IMM

VXOR.dt SRd, SRa, SRb

VXOR.dt SRd, SRa, #IMM

Where dt = {b, b9, h, w}.

Supported Mode

Explanation

The contents of the vector / scalar register Ra are logically XORed with the contents of the vector / scalar register Rb and the result is stored in the vector / scalar register Rd.

calculate

exception

none.

VXORALL XOR (exclusive OR) of all elements

format

Assembler Syntax

VXORALL.dt SRd, VRd

Where dt = {b, b9, h, w}. Note that .b and .b9 refer to the same operation.

Supported Mode

Explanation

The least significant bit of each element in VRb is XORed together, and a 1 bit result is returned at the least significant bit of SRd. This command is not affected by the element mask.

calculate

exception

none.

Claims (4)

A set of scalar registers adapted to store a single scalar value; A set of vector registers adapted to store a number of data elements; And a processing circuit coupled to the scalar register and the vector register, the method comprising: a single instruction plural data processing in which a scalar / vector operation is combined; Providing the scalar register set and the vector register set to the processing circuit; Separating the scalar register set independently from the vector register set; Extracting a scalar register number and a scalar value from the instruction; Determining the instruction rule such that the number of scalar registers can identify a vector register in the vector register set; And performing parallel operation by multiplying each of the data elements of the vector register identified by the number of scalar registers by the scalar value or adding the scalar value to each of the data elements to produce a vector result. Characterized in that the processing circuit operation method. The method of claim 1, wherein the processing circuit calculation method comprises: Extracting the number of vector registers from the instruction; Determining the instruction rule so that the number of vector registers can identify a scalar register in the scalar register set; And And reading said scalar value from a scalar register identified by said number of vector registers for associating with said data elements. The method of claim 5, Extracting the scalar value from the instruction to combine with the data elements. A set of scalar registers adapted to store a single scalar value; A set of vector registers adapted to store a number of data elements; Processing circuitry coupled to the scalar register and the vector register; In the processor having a scalar / vector operation combined single instruction for processing multiple data processing, Providing the scalar registers and vector registers in the processor; Assigning each scalar register a register number distinct from a register number assigned to another scalar register; Assigning to each vector register a register number at least some of the register numbers assigned to the vector registers are the same as the register numbers assigned to the scalar registers and are distinct from register numbers assigned to other vector registers; Decoding an instruction comprising a first operand that is a register number identifying a scalar register and a second operand that is a register number identifying a vector register and a third operand identifying a data element in the vector register ; And Between the scalar register identified by the first operand and the data element in the vector register identified by the second operand or between the scalar register and the second operand identified by the first operand. Between the data elements identified by the third operand in the vector register identified by the operand or by the scalar register and the second operand identified by the first operand. And executing data by moving data between data elements in the vector register identified by a value stored in the scalar register.

Images