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

Abstract

A vector processor including scalar registers for scalar values, and vector registers for vectors with multiple data elements. An operation performed by a vector processor processes two or more vector operands to determine the magnitude of a vector, combines scalar operands and vector operands to determine the magnitude of a vector, and combines two or more The scalar operands are combined to determine the scalar quantity. Scalar registers also operate on individual data elements in vector registers.

Description

Single-instruction-multiple-data processing in the multi-media signal processor and device thereof

The present invention relates to Digital Signal Processing, the method and the device thereof that particularly carry out parallel processing for a plurality of data elements to each instruction of multimedia function (such as the Audio and Video Code And Decode).

This patent document relates to and the following simultaneously patent application of application of reference:

U.S. Patent application serial number UNKNOWN1, attorney docket M-4354 is entitled as " Multiprocessor Operation in a Multimedia Signal Processor (multiprocessor operations in the multi-media signal processor) ";

U.S. Patent application serial number UNKNOWN2, attorney docket M-4355 is entitled as " Single-Instruction-Multiple-Data Processing in a Multimedia Signal Processor (in the multi-media signal processor single-instruction multiple-data process) ";

U.S. Patent application serial number UNKNOWN3, attorney docket M-4365 is entitled as " Efficient Context Saving and Restoring in Multiprocessors (efficient Locale Holding and recovery in the multiprocessor) ";

U.S. Patent application serial number UNKNOWN4, attorney docket M-4366 is entitled as " System and Method for Handlmg Software Interrupts with Argument Passing (processing has the system and method for the software interrupt of parameter transmission) ";

U.S. Patent application serial number UNKNOWN5, attorney docket M-4367 is entitled as " System and Method for Handling Interrupts and Exception Events in an Asymmetric Multiprocessor Architecture (system and method for handling interrupt and anomalous event in asymmetric multi-processor structure) ";

Ask serial number UNKNOWN6 in the United States Patent (USP), attorney docket M-4368 is entitled as " Methods and Apparatus for Processing Video Data (method and apparatus of processing video data) ";

U.S. Patent application serial number UNKNOWN7, attorney docket M-4369 is entitled as " Smgle-Instruction-Multiple Data Processing Using Multiple Banks of Vector Registers (adopting the single-instruction multiple-data of a plurality of vector registor groups to process) "; And

The programmable digital signal processor (DSPs) that is used for multimedia application (for example real-time video Code And Decode) needs great disposal ability, in order to process a large amount of data in finite time. Several structures of digital signal processor are well-known. The universal architecture that most of microprocessors adopt generally needs high operate frequency, so that the DSP with the computing capability that is enough to carry out the real-time video coding or decodes to be provided. This makes this DSP expensive.

Very long instruction word (VLIW) processor is a kind of DSP with a lot of functional units, and the major part in these functional units is carried out different, relatively simple task. The single instruction of VLIW DSP can be 128 bytes or longer, and has a plurality of independently by the part of functional unit executed in parallel independently. VLIW DSPs has very strong computing capability, because many functional units can concurrent working. VLIW DSPs also has relatively low cost, because each functional unit is relatively little and simple. The problem that VLIW DSPs exists is to process I/O control, be unsuitable for the function aspects inefficiency of a plurality of functional unit executed in parallel of using VLIW DSP with main computer communication and other. In addition, the software of VLIW is different from traditional software and exploitation difficulty, in default of programming tool be familiar with the programmer of VLIW software configuration. Therefore, can provide the DSP of reasonable cost, high computing capability and familiar programmed environment is that multimedia application is looked for.

The purpose of this invention is to provide a kind of single-instruction-multiple-data processing and device thereof.

According to one aspect of the invention, a multimedia digital signal processor (DSP) comprises a vector processor, and this vector processor operation vector data (being that every operand has a plurality of data elements) is to provide high throughput. This processor uses the SIMD organization of RISC type instruction collection. The programmer can adapt to the programmed environment of vector processor at an easy rate, because it is similar to the programmed environment of the general processor that most of programmer is familiar with.

DSP comprises the general vector registor of a cover. Each vector registor has regular length, but is divided into the independent data element that a plurality of users can select length. Therefore, being stored in data element prime number in the vector registor depends on and is the selected length of this element. For example 32 byte registers can be divided into 32 8 data element, 16 16 data element, or 8 32 data element. The selection of data length and type is determined by the instruction of processing the data relevant with vector registor, and an execution data path of instruction is carried out a plurality of parallel work-flows, and this depends on the data length that instruction is indicated.

The instruction of vector processor can the directed quantity register or scalar register as operand, and operate concurrently a plurality of data elements of a plurality of vector registors, in order to improve computing capability. An exemplary instruction set of vector processor of the present invention comprises: the coprocessor interface operation; Flow control operations: load/store operations; And logic/arithmetical operation. The operation that logic/arithmetical operation comprises combines a plurality of data elements of the data vector that bears results to corresponding a plurality of data elements in same or a plurality of other vector registors of a plurality of data elements of a vector registor. Other logic/arithmetical operation mixes the various data elements of one or more vector registors, or the data element of vector registor is combined with scalar.

A kind of structure extension of this vector processor has added scalar register, and each scalar register comprises a scalar data element. The combination of scalar sum vector registor has made things convenient for the instruction set with vector processor to expand to comprise concurrently the operation of the same scalar value combination of each data element of a vector. For example, an instruction be multiply by a scalar value to a plurality of data elements of a vector. Scalar register also provides a position, is used for the individual data element that vector registor will extract or deposit in from vector registor to storage. Scalar register is to transmission information between vector processor and coprocessor (structure of this coprocessor only provides scalar register) and also very convenient to calculating the used effective address of load/store operations.

According to a further aspect in the invention, a plurality of vector registors in the vector processor are organized as a plurality of groups. Each group can be selected as " current (current) " group, and another group then is " substituting (alternative) " group. The indication of " current group " position is current group in the control register of vector processor. In order to reduce the required figure place of mark vector register, some instruction only provides the register number of a vector registor in identifying current group. Load/store instruction has an extra order to identify the vector registor of any one group. Therefore, load/store operations can be taken out data and be delivered to alternate sets during the data of operation in current group. This helps the software pipeline operation of image processing and figure process, and reduces the delay of processor when fetching data, because with the load/store operations of accessing the alternative registers group, logic/arithmetical operation can not carried out in order. In other instruction, alternate sets allow to be used the Double Length vector registor, and this register comprises one from current group vector registor, and the corresponding vector registor from alternate sets. This Double Length register can be differentiated according to syntax of instructions. Control bit in the vector processor can be set, so that default vector length is one or two vector registor. Alternate sets also allows to use the operand of explicit identification still less in the complicated order syntax, as the conditional jump of shuffling (shuffle), going to shuffle (unshuffle), saturated (saturate) and having two sources and two destination registers.

Vector processor is also realized novel instruction, as Siping City all (average quad), shuffle, go to shuffle, paired mode maximum (pair-wise maximum) and exchange (exchange) and saturated. These instructions are carried out, and to operate in the multimedia function (for example Video coding and decoding) be common, and replace realizing in other instruction set 2 required or more instruction of said function. Thereby the vector processor instruction set has been improved efficient and the speed of multimedia application Program.

Describe the preferred embodiments of the present invention in detail below in conjunction with accompanying drawing, wherein,

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

Fig. 2 is the block diagram of vector processor of the multimedia processor of Fig. 1.

Fig. 3 is the block diagram of fetching unit of the vector processor of Fig. 2.

Fig. 4 is the block diagram of fetching unit of the vector processor of Fig. 2.

Fig. 5 A, 5B and 5C show the register of vector processor of Fig. 2 to the step of the used execution pipeline of register instruction, load instructions and storage instruction.

Fig. 6 A is the block diagram of execution data path of the vector processor of Fig. 2.

Fig. 6 B is the block diagram of the register file (register file) of Fig. 6 A execution data path.

Fig. 6 C is the block diagram of the parallel processing logic unit of Fig. 6 A execution data path.

Fig. 7 is the block diagram of load/store unit of the vector processor of Fig. 2.

Fig. 8 is the form of the vector processor instruction set of one embodiment of the invention.

Used same reference numeral represents similar or identical item in different figure.

Fig. 1 shows the block diagram of embodiment of the multi-media signal processor (MSP) 100 of one embodiment of the invention. Multimedia processor 100 comprises the processing core 105 that general processor 110 and vector processor 120 form. Process core 105 and link the remainder of multimedia processor 100 by cache memory (hereinafter referred to as high-speed cache) subsystem 130, high-speed buffer subsystem comprises SRAM 160 and 190, ROM 170 and director cache 180. Director cache 180 can be configured to SRAM 160 instruction cache 162 and the data cache 164 of processor 110, and SRAM 190 is configured to instruction cache 192 and the data cache 194 of vector processor 120.

ROM 170 comprises data and the instruction of processor 110 and 120 in the sheet, and can be configured to high-speed cache. In the present embodiment, ROM 170 comprises: reset and initialization procedure; The self-test diagnostic procedure; Interrupt and exception handler; And sound blaster emulation subroutine; V.34 modem signal is processed subroutine; The regular phone function; 2-D and 3-D figure subroutine library; And be used for Voice ﹠ Video standard such as MPEG-1, MPEG-2, H.261, H.263, G.728 and subroutine library G.723.

High-speed buffer subsystem 130 is connected to two system bus 140 and 150 to processor 110 and 120, and as processor 110 and 120 and be coupled to high-speed cache and the switching station (switching station) of the equipment of bus 140 and 150. The clock frequency work that system bus 150 usefulness are higher than bus 140, and being connected to Memory Controller 158, local bus interface 156, dma controller 154 and equipment interface 152, local bus, direct memory access (DMA) and various modulus, digital to analog converter that they are respectively external partial memory, master computer provide interface. System timer 142, UART (Universal asynchronous receiver transceiver, universal asynchronous receiver transmit) 144, bit stream processor 146 and interrupt control unit 148 are connected to bus 140. The patent application of above-mentioned being entitled as " Multiprocessor Operation in a Multimedia Signal Processor " and " Methods and apparatus for Processing Video Data " has more fully illustrated the work of high-speed buffer subsystem 130 and exemplary equipment, and processor 110 and 120 is by high level cache subsystem 130 and bus 140 and the described equipment of 150 access.

Processor 110 and 120 is carried out independently program threads, and structurally also is different, in order to more effectively carry out the particular task of giving them. Processor 110 is mainly used in controlling function, for example the function that computes repeatedly in a large number of the execution of real time operating system and similarly not needing. Therefore, processor 110 does not need strong computing capability, can realize with traditional general processor structure. This repetitive operation that comprises data block common in the multimedia processing of vector processor 120 main realization mathematical computations (number crunching). For strong computing capability and relative simply programming are arranged, vector processor 120 has SIMD (Single instruction multiple data, single-instruction multiple-data) structure; In the present embodiment, most of data path is 288 or 576 bit wides in vector processor 120, with the support vector data manipulation. In addition, the instruction set of vector processor 120 comprises the instruction that is particularly useful for the multimedia problem.

In the present embodiment, processor 110 is 32 risc processors, is operated on the 40MHz, meets the structure of ARM 7 processors, and described ARM 7 processors include the register set of ARM 7 standard definitions. About the structure of ARM 7 risc processors and instruction set at " ARM7DM Data Sheet (ARM7DM product description) " Document Number (document number): be described among the ARM DDI 0010G, this can obtain from Advance RISC Machines Ltd. company. ARM7DM Data Sheet all is included in here as a reference. Appendix A has illustrated the expansion of the ARM7 instruction set of present embodiment.

Vector processor 120 not only operates vector but also operate scalar. In the present embodiment, vector data processor 120 comprises the pipeline system RISC engine (engine) with 80MHz work. The register of vector processor 120 comprises 32 scalar registers, 32 special registers, two group of 288 bit vector register and the vectorial accumulator registers of two groups of Double Lengths (namely 576). Appendix C has illustrated the register set of the vector processor 120 of present embodiment. In the present embodiment, processor 120 comprises 32 scalar registers, and 5 bit registers of these scalar registers by scope from 0 to 31 are number identified instruction. Also have 64 288 vector registor, these registers form two groups, and every group has 32 vector registors. Each vector registor can No. 31 identify with the vector registor of 1 group number (0 or 1) and 5 scopes from 0 to. The vector registor in current group is only accessed in most of instruction, as it is represented to be stored in the default group position CBANK of control register VCSR of vector processor 120. The 2nd control bit VEC64 represents the Double Length the vector registor whether default expression of register number is comprised of a register from each group. The register number of the register number of the syntax distinctive mark vector registor of instruction and sign scalar register.

Each vector registor can be divided into the programmable a plurality of data elements of length, and table 1 shows the data type of the data element of supporting in 288 bit vector registers. Table 1:

Data type	Data length	Explain
			int8	8 (byte)	82 complement code between-128 and 127
int9	9 (byte 9)	92 complement code between-256 and 255
			int16	16 (half-word)	16 2 complement code between-32,768 and 32,767
int32	32 (word)	32 2 complement code between-2147483648 and 2147483647.
			float	32 (word)	32 IEEE 754 single-precision format

Appendix D further provides the data length supported in the embodiments of the invention and the explanation of type.

To the int9 data type, 9 bit bytes are combined in the 288 bit vector registers continuously, and to other data type, each the 9th is not used in 288 bit vector registers. 288 bit vector registers can be put 32 8 or 9 integer data elements, 16 16 integer data elements or 8 32 integers or floating-point element. In addition, 2 vector registors can be combined with Double Length vector assembling data element. In an embodiment of the present invention, the control bit VEC64 set with among control and the status register VCSR places mode VEC64 to vector processor 120, and Double Length (576) is the default length of vector registor here.

Multimedia processor 100 also comprises 32 extended registers 115 that a cover processor 110 and 120 can be accessed. Appendix B has illustrated extended register collection and their function in the embodiments of the invention. The scalar sum special register of extended register and vector processor 120 in some cases can be for processor 110 access. 2 special uses " user " extended register has 2 read ports, allows simultaneously read register of processor 110 and 120. Other extended register can not be simultaneously accessed.

Vector processor 120 has two the state VP_RUN and the VP_IDLE that replace, and indication vector processor 120 is in work or is in idle condition. When vector processor 120 was in state VP _ IDLE, processor 110 can read or write the scalar sum special register of vector processor 120. But the result that processor 110 read or write a register of vector processor 120 when vector processor 120 was in state VP_RUN does not give definition.

Expansion to the ARM7 instruction set of processor 110 comprises access extended register and the scalar of vector processor 120 or the instruction of special register. Command M FER and MFEP move on to the scalar of extended register and vector processor 120 or the data in the special register in the general register in the processor 110 respectively, and command M TER and MTEP move on to the data of general register in the processor 110 in the scalar or special register of extended register and vector processor 120 respectively. The TESTSET instruction is read extended register and the position 30 of extended register is set to 1. Signal instruction processor 110 occurs to processor 120 and has read the result that (or use) produces by with position 30 set in instruction TESTSET, has made things convenient for user/producer synchronous. The duty of other instruction of processor 110 such as STARTVP and INTVP dominant vector processor 120.

The work of 110 primary processors of processor is in order to the operation of dominant vector processor 120. Simplify processor 110 and 120 with the asymmetric division of control between processor 110 and 120 and carried out synchronous problem. When vector processor 120 was in the VP_IDLE state, processor 110 came initialization vector processor 120 by IA is write in the program counter of vector processor 120. Then, processor 110 is carried out the STARTVP instruction, and vector processor 120 is changed over state VP_RUN. Under state VP_RUN, vector processor 120 is by high-speed buffer subsystem 130 fetchings, and the processor 110 of its program of continuation execution is carried out those instructions concurrently together. After startup, vector processor 120 continues to carry out, until run into unusual, the VCJOIN that carries out to satisfy felicity condition or VCINT instruction or interrupted by processor 110. Vector processor 120 can be sent to processor 110 with the result of program execution by the result being write extended register, the result is write the address spaces that processor 110 and 120 shares or when vector processor 120 reenters state VP_IDLE the result being stayed in the scalar or special register of processor 110 access.

Vector processor 120 is not processed the unusual of it. When execution causes unusual instruction, vector processor 120 VP_IDLE that gets the hang of, and send an interrupt requests to processor 110 by direct-through line. Vector processor 120 remains on state VP_IDLE, until processor 110 is carried out another STARTVP instruction. The register VISRC that processor 110 is responsible for read vector processor 120 may process unusually by reinitializing vector processor 120 to determine unusual character, and then, boot vector processor 120 recovers to carry out as required.

INTVP instruction interrupt vector processor 120 by processor 110 is carried out makes vector processor 120 enter idle condition VP_IDLE. Instruction INTVP can for example be used in the multitask system, and vector processor is switched to another task such as sound card emulation from task such as the video coding of carrying out.

Vector processor instruction VCINT and VCJOIN are flow control instructions, if the condition of instruction indication satisfies, these instructions make vector processor 120 place state VP_IDLE the execution of stop vector processor 120, and to 110 interrupt requests of processor, unless this request conductively-closed. The program counter of vector processor 120 (special register VPC) is pointed out the IA after VCINT or the VCJOIN instruction. Processor 110 can check the interrupt source register VISRC of vector processor 120, determines whether it is that VCINT or VCJOIN instruction cause interrupt requests. Because vector processor 120 has the mass data bus, and more effective on its register of Save and restore, so should the Save and restore register during the software of carrying out by vector processor 120 switches (context switching) at the scene. The patent application of above-mentioned being entitled as " Efficient Context Saving and Restoring in Multiprocessors " has illustrated an exemplary system of Context switches.

Fig. 2 shows the main functional diagram of the embodiment of vector processor 120. Vector processor 120 comprises 210, the decoders 220 in a fetching unit (IFU), scheduler 230, execution data path 240 and a load/store unit (LSU) 250. IFU 210 fetchings are also processed flow control instructions (such as branch). Command decoder 220 is according to the order that arrives from IFU 210, and per cycle is deciphered an instruction, and a field value of deciphering out from instruction is write the FIFO in the scheduler 230. Scheduler 230 selects to send to the field value of carrying out control register according to the needs of executable operations step. Send to select to depend on operand dependence (dependency) and processing resource such as execution data path 240 or pack into/availability of memory cell 250. Logic/the arithmetic instruction of execution data path 240 executable operations vectors or scalar data. Pack into/memory cell 250 carries out the instruction of packing into/store of the address space of access vector processors 120.

Fig. 3 shows the block diagram of the embodiment of IFU210. IFU comprises an instruction buffer, and this buffer is divided into main instruction buffer 310 and ancillary instruction buffer 312. Main buffer 310 comprises 8 continual commands, comprising the instruction corresponding to the present procedure counting. Comprise 8 instructions of the instruction in the buffer 310 and then in the secondary buffer 312. IFU 210 also comprises a branch target buffer 314, and it comprises 8 continual commands, comprising the target of next flow control instructions in buffer 310 or 312. In the present embodiment, vector processor 120 uses the risc type instruction set, wherein every instruction be 32 long, buffer 310,312 or 314 is 8 * 32 digit buffers, and links high-speed buffer subsystem 130 by 256 bit instruction buses. IFU 210 can be within a clock cycle, and 8 instructions in the high-speed buffer subsystem 130 are loaded in the buffer 310,312 or 314 any one. Register 340,342 and 344 is indicated respectively the base address of load in the buffer 310,312 and 314.

MUX 332 is selected current instruction from main instruction buffer 310. If present instruction is not flow control instructions, and be stored in the decoding stage that instruction in the command register 330 proceeds to execution, then command register 330 is deposited in present instruction, is incremented to programmed counting. Behind the programmed counting increment, select the last item instruction in the buffer 310, then 8 instructions of next group are loaded onto buffer 310. If buffer 312 comprises desired 8 instructions, then the content of buffer 312 and register 342 moves on to buffer 310 and register 340 immediately, has again 8 instructions to deliver to secondary buffer 312 from cache systems 130 pre-fetchings. Adder 350 is determined the address of next group instruction according to the base address in the register 342 and the side-play amount selected by MUX 352. The result address that is obtained by adder 350 is stored in the register 342, when this moves on to register 340 in this address from register 342 or carry out later on. The address that calculates is also delivered in the high-speed buffer subsystem 130 in company with the request of 8 instructions. If called cache control system 130 last time, when buffer 310 request, also not 8 instructions below buffer 312 provides, then the instruction of request last time when receiving from high-speed buffer subsystem 130, is stored in the buffer 310 immediately.

If present instruction is flow control instructions, IFU 210 by convection control instruction condition calculating and after flow control instructions refresh routine count to process this instruction. If because the instruction that the front may change condition do not finish, and condition pauses IFU 210 when can not determine. If branch does not occur, program counter is incremented, and following instruction is selected as mentioned above. If the target that branch and branch target buffer 314 comprise this branch occurs, then the content of buffer 314 and register 344 is moved to buffer 310 and register 340, instruction is provided and need wait for from the instruction in the high-speed buffer subsystem 130 so that IFU 210 can continue as decoder 220.

In order to be branch target buffer 314 prefetched instructions, scanner 320 scanning buffer devices 310 and 312 are to locate the and then next flow control instructions of present procedure counting. If find flow control instructions in buffer 310 or 312, scanner 320 is determined to comprise the side-play amount of 8 instructions of flow control instructions destination address to one group of (aligned) that aims at from the buffer 310 that comprises this instruction or 312 base address. MUX 352 and 354 provides the side-play amount of flow control instructions and from the base address of register 340 or 342, is that buffer 314 produces new base address by adder 350 for adder 350. New base address is transferred to high-speed buffer subsystem 130, moreover it provides 8 instructions for branch target buffer 314.

Processing flow control instructions such as " decrement and conditional jump " instruction VD1CBR, VD2CBR and VD3CBR, when reaching " change control register " instruction VCHGCR, IFU 210 can change the value of the register except programmed counting. When IFU 210 found the instruction of a non-flow control instructions, command register 330 was delivered in this instruction, and from there to decoder 220.

As shown in Figure 4, each field of the fifo buffer 410 of decoder 220 by controlling value being write scheduler 230 is deciphered an instruction. Fifo buffer 410 comprises 4 line triggers, and wherein every delegation can comprise 5 information fields, in order to control the execution of an instruction. Row 0 to 3 keeps arriving the earliest respectively the information of up-to-date instruction, when information is early finished along with instruction and when being removed, the information in fifo buffer 410 moves down into lower row. Scheduler 230 sends an instruction to the execution phase by selecting essential instruction field to be loaded into to comprise the control pipeline 420 of carrying out register 421 to 427. Most of instruction can be scheduled, in order to do not send in order and carry out. Especially the order about logic/arithmetical operation and load/store operations is arbitrarily, unless the operand dependence is arranged between load/store operations and logic/arithmetical operation. Field value relatively indicates whether have operation dependency to exist in the fifo buffer 410.

Fig. 5 A illustrates 6 stage execution pipelines of an instruction, and this instruction has realized the operation of register to register, and need not access the address space of vector processor 120. In the instruction fetching stage 511, as mentioned above fetching one instruction of IFU 210. The fetching stage needs 1 clock cycle, unless because pipelining delay, unsolved branch condition or the delay in the high-speed buffer subsystem 130 that prefetched instruction is provided pause IFU 210. In the decoding stage 512, decoder 220 decoding is from the instruction of IFU 210, and the information of this instruction is write scheduler 230. The decoding stage 512 also needs a clock cycle, unless to new operation, among the FIFO 410 without available row. During the period 1 of FIFO 410, can send and operate control pipeline 420, but can be delayed owing to sending of operation early.

Executing data passage 240 is realized registers to the operation of register, and provides data and address for load/store operations. Fig. 6 A shows the block diagram of execution data path 240 1 embodiment, and is illustrated together with the execution phase 514,515 and 516. Carrying out register 421 provides the signal of two registers in the marker register file 610, and register file 610 was read in the clock cycle during read phase 514. Register file 610 comprises 32 scalar registers and 64 vector registors. Fig. 6 B is the block diagram of register file 610. Register file 610 has 2 read ports and 2 write ports, in order to provide 2 to read to write with 2 in each clock cycle. Each port comprises selects circuit 612,614,616 or 618 and 288 data/address bus 613,615,617 or 619. Selecting circuit is to know such as circuit 612,614,616 and 618 in the art, and use address signal WRADDR1, WRADDR2, RDADDR1 or RDADDR2, this be decoder 220 from generally be 5 bit registers that in instruction, provide number, group position from instruction or state of a control register VCSR, and indicator register be to obtain vector registor or the syntax of instructions of scalar register. The path that data are read can be to load/store unit 250, perhaps by MUX 622 and 624, by multiplier 620 ALUs 630, accumulator 640 by MUX 656. 2 registers are read in most of operation, and read phase 514 is finished in one-period. Yet, some instruction, as take advantage of and the instruction that adds instruction VMAD and operation Double Length vector need to more than the data of 2 registers, cause read phase 514 to need to surpass a clock cycle.

In the execution phase 515, multiplier 620, ALU 630 and accumulator 640 are processed the data that read from register file 610 front. If in order to read necessary a plurality of cycles of data demand, the execution phase 515 can be overlapping with read phase 514. The duration of execution phase 515 is depended on type (integer or floating type) and the quantity (read cycle data) of deal with data element. From carry out register 422,423 and 425 signal controlling data inserting to ALU 630, accumulator 640 and multiplier 620 in order to realize that in the execution phase first step operates. From carry out register 432,433 and 435 signal controlling realizes the second step operation in the execution phases 515.

Fig. 6 C shows the block diagram of multiplier 620 and ALU 630 1 embodiment. Multiplier 620 is integer multiplier, and it comprises 8 independently 36 * 36 multipliers 626. Each multiplier 626 comprises 49 * 9 multipliers that link together by control circuit. To 8 and 9 bit data elements width, disconnect the mutual binding of 49 * 9 multipliers from the control signal of scheduler 230, so that each multiplier 626 is realized 4 multiplication, multiplier 620 is realized 32 independently multiplication in one-period. To 16 bit data elements, control circuit 9 * 9 multipliers to the operation that links together. Multiplier 620 is realized 16 parallel multiplications. To 32 integer data element types, 8 626 each clock cycle of multiplier are realized 8 parallel multiplications. The result of multiplication provides 576 results to 9 bit data elements width, provides 512 results to other data length.

ALU 630 can process 576 or 512 results from multiplier 620 in 2 clock cycle. ALU 630 comprises 8 independently 36 ALUs 636, and each ALU 636 comprises for floating addition and 32 * 32 floating point units taking advantage of. Adjunct circuit is realized integer displacement, arithmetic sum logic function. For integer operation, each ALU 636 comprises 4 unit that can independently carry out 8 and 9 bit manipulations, and to 16 and 32 integer data elements, per 2 or 4 can form one group and connect together.

Accumulator 640 accumulation results, and comprise 2 576 bit registers, in order to realize the degree of precision of intermediate object program.

At write phase 516, from the result store of execution phase in register file 610. Within a clock cycle, can write 2 registers, 2 data values that input MUX 602 and 605 selections will be write. The duration of the write phase 516 of once-through operation depends on the data volume that will be write as operating result and from the competition of LSU 250, LSU 250 may be by writing to finish the loading instruction to register file 610. Select register that the data from logical block 630, accumulator 640 and multiplier 620 are write from the signal of carrying out register 426 and 427.

Fig. 5 B illustrates and carries out the execution pipeline 520 that loads instruction. Identical for instruction fetching stage 511, decoding stage 512 and the stage of sending 513 of execution pipeline 520 and illustrated register to the operation of register. Read phase 514 is also identical with top explanation, just execution data path 240 usefulness from the data of register file 610 to determine the address of calls cache subsystem 130. At address phase 525, MUX 652,654 and 656 is selected the address, and this address is provided for the load/store unit 250 of execution phase 526 and 527. When load/store unit 250 was processed operation, during stage 526 and 527, the Information preservation of load operation was in FIFO 410.

Fig. 7 shows an embodiment of load/store unit 250. Calls cache subsystem 130 during the stage 256 is with the data of request stage 525 determined addresses. Present embodiment uses (transaction based) high-speed cache based on affairs to call, and can pass through high-speed buffer subsystem 130 access local address spaces comprising a plurality of equipment of processor 110 and 120. In several cycles after calls cache subsystem 130, requested data may can not get, but when other called hang-up, load/store unit 250 can the calls cache subsystems. Therefore, load/store unit 250 unlikely pauses. High-speed buffer subsystem 130 provides the required clock periodicity of requested data to depend on hitting of data cache 194 or miss (hit or miss).

In the driving stage 527, high-speed buffer subsystem 130 is that load/store unit 250 is confirmed (assert) data-signal. High-speed buffer subsystem 130 can provide the data of 256 (32 bytes) to load/store unit 250 in each cycle, and byte alignment device 710 is aimed at each byte of 32 bytes in corresponding 9 memory locations, so that 288 value to be provided. 288 form is easily to the multimedia application of for example mpeg encoded and decoding, and they use 9 bit data elements sometimes. 288 place values write read data 720. To write phase 528, scheduler 230 is sent to the field 4 of fifo buffer 410 and carries out register 426 or 427, and 288 value of data buffer 720 is write register file 610.

Fig. 5 C shows and carries out the used execution pipeline 530 of storage instruction. The fetching stage 511 of execution pipeline 530, decoding stage 512 and the stage of sending 513 are identical with what illustrate previously. Read phase 514 is also identical with what illustrate previously, and just read phase is read data and the used data of address computation that will store. Want stored data to be written into write data buffer 730 in the load/store unit 250. MUX 740 becomes the data transaction of 9 bit byte forms the form of traditional octet. From the data of the conversion of buffer 730 with from the relative address in address computation stage 525, during the SRAM stage 536, delivered to concurrently high-speed buffer subsystem 130.

In the embodiment of vector processor, each instruction be 32 long and have a kind of form in 9 kinds of forms shown in Fig. 8, and be labeled as REAR, REAI, RRRM5, RRRR, RI, CT, RRRM9, RRRM9^*, and RRRM9^** Appendix E has illustrated the instruction set of vector processor 120.

When determining an effective address, use some loading, storage and the cache operations of scalar register to have the REAR form. The REAR format order is that 000b identifies and 3 operands arranged by 3 register number sign with a position 29-31, and 2 register number SRb and SRi are scalar register, and register number Rn can be scalar or vector registor, and this depends on a D. Group position B or for register Rn identifies a group, if indicate whether when perhaps the default vector register size is Double Length that vector registor Rn is Double Length. The operation that opcode field Opc sign is carried out operand, and field TT indication transmission type is for loading or storage. Typical REAR format order is instruction VL, and it comes bit load registers Rn from scalar register SRb and the definite address of SRi content addition. If position A is set, the address of calculating is stored among the scalar register SRb.

The REAI format order is identical with the REAR instruction, just is used to replace the content of scalar register SRi from 8 immediate values of field IMM. REAR and REAI form are countless according to the length of element field.

The RRRM5 form is used for having the instruction of 2 source operands and a destination operand. These instructions have 3 register manipulation numbers or 2 register manipulation numbers and 15 immediate value. Coding at field D, the S shown in the appendix E and M determines whether that first source operand Ra is scalar or vector registor; Whether the 2nd source operand Rb/IM5 is scalar register, vector registor or 5 immediate values; And whether destination register Rd is scalar or vector registor.

The RRRR form is used for having the instruction of 4 register manipulation numbers. Register number Ra and Rb indication source register. Register number Rd indicates destination register, and register number Rc indication source or destination register, this depends on field Opc. The all operations were number is vector registor, is scalar register unless position S is set indicator register Rb. The data element length of field DS indication vector registor. Field Opc selects the data type of 32 bit data elements.

The RI format order loads an immediate value to register. Field IMM comprises can reach 18 immediate value. Register number Rd indicates destination register, and this destination register is vector registor or the scalar register in current group, and this depends on a D. Field DS and F be length and the type of designation data element respectively. To 32 integer data elements, 18 immediate values are being loaded into register Rd with the previous crops sign extended. To the floating data element, position 18, position 17 to 10 and position 9 to 0 represent respectively symbol, the exponential sum mantissa of 32 floating point values.

The CT form is used for flow control instructions, and it comprises opcode field Opc, condition field Cond and 23 s' immediate value IMM. When the condition field indicated condition is true time, branch then occurs. Possible condition code is " always (unconditionally) ", " Less than (less than) ", " equal (equaling) ", " Less than or equal (being less than or equal to) ", " greater than (greater than) ", " not equal (being not equal to) ", " greater than or equal (more than or equal to) " and " overflow (overflowing) ". Position GT, EQ, LT and SO among state and the control register VCSR are used for appreciation condition.

Form RRRM9 provides 3 register manipulation numbers or 2 register manipulation numbers and 19 immediate value. Which operand the combination of position D, S and M indicates is vector registor, scalar register or 9 immediate values. Field DS designation data length of element. RRRM9^*And RRRM9^**Form is the special circumstances of RRRM9 form, and distinguishes with opcode field Opc. RRRM9^*Form condition code Cond and id field alternate source register number Ra. RRRM9^**Form replaces each highest significant position of immediate value with condition code Cond and position K. RRRM9^*And RRRM9^**Further specify in appendix E and provide, relate to conditional branch instruction VCMOV, element shielding conditional jump CMOVM and comparison and masking instruction CMPV be set.

Although in conjunction with specific embodiments the present invention has been made explanation, but these explanations only are the examples that the present invention uses, should be as being not a kind of restriction, the various modifications of the disclosed embodiments characteristics and combination still belong to the scope of the present invention that following claim defines in addition.

Appendix A

In an exemplary embodiment, processor 110 is the general processors according to ARM7 processor standard. In ARM7 to the description references ARM structured file of register or ARM7 tables of data (document number ARM DDI0020C, in December, 1994 distribution).

In order to cooperatively interact 110 processors with vector processor 120: starting and stop vector processor; The test vector processor state comprises synchronous regime; Scalar/special register from vector processor 120 passes to data in the general register of processor 110; And the scalar/special register that the data in the general register is passed to vector processor. Between the vector registor of general register and vector processor, there is not direct conveyer, these transmission need memory as mediator.

Table A .1 has illustrated the ARM7 instruction set of expanding for the reciprocation of vector processor. Table A .1: the ARM7 instruction set of expansion

Instruction	The result
		STARTVP	This instruction makes vector processor enter the VP-RUN state, if vector processor has entered the VP-RUN state then without impact. STARTVP carries out as processor data operation (CDP) class in the ARM7 structure, turns back to ARM7 without the result, and ARM7 continues its execution.
INTVP	This instruction makes vector processor enter the VP-IDEL state, if vector processor has entered the VP-IDEL state then without impact. INTVP carries out as processor data operation (CDP) class in the ARM7 structure, turns back to ARM7 without the result, and ARM7 continues its execution.
		TESTSET	User's extended register is read in this instruction, and register-bit 30 is set to 1 so that between vector sum ARM7 processor, provide the producer/consumer type synchronously. In the ARM7 structure, TESTSET carries out as processor register transfer (MRC) class. ARM7 gets clogged, until instruction is performed (register is transmitted).
MFER	Transfer to the ARM general register from extended register, in the ARM7 structure, MFER carries out as processor register transfer (MRC) class. ARM7 gets clogged, until instruction is performed (register is transmitted).

Instruction	The result
		MFVP	Transfer to the ARM7 general register from the scalar/special register of vector processor. Be different from other ARM7 instruction, this instruction is only carried out when vector processor is in VP-IDLE state. Otherwise its result is undefined. In the ARM7 structure, MFVP carries out as processor register transfer (MRC) class. ARM7 gets clogged, until instruction is performed (register is transmitted).
MTER	Transfer to extended register from the ARM7 general register, in the ARM7 structure, MTER transmits (MCR) class as coprocessor register and carries out. ARM7 gets clogged, until this instruction is performed (register is transmitted).
		MTVP	Transfer to the scalar/special register of vector processor from the ARM7 general register, be different from other ARM7 instruction, this instruction is only carried out when vector processor is in VP-IDLE state. Otherwise its result is undefined. In the ARM7 structure, MTVP transmits (MCR) class as coprocessor register and does not carry out. ARM7 gets clogged, until this instruction is performed (register is transmitted).
CACHE	The software administration of ARM7 data cache is provided
		PFTCH	The cache line of looking ahead is delivered to the ARM7 data cache.
WBACK	The cache line that the ARM7 data cache is come is written back in the memory.

Table A .2 has listed the unusual of ARM7, before carrying out the fault instruction, detects and reports that these are unusual. The exception vector address provides with sexadecimal notation. Table A .2:ARM7 is unusual

Exception vector	Explanation
		0x00000000	ARM7 resets
0x00000004	The ARM7 undefined instruction is unusual
		0x00000004	Vector processor is unavailable unusual
0x00000008	The ARM7 software interrupt
		0x0000000C	The ARM7 single step is unusual
0x0000000C	ARM7 IA breakpoint is unusual
		0x00000010	ARM7 data address breakpoint is unusual
0x00000010	ARM7 invalid data address is unusual
		0x00000018	The ARM7 protection is violating the regulations unusual

The following describes the syntax that the ARM7 instruction set is expanded. About the form of the explanation of term and instruction with reference to ARM structured file or ARM7 tables of data (document number ARM DDI 0020C, deliver in December, 1994).

The ARM structure provides 3 kinds of instruction formats for coprocessor interface:

1. coprocessor data manipulation (CDP)

2. the coprocessor data transmit (LDC, STC)

3. coprocessor register transmits (MRC, MCR)

Whole two kinds of forms are used in the expansion of MSP structure.

The coprocessor data manipulation form (CDP) that uses for operation need not return to ARM7. The CDP form

CDP format fields and following agreement is arranged:

Field	Meaning
		Cond	Condition field, this field designated order executive condition
Opc	The co processor operation code
		CRn	The co processor operation number register
CRd	The coprocessor destination register
		CP#	Coprocessor number; Below coprocessor number be current use: 1111-ARM7 data cache 0111-vector processor, the register of expansion
CP	Coprocessor information
		CPm	The co processor operation number register

Coprocessor data transfer format (LDC, STC) is used for directly loading or the register subset of storage vector processor arrives memory. The ARM7 processor is responsible for providing word address, and vector processor provides or receive data, and the number of words of control transmission. More detailed content is with reference to the ARM7 tables of data. LDC, the STC formFormat fields has following agreement:

Field	Meaning
		Cond	Condition field, this field designated order executive condition
P	The Pre/Post flag bit
		U	The Up/Down position
N	Transmit length, because the CRd field does not have enough figure places, position N uses as a part of source or destination register identifier.
		W	The write-back position
L	Load/the storage position
		Rn	Base register
CRn	Coprocessor source/destination register
		CP #	Coprocessor number, following coprocessor number are current uses: 1111-ARM7 data cache 0111-vector processor, the register of expansion
Offset	Without 8 of symbols side-play amount immediately

Coprocessor register transformat (MRC, MCR) is used for directly transmission information between ARM7 and vector processor. This form is used in the scalar of ARM7 register and vector processor or the transfer between the special register. MRC, the MCR form

This format fields has following agreement:

Field	Meaning
		Cond	Condition field, the condition that this field designated order is carried out
Opc	The co processor operation code
		L	Loading/storage position L=0 moves on to vector processor L=1 and moves from vector processor
CRn：Crm	Coprocessor source/destination register. CRn＜1:0 only 〉: CRm＜3:0〉be used
		Rd	ARM source/destination register
CP #	Coprocessor number, following coprocessor number are current uses: 1111=ARM7 data cache 0111=vector processor, the register of expansion
		CP	Coprocessor information

The ARM instruction of expansion

The ARM instruction alphabet sequence of expansion is explained. CACHE cache operations form

The assembler syntax

STC{cond}p15，cOpc，<Address>

CACHE{cond}Opc，<Address>

Cond={eq wherein, he, cs, cc, mi, pl, vs, vc, hi, Is, ge, It, gt, le, ai, nv} and Opc={0,1,3}. Note, because the CRn field of LDC/STC form is used to specify Opc. The decimal representation of Opcode must be by letter " C " take the lead (namely representing 0 with CO) in the first syntax. About the address mode syntax with reference to the ARM7 tables of data. Illustrate to be true time at Cond only, carry out this instruction. Opc＜3:0〉indicate following operation:

Opc<3：0>	Meaning
		0000	Write-back and calcellation are by the cache line of the change of EA appointment. If the row of coupling comprises the data of not changing, this row is cancelled, and refuses write-back. If can't find the cache line that comprises EA, data cache keeps remaining untouched.
0001	Write-back and calcellation are by the cache line of the change of EA traction appointment. If matching row comprises the data of not changing, this row is cancelled refuses write-back.
		0010	Be used for PFTCH and WBACK instruction
0011	Calcellation is by the cache line of EA appointment. Even this row was changed, this cache line is also by cancel (not write-back). This is a kind of privileged operation, if attempt to use under user mode, it will cause that the ARM7 protection is violating the regulations
		Other	Keep

Operation

With reference to the ARM7 tables of data, how EA calculates. Unusually

The ARM7 protection is violating the regulations. INTVP interrupt vector processor form

The assembler syntax

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

INTVP{cond}

Cond={eq wherein, ne, cs, cc, mi, pl, vs, vc, hi, Is, ge, It, gt, le, al, ns}. Explanation

This instruction is that true time is carried out at Cond only. This instruction is signaled vector processor is stopped. ARM7 needn't wait for that vector processor stops, and continues to carry out next instruction.

Should use MFER busy waiting circulation and whether after this instruction is carried out, stop in order to looking at vector processor. If vector processor is at the VP_IDLE state, then this instruction is inoperative. Position 19:12,7:15 and 3:0 are retained. Unusually

Vector processor is unavailable. MFER is from the extended register braning formatThe assembler syntax

MRC{cond}p7，2，Rd，cP，cER，0

MFER{cond}Rd，RNAME

Cond={eg wherein, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd=r0 ... and r15}, P={0,1}, ER={0 ... .15} and RNAME refers to the register memonic symbol (that is, PERO or CSR) of appointment on the structure. Explanation

This instruction is that true time is carried out at Cond only. ARM7 register Rd is according to P:ER＜3:0〉the extended register ER of appointment shifts, and is as shown in the table. Explanation with reference to chapters and sections 1.2 extended registers.

ER<3：0>	P＝0	P＝1
			0000	UER0	PER0
0001	UER1	PER1
			0010	UER2	PER2
0011	UER3	PER3
			0100	UER4	PER4
0101	UER5	PER5
			0110	UER6	PER6
0111	UER7	PER7
			1000	UER8	PER8
1001	UER9	PER9

ER<3：0>	P＝0	P＝1
			1010	UER10	PER10
1011	UER11	PER11
			1100	UER12	PER12
1101	UER13	PER13
			1110	UER14	PER14
1111	UER15	PER15

Position 19:17 and 7:5 are retained unusually

When attempting to access PERx in user mode, protection is violating the regulations. MFVP is from the vector processor braning format

The assembler syntax

MRC{cond}p7，1，Rd，Crn，CRm，0

MFVP{cond}Rd，RNAME

Cond={eq wherein, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd=and r0 ... r15}, CRn={c0 ... .c15}, CRm={c0 ... .c15} and RNAME refers to register memonic symbol (that is, SPO or the VCS) explanation of appointment on the structure

This instruction is that true time is carried out at Cond only. ARM7 register Rd is according to the scalar of vector processor/special register CRn＜1:0 〉: CRm＜3:0〉shift. Distribution with reference to register transfer vector processor register number among the chapters and sections 3.2.3.

Position 7.5 and CRn＜3:2〉be retained.

Below the vector processor register mappings is presented at. The table 15 of reference vector processor special register (SP0-SP15).

CRM<3：0>	CRn<1：0>＝00	CRn<1：0>＝01	CRn<1：0>＝10	CRn<1：0>＝111
					0000	SR0	SR16	SP0	RASR0
0001	SR1	SR17	SP0	RASR1
					0010	SR2	SR18	SP0	RASR2
0011	SR3	SR19	SP0	RASR3
					0100	SR4	SR20	SP0	RASR4
0101	SR5	SR21	SP0	RASR5
					0110	SR6	SR22	SP0	RASR6
0111	SR7	SR23	SP0	RASR7
					1000	SR8	SR24	SP0	RASR8
1001	SR9	SR25	SP0	RASR9
					1010	SR10	SR26	SP0	RASR10
1011	SR11	SR27	SP0	RASR11
					1100	SR12	SR28	SP0	RASR12
1101	SR13	SR29	SP0	RASR13
					1110	SR14	SR30	SP0	RASR14
1111	SR15	SR31	SP0	RASR15

SR0 often reads 32 zero, and ignores writing it. Unusually

Vector processor is unavailable. MTER transfers to the extended register form

The assembler syntax

MRC{cond}p7，2，Rd，cP，cER，0

MFVP{cond}Rd，RNAME

Here Cond={eq, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd=r0 ... and r15}, P={0,1}, ER={0 ... .15}. RNAME refers to the register memonic symbol (that is, PERO or CSR) of appointment on the structure. Explanation

This instruction is that true time is carried out in condition only. ARM7 register Rd is according to P:ER＜3:0〉the extended register ER of appointment shifts. As shown in the table

ER<3：0>	P＝0	P＝1
			0000	UER0	PER0
0001	UER1	PER1
			0010	UER2	PER2
0011	UER3	PER3
			0100	UER4	PER4
0101	UER5	PER5
			0110	UER6	PER6
0111	UER7	PER7
			1000	UER8	PER8
1001	UER9	PER9
			1010	UER10	PER10
1011	UER11	PER11
			1100	UER12	PER12
1101	UER13	PER13
			1110	UER14	PER14
1111	UER15	PER15

Position 19:17 and 7:5 are for subsequent use unusual

Attempt is when user mode access PERx, and protection is violating the regulations. MTVP transfers to the vector processor form

The assembler syntax

MRC{cond}p7，1，Rd，Crn，CRm，0

MFVP{cond}Rd，RNAME

Here Cond={eq, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd=r0 ... and r15}, CRn={c0 ... .c15}, CRm={c0 ... .c15}. RNAME refers to the register memonic symbol (that is, SPO or VCS) of appointment on the structure. Explanation

This instruction is that true time is carried out at Cond only. ARM7 register Rd is according to the scalar of vector processor/special register CRn＜1:0 〉: CRm＜3:0〉shift.

Position 7:5 and CRn＜3:2〉keep.

The vector processor register mappings is as follows

CRM<3：0>	CRn<1：0>＝00	CRn<1：0>＝01	CRn<1：0>＝10	CRn<1：0>＝111
					0000	SR0	SR16	SP0	RASR0
0001	SR1	SR17	SP0	RASR1
					0010	SR2	SR18	SP0	RASR2
0011	SR3	SR19	SP0	RASR3
					0100	SR4	SR20	SP0	RASR4
0101	SR5	SR21	SP0	RASR5
					0110	SR6	SR22	SP0	RASR6
0111	SR7	SR23	SP0	RASR7
					1000	SR8	SR24	SP0	RASR8
1001	SR9	SR25	SP0	RASR9
					1010	SR10	SR26	SP0	RASR10
1011	SR11	SR27	SP0	RASR11
					1100	SR12	SR28	SP0	RASR12
1101	SR13	SR29	SP0	RASR13
					1110	SR14	SR30	SP0	RASR14
1111	SR15	SR31	SP0	RASR15

Unusually

Vector processor is unavailable. The PFTCH form of looking ahead

The assembler syntax

LDC{cond}p15，2，<Address>

PFTCH{cond}<Address>

Here Cond={eq, he, cs, cc, mi, pl, rs, vc, hi, Is, ge, lt, gt, le, al, nv}, the ARM7 tables of data of reference address mode syntax. Explanation

This instruction is that true time is carried out at Cond only. Cache line by the EA appointment is pre-fetched in the ARM7 data cache. Operation

How to be calculated about EA, with reference to the ARM7 tables of data. Unusually: without STARTVP start vector processor form

The assembler syntax

CDP{cond}p7，0，cO，cO，cO

STARTVP{cond}

Cond={eq wherein, he, cs, cc, mi, pl, vs, vc, hi, Is, ge, it, gt, le, al, nv}. Explanation

This instruction is that true time is carried out at cond only. This instruction is signaled to vector processor, starts to carry out and automatically remove VISRC＜vjp〉and VISRC＜vip. ARM7 does not wait for that vector processor starts execution, continues to carry out next instruction.

The state of vector processor must be initialized to desired state before this instruction is carried out. If vector processor is at the VP-RUN state, then this instruction is without effect.

Position 19:12,7:5 and 3:0 keep. Unusually

Vector processor is unavailable. TESTSET tests and arranges form

The assembler syntax

MRC{cond}p7，0，Rd，cO，cER，0

TESTSET{cond}Rd，RNAME

Here cond={eq, he, cs, cc, mi, pl, rs, re, hi, ls, ge, It, gt, le, al, nv}. Rd=and r0....r15}, ER={0 ... ..15}, RNAME refer to the register memonic symbol (that is, VER1 or VASYNC) of appointment on the structure. Explanation

This instruction is that true time is carried out at cond only, and this instruction turns back to the content of UERX among the RD, and sets UERX＜30〉be 1. If destination register is appointed as by ARM7 register 15 then UERx＜30〉return in the Z position of CPSR, in order to can realize short busy waiting circulation.

Current, only have UER1 to be prescribed in company with reading instruction works.

Position 19:17 and 7:5 keep. Unusually: without appendix B

The organization definition of multimedia processor 100 extended register of processor 110 usefulness MFER and MTER instruction access, extended register comprises special permission extended register and user's extended register.

The special permission extended register is mainly used in controlling the operation of multi-media signal processor. They are shown in table and B.1 show B.1: the special permission extended register

Number	Memonic symbol	Explanation
			PER0	CTR	Control register
PER1	PVR	The processor type register
			PER2	VIMSK	The vector IMR
PER3	AIABR	ARM7 IA breakpoint register
			PER4	ADABR	ARM7 data address breakpoint register
PER5	SPREG	The scratchpad register
			PER6	STR	Status register

The operation of control register control MSP100, all positions among the CTR are eliminated when resetting, and B.2 the definition of register shown in showing. Table definition B.2:CTR

The position	Memonic symbol	Explanation
			31-13		Keeping the position reads as 0 forever
12	VDCI	Vector data cache invalidation position. During set, it is invalid that whole vector processor data caches are become. Because the cache invalidation operation can conflict with normal cache operations usually, so can only support an invalid code sequence.
			11	VDE	Vector data cache enabling position. When removing, forbid the vector processor data cache
10	VICI	Vector instruction cache invalidation position. It is invalid that whole vector processor instruction caches are become. Because the cache invalidation operation can conflict with normal cache operations usually. So can only support an invalid code sequence.
			9	VICE	Vector instruction cache enabling position. When removing, forbid the vector processor instruction cache.

The position	Mnemonic symbol	Explanation
			8	ADCI	ARM7 data cache invalid bit. When set, it is invalid that whole ARM7 data caches are become. Because cache invalidation operates usually together with normal cache operations conflict, so only support an invalid code sequence.
7	ADCE	ARM7 data cache enable bit. When removing, forbid the ARM7 data cache.
			6	AICI	ARM7 instruction cache invalid bit. When set, it is invalid that whole ARM7 instruction caches are become. Because cache invalidation operates usually together with normal cache operations conflict, so only support an invalid code sequence.
5	AICE	ARM7 instruction cache enable bit. When removing, forbid the ARM7 instruction cache
			4	APSE	ARM7 processor single step enable bit. When set, make the ARM7 processor after carrying out an instruction, it is unusual that the single step of ARM7 processor occurs. The single step function only obtains under user or way to manage.
3	SPAE	Scratchpad access enable bit. When setting, allow ARM7 to process from scratchpad and load or deposit scratchpad. When removing, attempt loading or be stored into scratchpad unusual to produce ARM7 invalid data address
			2	VPSE	Vector processor single step enable bit. When setting, make vector processor after carrying out an instruction, it is unusual that the vector processor single step occurs.
1	VPPE	Vector processor streamline enable bit. When removing, the configuration vector processor is in order to operate under the nonpipeline mode. This moment, it was movable only having an instruction in the vector processor execution pipeline.
			0	VPAE	Vector processor access enabled position. When setting, make as mentioned above the ARM7 instruction of ARM7 processing execution expansion. When removing, stop ARM7 processing execution expansion ARM7 instruction. All such attempts can produce unavailable unusual of vector processor

The state of status register instruct MS P100. All positions among the field STR are eliminated when resetting, and B.3 the definition of register shown in showing. Table is definition B.3STR

The position	Memonic symbol	Explanation
			31：23		Reservation position-forever pronounce 0
22	ADAB	When ARM7 data address breakpoint coupling occured, ARM7 data address breakpoint exception bits was set up, and interrupting report by data exception should be unusual.
			21	AIDA	When ARM7 loads or the storage instruction attempts to access debatable address or MSP concrete scheme when not finishing, maybe when attempting to access a unallowed scratch pad memory, it is unusual to produce ARM7 invalid data address. Thisly unusually can stop interrupt reporting by data.
20	AIAB	When ARM7 IA breakpoint matches now, ARM7 IA breakpoint exception bits is set. This stops by looking ahead interrupting reporting unusually.
			19	AIIA	ARM7 illegal command address is unusual. This exception stops by looking ahead interrupting reporting.
18	ASTP	The ARM7 single step is unusual. This stops by looking ahead interrupting reporting unusually.
			17	APV	ARM7 protects fault. This interrupts reporting by IRQ unusually
16	VPUA	Vector processor is unavailable unusual, and this is reported by the unavailable interruption of coprocessor unusually
			15-0		Keep-forever pronounce 0

The type of the concrete processor of the multi-media signal processor series of processor type (Version) register identification processor.

Vector processor IMR VIMSK control is to the unusual report of the vector processor of processor 110. Corresponding position in along with the VISRC register and when setting, each among the VIMSK produces unusual to interrupting ARM7. How it detects the unusual of vector processor if not affecting, but whether impact will interrupt ARM7 unusually. All positions in VIMSK are eliminated when resetting. The definition of register is table definition B.4:VIMSK shown in showing B.4

                                                   

The position	Memonic symbol	Explanation
			31	DABE	The data address breakpoint interrupts enabling
30	IABE	The IA breakpoint interrupts enabling
			29	SSTPE	Single step is interrupted enabling
28-14		Keep-forever pronounce 0.
			13	FOVE	Floating-point overflows and interrupts enabling
12	FINVE	Floating-point illegal operation number interrupts enabling
			11	FDIVE	Floating-point is enabled except interrupting by zero
10	IOVE	Integer overflow interrupts enabling
			9	IDIVE	Integer is enabled except zero interruption
8-7		Keep-forever pronounce 0
			6	VIE	VCINT interrupts enabling
5	VJE	VCJOIN interrupts enabling
			4-1		Keep-forever pronounce 0
0	CSE	Context switch enables

ARM7 IA breakpoint register assistant adjustment ARM7 program. B.5 the definition of register shown in showing. Table definition B.5:AIABR

The position	Memonic symbol	Explanation
			31-2	IADR	The ARM7 IA
1		Keep, forever be read as 0
			0	IABE	The IA breakpoint can make, and removes when resetting. If set is as " ARM7 instruction access address " coupling AIABR＜31:2 〉, and VCSR＜AIAB when being eliminated, it is unusual that ARM7 IA breakpoint occurs, VCSR＜AIAB set is unusual to represent. When coupling occurs, if VCSR＜AIAB〉set, then this VCSR＜AIAB〉be eliminated, mate out in the cold. Report is unusual before instruction is carried out.

" ARM7 data address breakpoint register " assistant adjustment ARM7 program. B.6 the definition of register shown in showing. Table is definition B.6:ADABR

The position	Memonic symbol	Explanation
			31-2	DADR	The ARM data address. When resetting without definition
1	SABE	Storage " the address breakpoint enables " is removed when resetting. If set is as high 30 coupling ADABR＜31:2 of ARM7 storage reference address〉and VCSR＜ADAB when being eliminated, it is unusual that " ARM7 data address breakpoint " occurs. VCSR＜ADAB〉set represents unusually. When coupling occurs, if VCSR＜ADAB〉this VCSR＜ADAB then is set〉be eliminated, coupling is left in the basket. Before the storage instruction is carried out, unusually reported.
			0	LABE	The load address breakpoint enables. When resetting, remove. If set is as high 30 coupling ADABR＜31:2 of ARM7 loading reference address〉and VCSR＜ADAB " ARM7 data address breakpoint " occurs when being eliminated unusually. VCSR＜ADAB〉be set to represent unusually. If VCSR＜ADAB when coupling occurs〉set, this VCSR＜ADAB〉be eliminated, coupling is left in the basket. Report is unusual before load instructions.

" scratchpad register " is configured in address and the size of the scratchpad that uses SRAM formation in the high-speed buffer subsystem 130. Register definitions is shown in table and B.7 shows B.7:SPREG definition

The position	Memonic symbol	Explanation
			31-11	SPBASE	Initial address high 21 of " scratchpad plot " indication scratchpad. According to the value in the MSP_BASE register, this value must have the skew of 4M byte
10-2	Keep
			1-0	SPSIZE	The size 00-of scratchpad＞0K (with 4K vector processor data cache) 01-＞2K (with 2K vector processor data cache) 10-＞3K (with 1K vector processor data cache) 11-＞4K (without the vector processor data cache)

User's extended register is synchronous mainly for the treatment of device 110 and 120. User's extended register is current be defined only have one, mapping puts 30 in place, and for example the instruction of " MFERR15, UERx " is back into the Z sign with the value of position. UERx＜31, position〉and UERx＜29:0 always pronounced 0. User's extended register is illustrated in showing B.8. Show B.8: user's extended register

Number	Memonic symbol	Explanation
			UER0	VPSTATE	The vector registor Status Flag. When set, position 30 expression vector processors are at the VP_RUN state, and the execution instruction. When removing, the expression vector processor is in the VP_IDLE state, and has stopped next bar instruction of VPC addressing in order to carry out. VPSTATE＜30〉when resetting, be eliminated.
UER1	VASYNC	Vector sum ARM7 synchronous mark. Position 30 provides the producer/consumer type between vector sum ARM7 processor 120 and 110 synchronous. Vector processor 120 can or be removed this sign with VMOV instruction setting. This sign can also be set up or remove with the processing of MFER or MTER instruction by ARM7. In addition, sign can be read or set with the TESTSET instruction.

B.9, table has shown the state of extended register when power-on reset. Show B.9: the extended register powering state

Register	Reset mode
		CTR
	0
		PVR	TBD
VIMSK
		0
AIABR			AIABR＜0 〉=0, other is all undefined
	ADABR	ADABR＜0 〉=0, other is all undefined
STR
		0
VPSTATE			VPSTATE＜30 〉=0, other is all undefined
	VASYNE	VASYNC＜3 〉=0, other is all undefined

Appendix C

The configuration state of vector processor 120 comprises 32 32 scalar registers; 2 groups of 32 288 bit vector registers; A pair of 576 bit vector accumulator registers; One group of 32 special register. Scalar, vector and accumulator registers are intended for universal programming, and support many different types of data.

Each several part after following mark is used for reaching here: VR represents vector registor; VRi represents i vector registor (zero offset); VR[i] be illustrated in i data element among the vector registor VR; VR＜a:b〉be illustrated in vector registor meta a to b, and VR[i]＜a:b〉be illustrated in the position a of i data element among the vector registor VR to b.

For a plurality of elements in the vector registor, vector structure has the size of an excessive data type and data length. Because vector registor has fixed dimension, its retainable data element prime number depends on the length of element. The MSP organization definition such as the 5 kind length of elements of table shown in C.1. Show C.1: the length of data element

The length name	Length (position)
		Boolean	1
Byte	8
		Byte 9	9
Half-word	16
		Word	32

The MSP structure is explained vector data according to data type and the length of appointment in the instruction. Usually, byte, byte 9, half-word and Character table length are supported 2 complement code (integer) form in most of arithmetic instruction. In addition, to most of arithmetic instruction, Character table length is supported the IEEE754 single-precision format.

Programmer can any desired mode decryption, as long as command sequence produces significant result. For example, the programmer can freely use byte 9 to store 8 unsigned numbers, is equivalent to and can freely deposits 8 unsigned numbers in the byte data element, and go to operate them with the arithmetic instruction of 2 the complement code that provides, as long as program can be processed " vacation " and overflow the result.

32 scalar registers are arranged, be called SR0 to SR31. Scalar register is long and can hold a data element of any definition length by 32. Scalar register SR0 is a specified register. Register SR0 always reads 32 zero. And ignore writing the SR0 register. Byte, byte 9 and half-word data type are stored in the least significant bit of scalar register, and those highest significant positions have undefined value.

Because register do not have the data type indicator, the programmer must know the data type of the register that every instruction is used. This is different from thinks that 32 bit registers comprise other structure of 32 place values. The result of MSP structure specified data type A only correctly is revised as the defined position of data type A. For example, the result that byte 9 adds, low 9 of can only revise 32 target scalar registers. 23 higher place values are definition not. Unless point out in addition with instruction.

64 vector registors are configured 2 groups, and each organizes 32 registers. Group 0 comprises initial 32 registers, and group body 1 comprises 32 registers of next. One is set to current group, another setting or alternate sets in these two groups. All vector instructions are used register in current group by default value, and except loading/storage and register transfer instruction, they can access the vector registor in the alternate sets. CBANK position in " vector control " and " status register VCSR " can be used to arrange group 0 or 1 becomes current group (another one becomes alternate sets). Vector registor in current group is designated as VR0 to VR31, and is appointed as VRA0 to VRA31 in alternate sets.

In addition, these two groups can merge the vector registor that 32 double sizes are provided, 576 in each register from conceptive. VEC64 specifies the position this mode in control register VCSR. In the VEC64 pattern, regardless of current group and alternate sets, and vector registor represents a pair of corresponding 288 bit vector registers in two groups, namely

VRi<575：0>＝VR1i<287：0>：VR ₀i<287：0>

Here VR₀I and VR₁I be illustrated respectively in the group 1 and 0 in register number be the vector registor of VRi. Double wide vector registor is called as VR0 to VR31.

Vector registor can hold a plurality of elements of byte, byte 9, half-word or word length, shown in showing C.2. Show C.2: the number of elements of each vector registor

The length of element name	Length of element (position)	The element maximum number	Used total bit
				Byte
9	9	32	288
				Byte	8	32	256
Half-word	16	16	256
				Word	32	8	256

Be not supported in and mix multiple element length in the register. Except byte 9 elements only with 256 in 288. Especially each the 9th need not. No 32 are retained in byte, half-word and word length. The programmer should not make any hypothesis to their value.

The vector accumulator registers will provide storage for having more high-precision intermediate object program than the result in the destination register. The vector accumulator registers is comprised of 4 288 bit registers, and it is VAC1H, VAC1L, VAC0H and VAC0L. VAC0H:VAC0L is to being used by 3 instructions by default. Only in the VEC64 pattern, VCL1H:VAC1L is to being used for simulation 64 bytes 9 vector operations. Even group 1 is set for current group in the VEC32 mode, still uses this VAC0H:VAC0L pair.

For generation coexists the result of the extended precision of identical element number is arranged in the vector register of source, preserves the extended precision element by a pair of register, as table C.3 shown in. Show C.3: vectorial accumulator form

Length of element	The logic vision area	The VAC form
			Byte 9	VAC[i]<17：0>	VAC0H[i]＜8: VAC0L＜i〉＜8:0〉for i=0.31 and VAC1H[i-32]＜8:0 〉: VAC1L[i-32]＜8:0〉for i=32..63
Byte	VAC[i]<15：0>	VAC0H[i]＜7:0 〉: VAC0L＜i〉＜7:0〉for i=0..31 and VAC1H[i-32]＜7:0 〉: VAC1L[i-32]＜7:0〉for i=32..63
			Half-word	VAC[i]<31：0>	VAC0H[i]＜15:0 〉: VAC0L＜i〉＜15:0〉for i=0..15 and VAC1H[i-16]＜15:0 〉: VAC1L[i-16] for i=16..31
Word	VAC[i]<63：0>	VAC0H[i]＜31:0 〉: VAC0L＜i〉＜31:0〉for i=0..7 and VAC1H[i-8]＜31:0 〉: VAC1L[i-8]＜31:0〉for i=8..15

Only in the VIEC64 pattern just with VAC1H:VAC1L pair, number of elements at this moment, byte 9 (and byte), half-word and word are respectively 64,32 or 16.

There are 33 special registers directly not load or directly to deposit in memory from memory. 16 special registers are called as RASR0 to RASR15, form an inner return-address stack and by subroutine call and return instruction and use. Other 17 32 special register is shown in table and C.4 shows C.4: special register

Number	Memonic symbol	Explanation
			SP0	VCSR	Vector control and status register
SP1	VPC	The vector program counter
			SP2	VEPC	The unusual program counter of vector
SP3	VISRC	The vector interrupt source register
			SP4	VIINS	Vector interrupt instruction register
SP5	VCR1	Vector count register 1
			SP6	VCR2	Vector count register 2
SP7	VCR3	Vector count register 3
			SP8	VGMR0	The total mask register 0 of vector
SP9	VGMR1	The total mask register 1 of vector
			SP10	VOR0	Vector overflow register 0
SP11	VOR1	Vector overflow register 1
			SP12	VIABR	Vector data address breakpoint register
SP13	VDABR	Vector instruction address breakpoint register
			SP14	VMMR0	Vector shifts mask register 0
SP15	VMMR1	Vector shifts mask register 1
			SP16	VASYNC	Vector sum ARM7 SYN register

Vector control and status register VCSRDefinition be shown in table and C.5 show C.5:VCSR definition

The position	Memonic symbol	Explanation
			31：18	Keep
17：13	VSP<4：0>	The return address stack pointer. VSP is by transferring to subroutine and returning to use to follow the tracks of the stack top of inner return address from the subroutine instruction. In return-address stack, only have 16 entrances, VSP＜4〉for detection of the stack overflow condition.
			12	SO	Gather overflow status flag. When the arithmetical operation result was overflowed, this position was set. In a single day this is constant after arranging, until write 0 for this position

		In time, just remove.
			The position	Memonic symbol	Explanation
11	GT	Greater than Status Flag. When SRa＞SRb, with the VSUBS instruction this position is set.
			10	EQ	Equal Status Flag. When SRa=SRb, with the VSUBS instruction this position is set.
9	LT	Less than Status Flag. When SRa＜SRb, with the VSUBS instruction this position is set
			8	SMM	Select to shift shielding. When this position arranged, VMMR0/1 was to becoming the element shielding of arithmetical operation.
7	CEM	The complement elements shielding. When this position arranged, the whichever element shielding that is configured to arithmetical operation, element shielding were defined by 1 the complement code of VGMR0/1 or VMMR0/1. This does not change the content of VGMR0/1 or MMR0/1, and it only changes the use of these registers. SMM:CEM encodes regulation: 00-usefulness VGMR0/1 as the shielding of all elements except VCMOVM. 01-shields as all elements except VCMOVM with VGMR0/1. 10-shields as all elements except VCMOVM with VMMR0/1. 11-shields as all elements except VCMOVM with VMMR0/1.
			6	OED	Overflow exception is forbidden. When this position, position, processor 120 still continues to carry out after detecting overflow condition.
5	ISAT	Integer is counted saturation mode. The combination of OED:ISAT position is defined as: 00 without the saturated regulation in OED:ISAT position: 00 is unsaturated, reports when overflow exception occurs. X1 is saturated, does not cause and overflows

The position	Memonic symbol	Explanation
						10 is unsaturated, do not report when overflow exception occurs.
4：3	RMODE	IEEE754 floating-point operation rounding procedure. The 00 direction negative poor large 01 direction 0 10 direction closest value 11 direction positive infinity that rounds off that rounds off that rounds off that rounds off
			2	FSAT	Floating-point saturation mode position (fast IEEE mode)
1	CBANK	Current group of position. When set, represent to organize 1 and be current group. Represent to organize 0 and be current group when removing, when position, VEC64 position, CBANK ignores.
			0	VEC64	64 bytes, 9 vector pattern positions. Regulation vector registor and accumulator have 576 when set. Default mode is stipulated 32 bytes, 9 length, and it is called as the VEC32 pattern.

Vector program counter register VPCIt is the address by the next instruction of vector processor 120 execution. ARM7 processor 110 should load register VPC before with start vector processor 120 operation sending the STARTVP instruction.

The unusual program counter VEPC of vectorPoint out that most probable causes up-to-date unusual IA. MSP100 does not support precise abnormal, therefore, has used " most probable " word.

Vector interrupt source register VISRC ARM7 processor 110 is pointed out interrupt source. Suitable position then is set up in abnormality detection by hardware. Software must be removed register VISRC before vector processor 120 restarts to carry out. Position, any position in register VISRC all causes vector processor 120 VP_IDLE that gets the hang of. If corresponding interrupt enable bit is set up in VIMSK, just be issued for the interruption of processor 110. C.6, table has defined the content of register VISRC. C.6:VISRC definition

The position	Mnemonic symbol	Explanation
			31	DAB	The data address breakpoint is unusual
30	IAB	The IA breakpoint is unusual
			29	SSTP	Single step is unusual
28-18		Keep
			17	IIA	The illegal command address is unusual
16	IINS	Illegal command is unusual
			15	IDA	The invalid data address is unusual
14	UDA	The non-alignment data access is unusual
			13	FOV	The floating-point overflow exception
12	FINV	Floating-point invalid operation number is unusual
			11	FDIV	Floating-point is removed unusual by zero
10	IOV	Integer overflow is unusual
			9	IDIV	Integer is removed unusual by zero
8	RASO	The return address stack overflow is unusual
			7	RASU	The return-address stack underflow exception
6	VIP	VCINT hangs up unusually, carries out the STARTVP instruction and removes this position
			5	VJP	VCJOIN hangs up unusually, carries out the STARTVP instruction and removes this position
4-0	VPEV	The vector processor exception vector

Vector interrupt instruction register VIINS, when VCINT or VCJOIN instruction were performed to interrupt ARM7 processor 110, VCINT or VCJOIN instruction were updated.

Vector count register VCR1, VCR2 and VCR3Be for " decrement and branch " instruction VD1CBR, VD2CBR and VD3CBR, and be initialised with the cycle count of carrying out. When carrying out the VD1CBR instruction, register VCR1 is subtracted 1. If count value is non-vanishing, and in instruction indication Condition Matching VFLAG, branch then occurs. Otherwise, branch does not occur. Register VCR1 under any circumstance can subtract 1. Register VCR2 and VCR3 are used in the same manner.

Vector full-shield register VGMR0 is illustrated in the VEC32 pattern element of the object vector register that will be affected and is in VR＜287:0 in the VEC64 pattern〉in element. The renewal of 9 positions in each dominant vector destination register in VGMR0. Specifically, VGMR0＜i〉VRd＜9i+8:9i in the control VEC32 pattern renewal and the VEC64 pattern in VR₀D＜9i+8:9i〉renewal. Note VR₀D refers to the destination register in the group 0 in the VEC64 pattern, and VRd refers to the destination register in current group. In the VEC32 pattern, it is group 0 in both, also can be group 1. Vector full-shield register VGMR0 is used for the execution with all instructions beyond the VCMOVM instruction.

Vector full-shield register VGMR1Be illustrated in the VEC64 pattern the VR＜575:288 that is affected interior element. The renewal of 9 positions in the vectorial destination register in every control group 1 in register VGMR1. VGMR1＜i specifically〉control VR1＜9i+8:9i renewal. Register VGMR1 does not use in the VEC32 pattern, but in the VEC64 pattern, the execution of all instructions of impact except the VCMOVM instruction.

Vector overflow register VOR0Be illustrated in VR＜287:0 in element in the VEC32 pattern and the VEC64 pattern〉in element, they comprise the result of overflowing after the vector arithmetic computing. This register is not subjected to the modification of scalar arithmetical operation. Position VOR0＜i〉expression byte and i element of byte 9, the＜i of half-word, idiv2 be set〉(i, idiv4) individual element of individual element or digital data type operations comprises and overflows the result. For example, position 1 and position 3 may be configured to respectively represent overflowing of first half-word and Character table. Be different from mapping at VGMR0 or VGMR1 meta in the mapping of VOR0 meta.

Vector overflow register VOR1Be used for being illustrated in VR＜575:288 in the VEC64 pattern〉in element, they are included in the result of overflowing after the vector arithmetic computing. Register VOR1 in the VEC32 pattern and need not, also can't help the scalar arithmetical operation to revise. Position VOR1＜the i that arranges〉(i idiv4) individual element of i element of expression byte or byte 9, (i, idiv2) individual element of half-word or digital data type operations comprises and overflows the result. For example, position 1 and position 3 may be configured to respectively be illustrated in VR＜575:288〉in the overflowing of first half-word or Character table. Be different from mapping at VGMR0 or VGMR1 meta in the mapping of VOR1 meta.

Vector instruction address breakpoint register VIABRAssistant adjustment vector program. C.7 the definition of register shown in showing. Table definition C.7:VIABR

The position	Memonic symbol	Explanation
			31-2	IADR	The vector instruction address does not define when resetting
1		Keep the position
			0	IABE	The IA breakpoint enables. When resetting, do not define. If set is as the same VIABR＜31:2 of vector instruction reference address〉" vector instruction address breakpoint " occurs when mating unusually, a VISRC＜IAB is set〉unusual to represent. This unusually report before instruction is carried out.

Vector data address breakpoint register VDABRAssistant adjustment vector program. The definition of register is such as C.8 expression of table. Table definition C.8:VDABR

The position	Memonic symbol	Explanation
			31-2	DADR	The vector data address. When resetting, do not define
1	SABE	Storage address breakpoint enables. Do not define when resetting. If set is as the same VDABR＜31:2 in vectorial memory access address〉when mating, it is unusual that " vector data address breakpoint " occurs. Position VISRC＜DAB〉be set to represent unusually. Report is unusual before the storage instruction is carried out.
			0	LABE	The load address breakpoint enables. When resetting, remove. If set is when vector loads the same VDABR＜31:2 of reference address〉" vector data address breakpoint " occurs when mating unusually. VISRC＜DAB〉be set to represent unusually. Report is unusual before load instructions is carried out.

Vector shifts mask register VMMR0In institute is free for the VCMOVM instruction, simultaneously as VCSR＜SMM=1 the time for all instructions. Register VMMR0 be illustrated in the VEC32 pattern can affected object vector register element, and in the VEC64 pattern VRL＜287:0 interior element. The renewal of 9 positions in VMMR0 each dominant vector destination register. VMMR0＜i specifically〉in the VEC32 pattern, control VRd＜9i+8:9i renewal, in the VEC64 pattern, control VR₀D＜9i+8:9i〉renewal. VR in the VEC64 pattern₀D is illustrated in the destination register in the group 0, and VRd refers to the destination register in current group, and VRd both can also can organize in 1 in group 0 in the VEC32 pattern.

Vector shifts mask register VMMR1In institute is free for the VCMOVM instruction, simultaneously as VCSR＜SMM=1 the time for all instructions. Register VMMR1 is illustrated in the VEC64 pattern can affected VR＜575:288〉in element, every among the VMMR1 is controlled at the renewal of 9 positions in the vectorial destination register in the group 1. VGMR1＜i specifically〉control VR1d＜9i+8:9i renewal. Register VGMR1 does not use in the VEC32 pattern.

Vector sum ARM7 SYN register VASYNCBe provided at the synchronous of the producer between processor 110 and 120/consumer's pattern. Current, only defined position 30. When vector processor 120 during at VP_ RUN or VP_IDLE, the ARM7 processor can be used MFER, MTER and TESTSET instruction access register VASYNC. Register VASYNC can not be accessed by the ARM7 processor by TVP or MFVP instruction. Because these instructions can not be accessed the special register of 16 vector processors that exceed beginning. Vector Processing can be passed through VMOV instruction access register VASYNC.

The state of the vector processor when C.9 table shows power-on reset. Show C.9: vector processor power-on reset state

Register	Reset mode
		SR0
	0
		All other registers	Without definition

Before vector processor can be carried out instruction, initialize special register by ARM7 processor 110.

Appendix D

The data type of source and destination operand is implied or has stipulated in every instruction. Some instruction has the semanteme that is applicable to comparably more than a kind of data type. The semanteme that some instruction has adopts a kind of data type to the source, and the result is produced different types of data. This appendix has illustrated the data type that example embodiment is supported. Data type int8, int9, int16, int32 and the floating number supported have been described in the table 1 in this application. Do not support signless integer format, before using, at first must convert 2 complement code form to signless integer value to. The programmer can freely use arithmetic instruction together with unsigned int or select any other form, overflows as long as process suitably. This structure has only defined overflowing of 2 complement code integer number and 32 floating types. These structures do not detect the execution of 8,9,16 or 32 bit arithmetics, and this computing is that detection is overflowed necessary without symbol. D.1, table has shown that data length that load operation supports D.1: the data length that load operation is supported

Data length in the memory	Data length in the register	Load operation
			8-bit	9-bit	Load 8, sign extended to 9 (being used for loading 82 complement code)
8-bit	9-bit	Load 8, zero expands to 9 (being used for loading signless 8)
			16-bit	16-bit	Load 16, (being used for loading 16 complement codes without symbol or 2)
32-bit	32-bit	Load 32, (be used for loading 32 without symbol, complement code integer number or 32 floating-points of 2)

This structure regulation memory address is by the data type boundary alignment. Namely to byte without the alignment requirement; To half-word, aligned condition is half-word boundary; To word, aligned condition is word boundary.

D.2, table has shown that data length table that the storage operation supports D.2: the data length that the storage operation is supported

Data length in the register	Data length in the memory	The storage operation
			8-bit	8-bit	Store 8 (storing 8 complement codes without symbol or 2)
9-bit	8-bit	Cut least-significant byte, store 8 and (store 9 tools

		2 the complement code of signless value between 0-255 arranged)
			16-bit	16-bit	Store 16 (storing 16 complement codes without symbol or 2).
32-bit	32-bit	Store 32

No matter be the register of scalar or vector because be mapped to more than a kind of data type. So may some undefined result to some data type in destination register. In fact, except the operation of byte 9 data lengths in vectorial destination register with in the scalar destination register the digital data size operation, some position in destination register, their value is not defined because of operation. To these positions, structure stipulates that their value is undefined, and D.3 table has shown the position that every kind of data length is not defined. Show D.3: the undefined position of data length

Data length	The vector destination register	The scalar destination register
			Byte	VR<9i+8>，for i＝0 to 31	SR<31：8>
Byte 9	none	SR<31：9>
			Half-word	VR<9i+8>，for i＝0 to 31	SR<31：16>
Word	VR<9i+8>，for i＝0 to 31	none

The programmer must know the data type of source and destination register or memory when programming. Data type converts another kind to from a kind of length of element and causes potentially with different number of elements and be stored in the vector registor. For example the conversion of the vector registor from half-word to the digital data type needs 2 vector registors to remove to store the same number of element that is converted. On the contrary, become half word format from the digital data type conversion that vector registor, has user's definition format, in half of vector registor, produce the similar number element, and remaining bit is in second half. In both cases, data type conversion produces a kind of structure with the element arrangements of being converted, and the length of these elements is different from the length of source element.

As a principle, the MSP structure does not provide and impliedly changes number of elements and as a result of operate, and this structure means that the programmer must know the consequence that changes number of elements in the destination register. This structure only provides the operation that becomes the another kind of data type of same length from a kind of data type conversion. And when turning from a kind of data type or during the data type of another kind of different length, needing the programmer is that the difference of data length is made adjustment.

Oversimplify at the vector that the special instruction described in the appendix E such as VSHFLL and VUNSHFLL make the vector of the first data length convert the 2nd kind of data length to. In vector registor VRa, (such as int8) converts larger length of element to from less length of element, and the included basic step of 2 complement code data types of (such as int16) is:

1. use byte data type, the element among the VRa and another vectorial VRb shuffled becomes 2 vectorial VRc:VRd. Element in VRa shift int16 data element among the wide register VRc:VRd doubly than the low byte place. And its element that is worth incoherent VRb is transferred to the high byte place of VRc:VRd. This operation moves on to half of VRa element among the VRc effectively, and second half moves on among the VRd. At this moment, the length of each element doubles into half-word from byte.

2. the element arithmetic shift among the VRc:VRd is moved 8, and it is made sign extended

In vector registor VRa 2 complement code number being changed into the included basic step of smaller length (such as int8) from larger length of element (int16) is:

1. check that each element of confirming in the int16 data type can represent with byte length. If necessary, saturated this element at two ends is to be fit to smaller length.

2. the element among the VRa is gone to shuffle with another vectorial VRb, transfer among 2 vectorial VRc:VRd, in VRa:VRb, height half one of each element transfers to VRc, low half one transfers among the VRd, has effectively gathered so low half element of all elements among the VRa in low half one of VRd.

For following data type conversion provides some special instructions: int32 changes into single-precision floating point; Single-precision floating point changes into fixed point (X.Y representation); Single-precision floating point changes into int32; Int8 changes into int9; Int9 changes into int16; And int16 changes into int9.

For the flexibility of vectorial programming is provided, most of vector instruction is used the element shielding and is only operated in selected element in the vector registor. The element of " vectorial full-shield register " VGMR0 and VGMR1 sign is the element that will be modified in destination register and vectorial accumulator by vector instruction. To the operation of byte and byte 9 data lengths, the every bit-identify in VGMR0 (or VGMR1) in 32 is wanted an operated element, position VGMR0＜i〉set represents that the element i of byte length will be applied. The i here is 0 to 31. Double digital data size operation, per two bit-identifies in VGMR0 (or VGMR1) in 32 are wanted an operated element. VGMR0＜2i:2i+1, position〉set represents that element i will be acted on, i is 0 to 15. If the centering of VGMR0 only has one to be set in the operation of half-word data length, then only have those positions in the respective byte to be modified. To the digital data size operation, per 4 one group of set identify an element and are operated in VGMR0 (or VGMR1). Position VGMR0＜4i:4i+3〉set represents that element i will be acted on, i is 0 to 7. If all positions that are not 4 group in VGMR0 are the set of digital data size operation, those positions that then are corresponding byte are modified.

VGMR0 and VGMR1 arrange available VCMPV instruction with vector registor with vector or scalar register relatively or vector registor more definite with immediate value, this instruction compatibly arranges shielding according to the data length of defined. Because scalar register is defined by only comprising a data element, so scalar operation (being that destination register is scalar) can not be subjected to the element screening effect.

For the flexibility of vector programming, 3 kinds of forms of most of MSP instruction support vector and scalar operation, they are:

1. vector=vector operations is vectorial

2. vector=vector operations scalar

3. vector=scalar operates scalar

The scalar register specifications is as the B operand in the situation 2, and the individual element in scalar register is copied into for the required quantity of number of elements in the matching vector A operand. The element that copies has identical value with the element in the designated scalar operands. Scalar operands can be from scalar register or instruction with the immediate operand form. In the situation of immediate operand, if the data length that the specified data type is used is larger than available immediate field length, then adopt suitable sign extended.

In many multimedia application, pay special attention to source immediately number and the precision of end product. In addition, integer takes advantage of instruction to produce " double precision " intermediate object program that can be stored in 2 vector registors.

Usually, the integer format of 2 of MSP structural support 8,9,16 and 32 bit elements complement code and 32 bits element IEEE754 single-precision format. Overflowing of definition, the expression result exceeds positive peak or the negative peak scope that can represent with the specified data type. When overflowing, the value of writing in the destination register is not significant figure, and defined underflow only is used for floating-point operation.

One of except as otherwise noted, all floating-point operations are with position VCSR＜RMODE〉4 kinds of rounding procedures of appointment. Some instruction rounding procedure of casting out zero (idol rounds off) of knowing. These instructions are obviously pointed out.

In many multimedia application, saturated is a kind of critical function. All 4 kinds of integers of MSP structural support and floating-point operation are saturated. Specify the integer saturation mode at register VCSR meta ISAT. The floating-point saturation mode, the fast IEEE mode of also expressing one's gratification, it is specified the position with FSAT among the VCSR. When enabling saturation mode, surpass maximum just or the result of large negative value just be arranged to respectively maximum or negative peak. In this case, do not overflow, overflow position can not be set up.

D.4, table is listed precise abnormal, these unusually detected before carrying out the fault appointment and reports. D.4 the exception vector address represents with 16 systems: precise abnormal

Exception vector	Explanation
		0x00000018	Vector processor IA breakpoint is unusual
0x00000018	Vector processor data address breakpoint is unusual
		0x00000018	The vector processor illegal command is unusual
0x00000018	The vector processor single step is unusual
		0x00000018	Vector processor return address stack overflow is unusual
0x00000018	Vector processor return-address stack underflow exception
		0x00000018	Vector processor VCINT is unusual
0x00000018	Vector processor VCJOIN is unusual

D.5, table is listed imprecise exceptions, and these are detected and report unusually after having carried out some instruction be in the fault instruction in program after. Show D.5: non-precise abnormal

Exception vector	Explanation
		0x00000018	Vector processor illegal command address is unusual
0x00000018	Vector processor invalid data address is unusual
		0x00000018	The vector processor Non-aligned data access is unusual
0x00000018	Vector processor integer overflow is unusual
		0x00000018	Vector processor floating-point overflow is unusual
0x00000018	Vector processor floating-point invalid operation number is unusual
		0x00000018	The vector processor floating number is removed unusual by 0
0x00000018	The vector processor integer is removed unusual by 0

Appendix E

The instruction of this vector processor comprises and is shown in ten one classification of table in E.1

Table E.1	The vector instruction class gathers
		Class	Explanation
Control stream	The contained instruction of this class is used for the program flow that control comprises transfer and ARM7 interface instruction.
		Logic (step-by-step mode, shielding)	This class comprises the logical order of step-by-step mode. Although (step-by-step mode, shielding) data type is Boolean Class, logical order uses element to shield to revise the result, thereby requires data type.
Displacement and cyclic shift (pressing the element mode, shielding)	The contained instruction of this class is used for the displacement of each element and the shielding of rotation bit. This class is distinguished the length of element, and is subjected to the impact of element shielding.
		Arithmetic (pressing the element mode, shielding)	This class comprises the arithmetic instruction by the element mode. (press the element mode, shielding) in other words i element result is that i element in the source calculates the type of this class differentiation element, and the impact that shielded by element.
Multimedia (pressing the element mode, shielding)	The contained instruction of this class is used for optimizing the application of multimedia (pressing the element mode, shielding), and this class is distinguished element type, and is subjected to the element screening effect.
		Data type conversion (pressing the element mode, unshielded)	The instruction that this class comprises is used for switch element from a kind of (element mode, unshielded) data type to another kind of. The data type collection of appointment is supported in the instruction of this class, and without the element shielding, because this structure is not supported in the register more than a kind of data type.
Arithmetic between element	The instruction that this class comprises is used for getting two elements to produce arithmetic results from the diverse location of vector.
		Shift between element	The instruction that this class comprises is used for getting two elements to rearrange element from the diverse location of vector.
Load/store	The instruction that this class comprises is used for loading or memory register. These instructions are not subjected to the impact of element shielding.
		Cache operations	The contained instruction of this class is used for control instruction and data cache. These instructions are not subjected to the impact of element shielding.
Register shifts	The instruction that this class comprises is used for transferring data between two registers. These instructions are not subjected to the impact of element shielding usually, but some can select the element shielding.

E.2, table is listed flow control instructions. Show E.2: the Flow Control instruction

Memonic symbol	Explanation
		VCBR	Conditional branching
VCBRI	Indirect conditional branching
		VD1CBR	Decrement VCR1 and conditional branching
VD2CBR	Decrement VCR2 and conditional branching
		VD3CBR	Decrement VCR3 and conditional branching
VCJSR	Condition rotor routine
		VCJSRI	Indirect condition rotor routine
VCRSR	Return from procedure condition
		VCINT	Condition is interrupted ARM7
VCJOIN	Condition and ARM7 converge
		VCCS	The condition context switches
VCBARR	The condition barrier
		VCHGCR	Change control register (VCSR)

Logic class is supported Boolean data type, and is subjected to the element screening effect. E.3, table is listed the Flow Control instruction. Show E.3: logical order

Memonic symbol	Explanation
		VNOT	NOT--B
VAND	AND-(A&B)
		VCAND	Complement code AND-(A﹠B)
VANDC	The AND complement code-(A﹠-B)
		VNAND	NAND--(A&B)
VOR	OR-(A|R)
		VCOR	Complement code OR-(A|R)
VORC	The OR complement code-(A|-R)
		VNOR	NOR--(A|R)
VXOR	XOR-(A^R)
		VXNOR	XNOR--(A^R)

The instruction of displacement/loop jump class is to int8, int9, int16 and int32 data type operation (non-floating type), and the impact that shielded by element. E.4, table has been listed displacement/cyclic shift class instruction. Show E.4: displacement and cyclic shift class

Memonic symbol	Explanation
		VDIV2N	Power except 2
VLSL	Logical shift left
		VLSR	Logic shift right
VROL	Ring shift left
		VROR	Ring shift right

Usually, int8, int9, int16 and int32 and floating type are supported in the instruction of arithmetic class, and are subjected to the impact of element shielding. For the special restriction of the data type of not supporting, with reference to the detailed description of following every instruction. The VCMPV instruction is the impact that is not subjected to the element shielding, because it works in element shielding situation. E.5, table is listed the instruction of arithmetic class. Show E.5: the arithmetic class

Memonic symbol	Explanation
		VASR	Arithmetic shift right
VADD	Add
		VAVG	On average
VSUB	Subtract
		VASUB	Subtract absolute value
VMUL	Take advantage of
		VMULA	Accumulator is taken advantage of
VMULAF	Multiply accumulating device decimal
		VMULF	Take advantage of decimal
VMULFR	Take advantage of decimal and and round off
		VMULL	Take advantage of low level
VMAD	Take advantage of and add
		VMADL	Take advantage of and add low level
VADAC	Add and add up

Memonic symbol	Explanation
		VADACL	Add and cumulative low level
VMAC	Take advantage of and add up
		VMACF	Take advantage of and cumulative decimal
VMACL	Take advantage of and cumulative low level
		VMAS	Take advantage of and subtract from accumulator
VMASF	Take advantage of and subtract from the accumulator decimal
		VMASL	Take advantage of and subtract from the accumulator low level
VSATU	Be saturated to the upper limit
		VSATL	Be saturated to lower limit
VSUBS	Subtract scalar sum and put condition
		VCMPV	Relatively vector sum is put shielding
VDIVI	Except initializing
		VDIVS	Remove
VASL	Arithmetic shift right
		VASA	Accumulator arithmetic moves one

The MPEG instruction is a class instruction that is suitable for specially mpeg encoded and decoding, but can use in a different manner. Int8, int9, int16 and int32 data type are not supported in the MPEG instruction, and are subjected to the impact of element shielding. E.6, table has been listed the MPEG instruction. Show E.6:MPEG class

Memonic symbol	Explanation
		VAAS3	Add and add (1,0,1) symbol
VASS3	Add and subtract (1,0,1) symbol
		VEXTSGN2	Extract (1,1) symbol
VEXTSGN3	Extract (1,0,1) symbol
		VXORALL	The least significant bit of the whole elements of XOR.

Every kind of specific data type of data type conversion instruction support, and the impact that not shielded by element be not because this structure is supported in the register more than a kind of data type. E.7, table has been listed the data type conversion instruction. Show E.7: the data type conversion class

Memonic symbol	Explanation
		VCVTIF	The conversion integer is to floating number
VCVTFF	The conversion floating-point is to fixed-point number
		VROUND	Round off floating-point to integer (supporting 4 IEEE rounding modes)
VCNTLZ	Count leading 0
		VCVTB9	Conversion byte	9 data types

Int8, int9, int16 and int32 and floating type are supported in the instruction of inner element arithmetic class. E.8, table has been listed the instruction of inner element arithmetic class. Show E.8: inner element arithmetic class

Memonic symbol	Explanation
		VADDH	Two adjacent elements add
VAVGH	Two adjacent elements are average
		VAVGQ	The quaternary element is average
VMAXE	Maximum exchange is strange/even element

Shift the class instruction between element and support byte, byte 9, half-word and digital data length, E.9 table has been listed and has been shifted the class instruction between element. Show E.9: shift class between element

Memonic symbol	Explanation
		VESL	Element moves to left one
VESR	Element moves to right one
		VSHFL	Idol/odd element shuffles
VSHFL	Idol/odd element shuffles
		VSHFLH	High idol/odd element shuffles
VSHFLL	Low idol/odd element shuffles
		VUNSHFL	Idol/odd element goes to shuffle
VUNSHFLH	High idol/odd element goes to shuffle
		VUNSHFLL	Low idol/odd element goes to shuffle

Load/store instruction also supports byte 9 relevant data lengths to operate except supporting byte, half-word and digital data length especially, and is subjected to the impact of element shielding. E.10, table has been listed the instruction of load/store class. Show E.10: the load/store class

Memonic symbol	Explanation
		VL	Load
VLD	Load double word
		VLQ	Load four words
VLCB	Load from the Circular buffer device
		VLR	The inverse element sequence loads
VLWS	Span loads
		VST	Storage
VSTD	The storage double word
		VSTQ	Store four words
VSTCB	Store the Circular buffer device into
		VSTR	The storage of inverse element sequence
VSTWS	The span storage

Most of register transfer instructions are supported int8, int9, int16 and int32 and float, are not subjected to the impact of element shielding, and only having the VCMOVM instruction is the impact that is subjected to the element shielding. E.11, table is listed register and is shifted the class instruction. Show E.11: register shifts class

Memonic symbol	Explanation
		VLI	Number loads immediately
VMOV	Shift
		VCMOV	Conditional jump
VCMOVM	Conditional jump with the element shielding
		VEXTRT	Extract an element
VINSERT	Insert an element

E.12, table is listed the cache operations class instruction of control high-speed buffer subsystem 130. Show E.12: the cache operations class

Memonic symbol	Explanation
		VCACHE	Cache operations to data or instruction cache
VPFTCH	Be prefetched to data cache
		VWBACK	From the data cache write-back

The instruction predicate

Be the explanation of reduction instruction collection, in whole appendix, adopted special term. For example, instruction operands is the integer number of complement code of the tape symbol 2 of byte, byte 9, half-word or word length, unless note separately. Term " register " is used in reference to general (scalar or vector) register, and the register of other type is clearly illustrated. Press the assembler language syntax, tail tag b, b9, h and w represent data length (byte, byte 9, half-word and word) and integer data type (int8, int9, int16 and int32). In addition, as follows for term and the symbol of describing instruction operands, operation and assembler language syntax. Rd destination register (vector, scalar or special use) Ra, Rb source register a and b (vector, scalar or special use) Rc source or destination register c (vector or scalar) Rs storage data source register (vector or scalar) S 32-bit scalar or 1 group of vector registor VRd vector of 0 group of vector registor VR1 of current group of vector registor VRA of special register VR alternate sets vector registor VR0 destination register (default to current group, unless VRA is designated) VRa, VRb vector source register a and b VRC vector source or destination register C VRS vector storage are according to source register VAC0H vector accumulator registers 0 high VAC0L vector accumulator registers 0 low VAC1H vector accumulator registers 1 high VAC1L vector accumulator registers 1 low SRd scalar destination register SRa, SRb scalar source register a and b SRb+ upgrade base register SRs scalar storage data source register SP special register VR[i with effective address] i element VR[i among the vector registor VR]＜a:b among the vector registor VR a of i element to b position VR[i]＜msb the effective address MEM memory BYTE[EA of the highest significant position EA memory access of i element among the vector registor VR] a byte HALF[EA among the storage address EA] half word among the storage address EA, address EA+1 is position＜15:8 〉. WORD[EA] a word among the storage address EA, address EA+3 is position＜31:24 〉. NumElem provides the element number that data type indicates. In the VEC32 pattern, to word

Joint and byte 9, half-word or digital data length are respectively 32,16 or 8;

The VEC64 pattern is respectively byte and byte 9, half-word or digital data length

64,32 or 16. NumElem is 0 to the scalar operation. EMASK[i] represent the element of i element is shielded. To byte and byte 9, half-word or number of words

According to length, VGMR0/1 ,～VGMR0/1, VMMR0/1 or～

Represent respectively 1,2 or 4 position among the VMMR0/1. Be the scalar operation, even

EMASK[i]=0, think that also the element shielding is set up. MMASK[i] represent the element of i element is shielded. In byte and byte 9, half-word or number of words

According to length, in VMMR0 or VMMR1, represent respectively 1,2 or 4

The position. VCSR vector control and status register VCSR＜x〉position or a plurality of among the expression VCSR. " x " is field name VPC vector processor program counter VECSIZE vector registor length, is 32 in the VEC32 pattern, in the VEC64 pattern is

64. The SPAD buffer

The C programming structure is used for describing flow-control operation. It is as follows that indicate the unusual part :=assignment: connect select (not being logic OR) sex between X ‖ Y} X or the Y to the sign extended sex_dp of the data length of the appointment data length double-precision number sign extended sign to appointment " (arithmetic) the sign extended zex zero expansion zero to the data length of appointment that moves to right " (logic) move to right zero expansion " 7 (from half-word) trnc1 that (the inserting zero) trnc7 that moves to left clips the front clip 1 (from byte 9) % modulo operation of front | expression| gets the absolute value of expression formula/except (adopting one of four kinds of IEEE rounding modes for floating type) // except (adopting rounding off of zero rounding mode) Saturate () is saturated to negative peak or positive peak to integer type, does not produce and overflow; Right

In floating type, saturated to positive infinity, positive zero, negative zero or negative

Or infinitely great.

The universal command form is presented among Fig. 8 and is described as follows.The REAR formUsed by load, store and cache operational order, and the field in the REAR form has the meaning that E.13 following table provides. Show E.13:REAR form

Field	Meaning
		OPC<4：0>	Command code
B	The group identifier of Rn register
		D	Purpose/source scalar register. When arranging, Rn＜4:0〉point out scalar register. Under the VEC32 pattern, to the legal value of B:D coding be: 00 Rn is that current group vector registor 01 Rn is that scalar register (in current group) 10 Rn are that vector registor 11 in alternate sets is undefined

	Under the VEC64 pattern, to the legal value of B:D coding be: 00 only has 4,8,16 or 32 bytes to be used 01 Rn in vector registor Rn, and to be that whole 64 bytes of scalar register 10 vector registor Rn are used 11 undefined
		TT<1：0>	Transmission type is indicated concrete loading or storage operation. See following LT and ST coding schedule.
C	High-speed cache is closed. Data cache when this being set loading with bypass. This arranges (connecting OFF to memonic symbol) with loading with the cache-off memonic symbol of being connected instruction
		A	The address is upgraded, and this position is set upgrades SRb with effective address. Effective address is pressed SRb+SRi and is calculated.
Rn<4：0>	Purpose/source register number
		SRb<4：0>	Scalar base register number
SRi<4：0>	Scalar index register number

Position 17:15 is retained and should be zero, with the compatibility of guaranteeing that structure will be expanded in the future. Some coding of B:D and TT field is undefined, and programmer should not used these codings, because structure not have to stipulate the expected results that ought a kind of like this coding be used. E.14, table illustrates the scalar load operation (being encoded as LT in the TT field) that VEC32 and VEC64 pattern are all supported. E.14 REAR load operation under VEC32 and VEC64 pattern of table

D：LT	Memonic symbol	Meaning
				100	.bs9	Load 8 and become byte 9 length, sign extended
101	.h	Load 16 and become half-word length
			110	.bz9	Loading 8 becomes byte 9 length, zero expansion
111	.W	Load 32 and become word length

E.15, table shows the vectorial load operation (being encoded as LT in the TT field) that the VEC32 pattern is supported, at this moment VCSR＜0〉position is eliminated. Show E.15:VEC32 REAR load operation under the pattern

D：LT	Memonic symbol	Meaning
			000	.4	Load 4 bytes from memory and enter 4 lower bytes 9 of register, and keep remaining byte 9 not change. Corresponding the 8th of the 9th basis of each of 4 bytes 9 made sign extended.
001	.8	Load 8 bytes from memory and enter 8 lower bytes 9 of register, and keep remaining byte 9 not change. Corresponding the 8th of the 9th basis of each of 8 bytes 9 made sign extended.
			010	.16	Load 16 bytes from memory and enter 16 lower bytes 9 of register, and keep remaining byte 9 not change. Corresponding the 8th of the 9th basis of each of 16 bytes 9 made sign extended.
011	.32	Load 32 bytes from memory and enter 32 lower bytes 9 of register, and keep remaining byte 9 not change. Corresponding the 8th of the 9th basis of each of 32 bytes 9 made sign extended.

The B position is used to indicate current or alternate sets.

E.16, table provides the vectorial load operation (being encoded as LT in the TT field) of supporting under the VEC64 pattern. This moment VCSR＜0 position be set up. Show the load operation of REAR under the pattern E.16:VEC32

B：D：LT	Memonic symbol	Meaning
			0000	.4	Load 4 bytes from memory and enter 4 lower bytes 9 of register, and keep remaining byte 9 not change. The 9th of each of 4 bytes 9 made sign extended according to corresponding the 8th.
0001	.8	Load 8 bytes from memory and enter 8 lower bytes 9 of register, and keep remaining byte 9 not change. Corresponding the 8th of the 9th basis of each of 8 bytes 9 made sign extended.
			0010	.16	Load 16 bytes from memory and enter 16 lower bytes 9 of register, and keep remaining byte 9 not change. Corresponding the 8th of the 9th basis of each of 16 bytes 9 made sign extended.

B：D：LT	Memonic symbol	Meaning
				0011	.32	Load 32 bytes from memory and enter 32 lower bytes 9 of register, and keep remaining byte 9 not change. Corresponding the 8th of the 9th basis of each of 32 bytes 9 made sign extended.
1000	Undefined
			1001	Undefined
1010	Undefined
			1011	.64	Load 64 bytes from memory and enter 64 lower bytes 9 of register, and keep remaining byte 9 not change. Corresponding the 8th of the 9th basis of each of 64 bytes 9 made sign extended.

Position B is used to indicate 64 byte vector operations, because do not exist in the VEC64 pattern when the concept that group and alternate sets are arranged.

E.17, table has been listed the scalar storage operation (being encoded as ST in the TT field) that VEC32 and VEC64 pattern are all supported. Table scalar storage operation E.17:REAR

D：ST	Memonic symbol	Meaning
				100	.b	Store byte or byte 9 length become 8 (blocking 1 from byte 9)
101	.h	Store halfword length becomes 16
			110	Undefined
111	.W	Memory word length becomes 32

E.18, table is listed the vectorial storage operation (being encoded as ST in the TT field) that the VEC32 pattern is supported, this moment VCSR＜0 position is eliminated. Show the vectorial storage operation of REAR under the pattern E.18:VEC32

D：ST	Memonic symbol	Meaning
			000	.4	From 4 bytes of register-stored to memory, each the 9th of 4 bytes 9 is left in the basket in the register.
001	.8	From 8 bytes of register-stored to memory, each the 9th of 8 bytes 9 is left in the basket in the register.
			010	.1b	From 16 bytes of register-stored to memory, each the 9th of 16 bytes 9 is left in the basket in the register.
011	.32	From 32 bytes of register-stored to memory, each the 9th of 32 bytes 9 is left in the basket in the register.

E.19, table is listed the vectorial storage operation (being encoded as ST in the TT field) that the VEC64 pattern is supported, at this moment VCSR＜0〉position is set up. Show E.19: REAR vector storage operation under the VEC32 pattern

B：D：ST	Memonic symbol	Meaning
			0000	.4	From 4 bytes of register-stored to memory, each the 9th of 4 bytes 9 is left in the basket in the register.
0001	.8	From 8 bytes of register-stored to memory, each the 9th of 8 bytes 9 is left in the basket in the register.
			0010	.16	From 16 bytes of register-stored to memory, each the 9th of 16 bytes 9 is left in the basket in the register.
0011	.32	From 32 bytes of register-stored to memory, each the 9th of 32 bytes 9 is left in the basket in the register.
			1000	Undefined
1001	Undefined
			1010	Undefined
1011	.64	From 64 bytes of register-stored to memory, each the 9th of 64 bytes 9 is left in the basket in the register.

Position B is used for pointing out 64 byte vector operations, because there is not the concept of current group and alternate sets in the VEC64 pattern.The REAI formUsed by loading, storage and cache operations instruction, E.20 table has shown the meaning of each field under the REAI form. Show E.20:REAI form

Field	Meaning
		OPC<4：0>	Command code
B	The group identifier of Rn register. When under the VEC32 pattern, arranging, Rn＜4:0〉be illustrated in the alternate sets vector registor number; When under the VEC64 pattern, arranging, expression omnidirectional's amount (64 byte) operation.
		D	Purpose/source scalar register. When arranging, Rn＜4:0〉expression one scalar register. The legal value of B:D coding is under the VEC32 pattern:

	00 Rn be current group vector registor 01 Rn be scalar register (in current group) 10 Rn be the vector registor 11 of alternate sets undefined under the VEC64 pattern the legal values of B:D coding be: 00 only 4,8,16 or 32 bytes in vector registor Rn to be used 01 Rn be that whole 64 bytes are used 11 undefined among the scalar register 10 vector registor Rn
		TT<1：0>	Transmission type represents concrete loading or storage operation. See following LT and ST coding schedule.
C	High-speed cache is closed, the data cache when this being set loading with bypass. This arranges (connecting OFF to memonic symbol) with loading with the Cache-off memonic symbol of being connected instruction.
		A	The address is upgraded, and this position is set upgrades SRb with effective address. Effective address is pressed SRb+IMM＜7:0〉calculate.
Rn<4：0>	Purpose/source register number
		SRb<4：0>	Scalar base register number
IMM<7：0>	Immediately several side-play amounts of one 8 are by the explanation of twos complement numeral.

REAR and REAI form are used for the same-code of transmission type. To further coding details referring to the REAR form.The RRRM5 formThree registers or two registers and one 5 s' immediate operand is provided. E.21, table has defined the field of RRRM5 form. Show E.21:RRRM5 form

Field	Meaning
		OP<4：0>	Command code
D	The purpose scalar register. When arranging, Rd＜4:1〉the indication scalar register; When removing, Rd＜4:0〉the indication vector registor.
		S	Scalar Rb register. When arranging, point out Rb＜4:0〉be scalar register; When removing, Rb＜4:0〉be vector registor.
SD<1：0>	Data width, it is encoded to: 00 byte (being used for the int8 data type), 01 byte 9 (being used for the int9 data type), 10 half-words (being used for the int16 data type), 11 words (being used for int32 or floating type)
		M	The modification symbol of D:S position sees below the D:S:M coding schedule.
Rd<4：0>	Target D register number
		Ra<4：0>	Source A-register number
Rb＜4:0〉or IM5＜4:0	Source B-register number or 5 count immediately, depend on the D:S:M coding, and 5 immediately number is regarded unsigned numbers as.

Position 19:15 keeps and is necessary for zero, with the compatibility of guaranteeing will expand in the future.

All the operand of vector registors refers to current group (both 0 group also 1 group) unless do in addition statement. E.22, table is listed as DS＜1:0〉D:S:M when being 00,01 or 10 coding. E.22:DS, table is not equal to the D:S:M coding of 11 o'clock RRRM5

Coding	Rd	Ra	Rb/IM5	Note
					000	VRd	VRa	VRb	Three vector registor operands
001				Undefined
					010	VRd	VRa	SRb	The B operand is scalar register
011	VRd	VRa	IM5	The B operand is 5 counting immediately
					100				Undefined
101				Undefined
					110	SRd	SRa	SRb	Three scalar register operands
111	SRd	SRa	IM5	The B operand is 5 counting immediately

As DS＜1:0〉meaning below D:S:M coding has when being 11: when E.23:DS table equals 11, the D:S:M of RRRM5 coding

D：S：M	Rd	Ra	Rb/IM5	Note
					000	VRd	VRa	VRb	Three vector registor operands (int32)
001	VRd	VRa	VRb	Three vector registor operands (float)
					010	VRd	VRa	SRb	The B operand is a scalar register (int32)
011	VRd	VRa	IM5	The B operand is 5 count immediately (int32)
					100	VRd	VRa	SRb	The B operand is a scalar register (float)
101	SRb	SRa	SRb	Three scalar register operands (float)
					110	SRd	SRa	SRb	Three scalar register operands (int32)
111	SRd	SRa	IM5	The B operand is 5 count immediately (int32)

The RRRR formFour kinds of register manipulation numbers are provided, and E.24 table has shown the field under the RRRR form. Show E.24:RRRR form

Field	Meaning
		Op<4：0>	Command code
S	Scalar Rb register. When arranging, point out Rb＜4:0〉be a scalar register; When removing, Rb＜4:0〉be a vector registor.
		DS<1：0>	Data length, it is encoded to: 00 byte (being used for the int8 data type), 01 byte 9 (being used for the int9 data type), 10 half-words (being used for the int16 data type), 11 words (being used for the int32 data type)
Rc<4：0>	Source/destination C register number
		Rd<4：0>	Purpose D register number
Ra<4：0>	Source A-register number
		Rb<4：0>	Source B-register number

All the vector registor operand refers to current group (both can be 0 group and also can be 1 group), unless do in addition statement.The RI formOnly count immediately the instruction use by loading. E.25, table indicates the field under the RI form. Show E.25:RI form

Field	Meaning
		D	The purpose scalar register. When arranging, Rd＜4:0〉expression one scalar register; When removing, Rd＜4:0〉vector registor in current group of the expression.
F	Floating type. When arranging, be indicated as floating type, and require DS＜1:0 be 11.
		DS<1：0>	Data length, it is encoded to: 00 byte (being used for the int8 data type), 01 byte 9 (being used for the int9 data type), 10 half-words (being used for the int16 data type)

	11 words (being used for int32 or floating type)
		Rd<4：0>	Purpose D register number
IMM<18：0>	One 19 immediately numerical value

Field F:DS＜1:0〉some coding undefined. Programmer should be encoded without these, because this structure is given the anticipated consequence when settled use is this encodes. The value that is loaded into Rd depends on the type of data, shown in showing E.26. Show the loaded value under the form E.26:RI

Form	Data type	The register manipulation number
			.b	Byte (8)	Rd<7：0>：＝Imm<7：0>
.b9	Byte (9)	Rd<8：0>：＝Imm<8：0>
			.h	Half-word (16)	Rd<15：0>：Imm<15：0>
.w	Word (32)	Rd＜31:0 〉: the IMM＜18:0 of=sign extended 〉
			.f	Floating-point (32)	Rd＜31〉:=Imm＜18〉(symbol) Rd＜30:23〉:=Imm＜17:0〉(index) Rd＜22:13 〉: Imm＜9:0〉(mantissa) Rd＜12:0〉:=0

The CT formE.27 the field that comprises is shown in table. Show E.27:CT form

Field	Meaning
		Opc<3：0>	Command code
Cond<2：0>	Jump condition: 000 unconditional 001 equals 011 less than 010 is less than or equal to 100 and is not equal to 110 greater than 101 and overflows more than or equal to 111
		IMM<22：0>	23 immediately digimigration amount is pressed the twos complement number explanation.

Jump condition is used VCSR[GT:EQ:LT] field. Overflow condition uses VCSR[SO] position, when arranging, it has precedence over GT, EQ and LT position. VCCS and VCBARR are then to be different from the above said Cond of explanation＜2:0〉field, with reference to its instruction details.

The RRRM9 formIndicate three registers or two registers and one 9 s' immediate operand. E.28, table provides the field of RRRM9 form. Show E.28:RRRM9 form

Field	Meaning
		Opc<5：0>	Command code
D	The purpose scalar register. When arranging, Rd＜4:0〉expression one scalar register; When removing, Rd＜4:0〉expression one vector registor.
		S	Scalar Rb register. Indication Rb＜4:0 when arranging〉be a scalar register; When removing, Rb＜4:0〉be a vector registor.
DS<1：0>	Data width, it is encoded to: 00 byte (being used for the int8 data type), 01 byte 9 (being used for the int9 data type), 10 half-words (being used for the int16 data type)

	11 words (being used for int32 or floating type)
		M	To the modification symbol of D:S position, the D:S:M coding schedule that sees below.
Rd<4：0>	Destination register number
		Ra<4：0>	Source A-register number
Rb＜4:0〉or IM5＜4:0	Source B-register number or one 5 count immediately, depend on the D:S:M coding.
		IM9<3：0>	With IM5＜4:0〉provide one 9 to count immediately, depend on the D:S:M coding.

19:15 position, position is retained, and does not specify an immediate operand when D:S:M encodes, and is necessary for 0 to guarantee compatibility in the future.

All the vector registor operands refer to current group (both 0 group also can be 1 group) unless do in addition statement. D:S:M coding with the table of RRRM5 form E.22 with E.23 shown in those be identical, except according to DS＜1:0〉coding from the immediately number that digital section extracts immediately, see Table E.29 shown in. Show the E.29:RRRM9 immediately numerical value of form

DS	The data type of coupling	The B operand
			00	int8	Source B<7：0>：＝IM9<2：0>：IM5<4： 0>
01	int9	Source B<8：0>：＝IM9<3：0>：IM5<4： 0>
			10	int16	Source B<15：0>：＝sex(IM9<3：0>：IM5<4： 0>)
11	int32	Source B<31：0>：＝sex(IM9<3：0>：IM5<4： 0>)

Floating type can not obtain immediately number format.

The below is the MSP vector instruction of arranging by alphanumeric. Attention: 1. unless otherwise noted, instruction is the impact that is subjected to the element shielding. The CT format order is not subjected to the element screening effect. The REAR and the REAI format order that are comprised of loading, storage and high-speed cache instruction are not subjected to the element screening effect yet. 2. can not obtain 9 immediate operand under the floating type. 3. in operating instruction, only provided vector form. To the scalar operation, suppose and only have one that namely the 0th element is defined. 4. to RRRM5 and RRRM9 form, following coding is used for integer data type (b, b9, h, w):

D：S：M	000	010	011	110	111
						DS	00	01	10	11

5. to RRRM5 and RRRM9 form, following coding is used for floating type:

D：S：M	001	100	n/a	101	n/a
						DS					11

6. for all causing the instruction of overflowing, as VCSR＜ISAT〉when the position was set up, the maximum or the minimum limit that are saturated to int8, int9, int16, int32 were used. Correspondingly, as VCSR＜FSAT〉when the position arranged, floating point result was saturated to-infinitely great ,-0 ,+0 or+infinity. 7. by syntactic rule .n can be used for replacing .b9 with expression byte 9 data lengths. 8. to whole instructions, turn back to destination register or be the IEEE754 single-precision format to the floating point result of vectorial accumulator. Floating point result write accumulator than lower part, high-order portion does not change.VAAS3 adds and adds (1,0,1) symbolForm

The assembler syntax

VAAS3.dt VRd，VRa，VRb

VAAS3.dt VRd，VRa，SRb

VAAS3.dt SRd，SRa，SRb

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M	V＜-V＠V	V＜-V＠S		S＜-S＠S
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

The content of vector/scalar register Ra is added to Rb to produce an intermediate object program, and this intermediate object program is the symbol of affix Ra again; And final result is stored among the vector/scalar register Rd. Operation

    for(i＝0；i＜NumElem && EMASK[i]；i++){

        if(Ra[i]＞0)    extsgn3＝1；

        elseif(Ra[i]＜0)extsgn3＝-1；

        else            extsgn3＝0；

        Rd[i]＝Ra[i]+Rb[i]+extsgn3；

Unusual

Overflow.VADAC adds and adds upFormThe assembler syntax

VADAC.dt VRc，VRd，VRa，VRb

VADAC.dt SRc，SRd，SRa，SRb

Dt={b wherein, b9, h, w}. The pattern of supporting

S	VR	SR
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

With each double precision element addition of each element and the vectorial accumulator of Ra and Rb operand, with the double precision of each element with store vectorial accumulator and destination register Ra and Rd into. Ra and Rb use the data type of appointment, and VAC uses suitable double precision datum type (16,18,32 and 64 the corresponding int8 of difference, int9, int16 and int32). The higher memory of each double precision element is at VACH and Rc. If Rc=Rd, the result among the Rc is undefined. Operation

     for(i＝0；i＜NumElem && EMASK[i]；i++){

         Aop[i]＝{VRa[i]‖SRa}；

         Bop[i]＝{VRb[i]‖SRb}；

         VACH[i]：VACL[i]＝sex(Aop[i]+Bop[i])+ VACH[i]：VACL[i]；

         Rc[i]＝VACH[i]；

         Rd[i]＝VACL[i]；

     } VADACL adds and the low level that adds upFormThe assembler syntax

VADACL.dt VRd，VRa，VRb

VADACL.dt VRd，VRa，SRb

VADACL.dt VRd，VRa，#IMM

VADACL.dt SRd，SRa，SRb

VADACL.dt SRd，SRa，#IMM

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

With each extended precision element addition of each element and the vectorial accumulator of Ra and Rb/ immediate operand, with extended precision and deposit vectorial accumulator in; Lower accuracy is turned back to destination register Rd. Ra and Rb/ immediately number use the data types of appointments, and VAC is with suitable double precision datum type (16,18,32 and 64 the corresponding int8 of difference, int9, int16 and int32). The higher memory of each extended precision element is in VACH. Operation

    for(i＝0；i＜NumElem && EMASK[i]；i++){

        Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

        VACH[i]：VACL[i]＝sex(Ra[i]+Bop[i])+VACH[i]：VACL[i]；

        Rd[i]＝VACL[i]；

    } VADD addsForm

The assembler syntax

VADD.dt VRd，VRa，VRb

VADD.dt VRd，VRa，SRb

VADD.dt VRd，VRa，#IMM

VADD.dt SRd，SRa，SRb

VADD.dt SRd，SRa，#IMM

Dt={b wherein, b9, h, w, f}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)	float(f)

Explanation

Add Ra and Rb/ immediate operand, and with it with turn back to destination register Rd. Operation

         for(i＝0；i＜NumElem && EMASK[i]；i++){

             Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

             Rd[i]＝Ra[i]+Bop[i]；

Unusual

Overflow, floating-point invalid operation number.VADDH adds two adjacent elementsForm

The assembler syntax

VADDH.dt VRd，VRa，VRb

VADDH.dt VRd，VRa，SRb

Dt={b wherein, b9, h, w, f}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S
						DS	int8(b)	int9(b9)	int16(h)	int32(w)	float(f)

Explanation

Operation

          for(i＝0；i＜NumElem-1；i++){

              Rd[i]＝Ra[i]+Ra[i+1]；

          }

Rd{NumElem-1]=Ra[NumElem-1]+VRb[0] ‖ SRb}; Unusually

Overflow, floating-point invalid operation number. Programming is explained

This instruction is not subjected to the element screening effect.VAND withFormThe assembler syntax

VAND.dt VRd，VRa，VRb

VAND.dt VRd，VRa，SRb

VAND.dt VRd，VRa，#IMM

VAND.dt SRd，SRa，SRb

VAND.dt SRd，SRa，#IMM

Dt={b wherein, b9, h, w}. Notice that .w specifies identical operation with .f. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Ra and Rb/ immediate operand are carried out logical AND, and the result is turned back to destination register Rd. Operation

         for(i＝0；i＜NumElem && EMASK[i]；i++){

             Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

             Rd[i]<k>＝Ra[i]<k>&Bop[i]<k>，k＝for all bits in element i：

Unusual

Nothing.VANDC and complement codeForm

The assembler syntax

VANDC.dt VRd，VRa，VRb

VANDC.dt VRd，VRa，SRb

VANDC.dt VRd，VRa，#IMM

VANDC.dt SRd，SRa，SRb

VANDC.dt SRd，SRa，#IMM

Dt={b wherein, b9, h, w}. Notice that .w and .f specify same operation. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Complement code to Ra and Rb/ immediate operand is carried out logical AND, and the result is turned back to destination register Rd. Operation

    for(i＝0；i＜NumElem&&EMASK[i]；i++){

        Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

        Rd[i]<k>＝Ra[i]<k>&-Bop[i]<k>，k＝for all bits in element i：

Unusual

Nothing.VASA accumulator arithmetic shiftFormThe assembler syntax

VASAL.dt

VASAR.dt

Dt={b wherein, b9, h, w}, and R points out to the left or to the right direction of displacement. The pattern of supporting

R	left	right
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Each data element bit position that moves to left of vector accumulator registers, and from right-hand member with zero padding (if R=0), the perhaps tape symbol expansion bit position (if R=1) that moves to right. Its result store is in vectorial accumulator. Operation

     for(i＝0；i＜NumElem && EMASK[i]；i++){

         if(R＝1)

             VAC0H[i]：VAC0L[i]＝VAC0H[i]：VAC0L[i]sign＞＞1；

         else

             VAC0H[i]：VAC0L[i]＝VAC0H[i]：VAC0L[i]＜＜1；

Unusual

Overflow.The VASL arithmetic shift leftFormThe assembler syntax

VASL.dt VRd，VRa，SRb

VASL.dt VRd，VRa，#IMM

VASL.dt SRd，SRa，SRb

VASL.dt SRd，SRa，#IMM

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M		V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Each data element of vector/scalar register Ra moves to left, and with zero padding, shift amount is provided by scalar register Rb or IMM field from right-hand member, and its result leaves among the vector/scalar register Rd. To causing those elements that overflow, its result comprises according to its symbol and arrives positive peak or negative peak. Shift amount is defined as signless integer. Operation

      shift_amount＝{SRb％32‖IMM<4：0>}；

      for(i＝0；i＜NumElem && EMASK[i]；i++){

          Rd[i]＝saturate(Ra[i]＜＜shift_amount)；

Unusual

Nothing. Programming is explained

Notice that shift_amount is from SRb or IMM＜4:0〉5 figure places that obtain. To byte, byte9, halfword data type, programmer are responsible for the correct shift amount of specifying, and this shift amount is less than or equal to the figure place of data length. If shift amount is greater than the data length of appointment, element will be filled by zero.The VASR arithmetic shift rightForm

The assembler syntax

VASR.dt VRd，VRa，SRb

VASR.dt VRd，VRa，#IMM

VASR.dt SRd，SRa，SRb

VASR.dt SRd，SRa，#IMM

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M		V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Each data element of vector/scalar register Ra is by arithmetic shift right, and there is sign extended the highest significant position position, and shift amount provides in the least significant bit of scalar register Rb or IMM field, and its result store is in vector/scalar register Rd. Shift amount is defined as signless integer. Operation

    shift_amount＝[SRb ％32‖IMM<4：0>}；

    for(i＝0；i＜NumElem && EMASK[i]；i++){

        Rd[i]＝Ra[i]sign＞＞shift_amount；

Unusual

Nothing. Programming is explained

Notice that shift_amount is from SRb or IMM＜4:0〉5 figure places that obtain. For byte, byte9, halfword data type, programmer are responsible for correctly specifying shift amount, and this shift amount is less than or equal to the figure place of data length. If shift amount is greater than the data length of appointment, element will be filled by sign bit.VASS3 adds and subtracts (1,0,1) symbolForm

The assembler syntax

VASS3.dt VRd，VRa，VRb

VASS3.dt VRd，VRa，SRb

VASS3.dt SRd，SRa，SRb

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S		S＜-S@S
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

The content of vector/scalar register Ra is added to Rb to produce an intermediate object program, and then from then on the symbol with Ra removes in the intermediate object program; Final result is stored among the vector/scalar register Rd. Operation

    for(i＝0；i＜NumElem && EMASK[i]；i++){

        if(Ra[i]＞0)    extsgn3＝1；

        elseif(Ra[i]＜0)extsgn3＝-1；

        else            extsgn3＝0；

        Rd[i]＝Ra[i]+Rb[i]-extsgn3； 

Unusual

Overflow.The absolute value of VASUB reducingForm

The assembler syntax

VASUB.dt VRd，VRa，VRb

VASUB.dt VRd，VRa，SRb

VASUB.dt VRd，VRa，#IMM

VASUB.dt SRd，SRa，SRb

VASUB.dt SRd，SRa，#IMM

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)	float(f)

Explanation

The content of vector/scalar register Rb or IMM field deducts from the content of vector/scalar register Ra, and its absolute value result store is in vector/scalar register Rd. Operation

    for(i＝0；i＜NumElem && EMASK[i]；i++){

        Bop[i]＝{Rb[i]‖SRb‖sex(IMM<8：0>)}；

        Rd[i]＝|Ra[i]-Bop[i]|；

Unusual

Overflow floating-point invalid operation number. Programming is explained

If the result who subtracts is maximum negative, then after absolute value operation, will overflow. If the permission saturation mode, this result who takes absolute value operation will be maximum positive.VAVG two elements are averageForm

The assembler syntax

VAVG.dt VRd，VRa，VRb

VAVG.dt VRd，VRa，SRb

VAVG.dt SRd，SRa，SRb

Dt={b wherein, b9, h, w, f}. Use VAVGT to specify " blocking " rounding mode to the integer data type. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S		S＜-S@S
						DS	int8(b)	int9(b9)	int16(h)	int32(w)	float(f)

Explanation

The content of vector/scalar register Ra is added on the content of vector/scalar register Rb to produce an intermediate object program; Then intermediate object program is removed by 2, and final result is stored among the vector/scalar register Rd. To the integer data type, if the T=1 rounding mode is to block, and if T=0 (default) then casts out zero. To floating type, rounding mode is by VCSR＜RMODE〉specify. Operation

     for(i＝0；i＜NumElem && EMASK[i]：i++){

         Bop[i]＝{Rb[i]‖SRb‖sex(IMM<8：0>)}：

         Rd[i]＝(Ra[i]+Bop[i]//2；

Unusual

Nothing.VAVGH two adjacent elements are averageFormThe assembler syntax

VAVGH.dt VRd，VRa，VRb

VAVGH.dt VRd，VRa，SRb

Dt={b wherein, b9, h, w, f}. Use VAVGHT to specify " blocking " rounding mode to the integer data type. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S
						DS	int8(b)	int9(b9)	int16(h)	int32(w)	float(f)

Explanation

For each element, average two adjacent elements pair. To the integer data type, if T=1, rounding mode is to block, and then is to cast out zero to T=0 (default). To floating type, rounding mode is by VCSR＜RMODE〉specify.

Operation

         for(i＝0；i＜NumElem-1；i++){

             Rd[i]＝(Ra[i]+Ra[i+1])//2；

         }

Rd[NumElem-1]=(Ra[NumElem-1]+[VRb[0] ‖ SRb]) // 2; Unusually

Nothing. Programming is explained

This instruction is not subjected to the element screening effect.VAVGQ Siping City is equalForm

The assembler syntax

VAVGQ.dt VRd，VRa，VRb

Dt={b wherein, b9, h, w}. Use VAVGQT with indication " blocking " rounding mode to the integer data type. The pattern of supporting

D：S：M	V＜-V@V
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Under the VEC64 pattern, do not support this instruction.

As shown below, adopt by the truncated mode (1 for blocking, and 0 for casting out zero, default) of T appointment and calculate the average of 4 elements. Note leftmost element (D_n-1) undefined.

Operation

          for(i＝0；i＜NumElem-1；i++){

Rd[i]=(Ra[i]+Rb[i]+Ra[i+1]+Rb[i+1]) // 4; Unusual

Nothing.VCACHE Cache operationFormThe assembler syntax

VCACHE.fc SRd，SRi

VCACHE.fc SRb，#IMM

VCACHE.fc SRb+，SRi

VCACHE.fc SRb+，#IMM

Fc={0 wherein, 1}. Explanation

This instruction is for the software administration of vectorial Data Cache. Dispose the scratchpad memory when the part or all of quilt of Data Cache resembles, this instruction on scratchpad memory without impact. Support the following option:

FC<2：0>	Meaning
		000	Write-back and make its label and the Cache of the change of EA coupling capable invalid. If matching row comprises the data of not changing, then make the invalid and write-back not of this journey. If find not have the capable EA of comprising of Cache, then the Data Cache reservation is not touched.
001	Write-back and make by the Cache of the change of the index appointment of EA capable invalid. If matching row comprises the data of not changing, make the invalid and write-back not of this journey.
		Other	Undefined

Operation exception

Nothing. Programming is explained

This instruction is not subjected to the element screening effect.The VCAND complement code withForm

The assembler syntax

VCAND.dt VRd，VRa，VRb

VCAND.dt VRd，VRa，SRb

VCAND.dt VRd，VRa，#IMM

VCAND.dt SRd，SRa，SRb

VCAND.dt SRd，SRa，#IMM

Dt=(b, b9, h, w) wherein. Notice that .w and .f indicate same operation. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Complement code to Ra and Rb/ immediate operand is carried out logical AND, and its result is turned back to destination register Rd. Operation

     for(i＝0；i＜NumElem && EMASK[i]；i++){

         Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

         Rd[i]<k>＝-Ra[i]<k>&Bop[i]<k>，k＝for all bits in element i；

Unusual

Nothing.VCBARR condition barrierFormAssembler syntax VCBARR.cond is cond={0-7} wherein. Each condition will provide memonic symbol in the back. Explanation

As long as this condition remains valid, delay this instruction and all instructions of back (appear at agenda back those). Cond＜2:0〉explanation of field is different from other conditional order under the CT form.

The following condition of current definition:

Cond<2：0>	Meaning
		000	Before any instruction after carrying out, the whole previous instructions of wait (early occurring in the agenda) are to finish execution.
Other	Undefined

Operation

while(Cond＝true)

Stall all later instructoins; Unusually

Nothing. Programming is explained

This instruction is carried out for software provides with the consecutive of imperative instruction. This instruction can be used to force the indefinite anomalous event of accurate report. For example, if this instruction is used in after the arithmetic instruction that can cause anomalous event immediately, then this anomalous event will be with the program counter report to this instruction addressing.VCBR conditional jumpForm

The assembler syntax

VCBR.cond  # Offset

Cond={un wherein, lt, eq, le, gt, ne, ge, ov}. Explanation

If Cond is true, then shift, this is not Branch-delay. Operation

If((Cond＝VCSR[SO，GT，EQ，LT])|(Cond＝un))

    VPC＝VPC+sex(Offset<22：0>*4)；

ElseVPC=VPC+4; Unusually

Invalid IA.The indirect conditional jump of VCBRIForm

The assembler syntax

VCBRI.cond SRb

Cond={un wherein, lt, eq, le, gt, ne, ge, ov}. Explanation

If Cond is true, then indirect branch. This is not Branch-delay. Operation

If((Cond＝VCSR[SO，GT，EQ，LT])|(Cond＝un))

    VPC＝SRb<31：2>：b’00；

ElseVPC=VPC+4; Unusually

Invalid IA.The on-the-spot conversion of VCCS conditionForm

The assembler syntax

VCCS # Offset explanation

If VIMSK＜cse〉be true, then jump to on-the-spot conversion routine. This is not Branch-delay.

If VIMSK＜cse〉be true, then VPC+4 (return address) is saved in the return address storehouse. If non-true, continue to carry out from VPC+4. Operation

             If(VIMSK＜cse＞＝1){

                if(VSP＜4＞＞15){

　　                VISRC＜RASO＞＝1；

　　                signal ARM7 with RASO exception；

　　                VP_STATE＝VP_IDLE；

　　           }else{

　　                RSTACK[VSP＜3：0＞]＝VPC+4；

　　                VSP＜4：0＞＝VSP＜4：0＞+1；

　　                VPC＝VPC+sex(Offset＜22：0＞*4)；

　　           }

　　         }else VPC＝VPC+4；

Unusually

The return address stack overflow.VCHGCR changes control registerForm

The assembler syntax

VCHGCR Mode explanation

This instruction changes the operator scheme of vector processor

Every appointment is as follows among the Mode:

Mode	Meaning
		bit1：0	These two control VCSR＜CBANK〉position. Coding is specified: 00-does not change 01-and removes VCSR＜CBANK〉a position 10-arranges VCSR＜CBANK〉position 11-triggers VCSR＜CBANK〉position
bits3：2	These two control VCSR＜SMM〉position. Coding is specified: 00-does not change 01-and removes VCSR＜SMM〉a position 10-arranges VCSR＜SMM〉position 11-triggers VCSR＜SMM〉position
		bit5：4	These two control VCSR＜CEM〉position. Coding is specified: 00-does not change 01-and removes VCSR＜CEM〉a position 10-arranges VCSR＜CEM〉position 11-triggers VCSR＜CEM〉position
Other	Undefined

Operation exception

Nothing. Programming is explained

This instruction provides for hardware, to change the control bit among the VCSR than the more efficiently mode of VMOV instruction.The VCINT condition is interrupted ARM7FormThe assembler syntax

VCINT.cond  # ICODE

Cond={un wherein, lt, eq, le, gt, ne, ge, ov}. Explanation

If Cond is true, when allowing, stop to carry out and interrupting ARM7. Operation

   If((Cond＝VCSR[SO，GT，EQ，LT])|(Cond＝un)){

       VISRC<vip>＝1；

       VIINS＝[VCINT.cond #ICODE instruction]；

       VEPC＝VPC；

       if(VIMSK<vie>＝1)signal ARM7 interrupt；

       VP_STATE＝VP_IDLE；

   }

Else VPC=VPC+4; Unusually

VCINT interrupts.VCJOIN connects with the ARM7 task conditionForm

The assembler syntax

VCJOIN.cond  # Offset

Cond={un wherein, lt, eq, le, gt, ne, ge, ov}. Explanation

If Cond is true, when allowing, stop to carry out and interrupting ARM7. Operation

    If((Cond＝VCSR[SO，GT，EQ，LT])|(Cond＝un)){

        VISRC<vjp>＝-1；

        VIINS＝[VCJOIN.cond #Offset instruction]；

        VEPC＝VPC：

        if(VIMSK<vje>＝1)signal ARM7 interrupt；

        VP_STATE＝VP_IDLE；

    }

Else VPC=VPC+4; Unusually

VCJOIN interrupts.The VCJSR conditional jump is to subprogramForm

The assembler syntax

VCJSR.cond  # Offset

Cond={un wherein, lt, eq, le, gt, ne, ge, ov}. Explanation

If Cond is true, then jump to subprogram. This is not Branch-delay.

If Cond is true, VPC+4 (return address) is saved in the return address storehouse. If non-true, then continue to carry out from VPC+4. Operation

　　    If((Cond＝VCSR[SO，GT，EQ，LT])|(Cond＝un)){

　　        if(VSP＜4＞＞15){

　　            VISRC＜RASO＞＝1；

　　            signal ARM7 with RASO exception；

　　            VP STATE＝VP_IDLE；

　　        }else{

　　            RSTACK[VSP＜3：0＞]＝VPC+4；

　　            VSP＜4：0＞＝VSP＜4：0＞+1；

　　            VPC＝VPC+sex(Offset＜22：0＞*4)；

　　    }

　　}else VPC＝VPC+4；

Unusually

The return address stack overflow.The indirect conditional jump of VCJSRI is to subprogramForm

The assembler syntax

VCJSRI.cond SRb

Cond={un wherein, lt, eq, le, gt, ne, ge, ov}. Explanation

If Cond is true, then indirectly jump to subprogram. This is not Branch-delay.

If Cond is true, then VPC+4 (return address) is saved in the return address storehouse. If non-true, continue to carry out from VPC+4. Operation

   If((Cond＝VCSR[SO，GT，EQ，LT])|(Cond＝un)){

           if(VSP＜4：0＞15){

               VISRC＜RASO＞＝1；

               signal ARM7 with RASO exception；

               VP_STATE＝VP_IDLE；

           }else{

               RSTACK[VSP＜3：0＞]＝VPC+4；

               VSP＜4：0＞＝VSP＜4：0＞+1；

               VPC＝SRb＜31：2>：b’00；

           }

       }else VPC＝VPC+4；

Unusually

The return address stack overflow.VCMOV conditional jumpForm

The assembler syntax

VCMOV.dt Rd，Rb，cond

VCMOV.dt Rd，# IMM，cond

Dt={b wherein, b9, h, w, f}, cond={un, lt, eq, le, gt, ne, ge, ov}. Notice that .f specifies identical operation with .w, unless the .f data type is not supported 9 immediate operand. The pattern of supporting

D：S：M	V＜-V	V＜-S	V＜-I	S＜-S	S＜-I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

If Cond is true, the transfer of content of register Rb is to register Rd. ID＜1:0〉further assigned source and destination register:

Current group of vector registor of VR

The SR scalar register

The SY SYN register

VAC vector accumulator registers (VAC register coding is illustrated with reference to VMOV)

D：S：M	ID<1：0>＝00	ID<1：0>＝01	ID<1：0>＝10	ID<1：0>＝11
					V＜-V	VR＜-VR	VR＜-VAC	VAC＜-VR
V＜-S	VR＜-SR		VAC＜-SR
					V＜-I	VR＜-I
S＜-S	SR＜-SR
					S＜-I	SR＜-I

Operation

If((Cond＝VCSR[SOV，GT，EQ，LT])|(Cond＝un))

    for(i＝0；i＜NumElem；i++)

Rd[i]=Rb[i] ‖ SRb ‖ sex (IMM＜8:0 〉) }; Unusually

Nothing. Programming is explained

This instruction is not subjected to the impact of element shielding, and VCMOVM is subjected to the element screening effect.

To 8 elements, the expression of expansion floating point precision has been used whole 576 in the vectorial accumulator. Thereby, comprise that the transfer of the vector registor of accumulator must be specified the .b9 data length.VCMOVM is with the conditional jump of element shieldingFormThe assembler syntax

VCMOVM.dt Rd，Rb，cond

VCMOVM.dt Rd，# IMM，cond

Dt={b wherein, b9, h, w, f}, cond={un, lt, eq, le, gt, ne, ge, ov}. Notice that .f specifies identical operation with .w, unless the .f data type is not supported 9 immediate operand. The pattern of supporting

D：S：M	V＜-V	V＜-S	V＜-I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

If Cond is true, then the transfer of content of register Rb is to register Rd. ID＜1:0〉further assigned source and destination register:

Current group of vector registor of VR

The SR scalar register

VAC vector accumulator registers (VAC register coding is illustrated with reference to VMOV)

D：S：M	ID<1：0>＝00	ID<1：0>＝01	ID<1：0>＝10	ID<1：0>＝11
					V＜-V	VR＜-VR	VR＜-VAC	VAC＜-VR
V＜-S	VR＜-SR		VAC＜-SR
					V＜-I	V＜-I
S＜-S
					S＜-I

Operation

If((Cond＝VCSR[SO，GT，EQ，LT])|(Cond＝un))

    for(i＝0；i＜NumElem && MMASK[i]；i++)

Rd[i]=Rb[i] ‖ SRb ‖ sex (IMM＜8:0 〉) }; Unusually

Nothing. Programming is explained

This instruction is subjected to the impact of VMMR element shielding, and VCMOV is not subjected to the element screening effect.

To 8 elements, the expression of expansion floating point precision is used whole 576 in vectorial accumulator. Thereby, comprise that the transfer of the vector registor of accumulator must be specified the .b9 data length.VCMPV relatively and shielding is setForm

The assembler syntax

VCMPV.dt VRa，VRb，cond，mask

VCMPV.dt VRa，SRb，cond，mask

Dt={b wherein, b9, h, w, f}, cond={lt, eq, le, gt, ne, ge,, mask={VGMR, VMMR}. Do not shield if specify, then VGMR is assumed to be. The pattern of supporting

D：S：M	M＜-V@V	M＜-V@S
						DS	int8(b)	int9(b9)	int16(h)	int32(w)	float(f)

Explanation

The content of vector registor VRa and VRb is carried out the comparison of element mode by carrying out subtraction operation (VRa[i]-VRb[i]), if result relatively and the Cond field of VCMPV instruction are complementary, then the #i position of phase place is set up in VGMR (such as K=0) or VMMR (such as the K=1) register. For example, if the Cond field is less than (LT), then as VRa[i]＜VRb[i] time VGMR[i is set] (or VMMR[i]) position. Operation

        for(i＝0；i＜NumElem；i++){

            Bop[i]＝{Rb[i]‖SRb‖sex(IMM<8：0>)}；

            relationship[i]＝Ra[i]？Bop[i]；

            if(K＝i)

                MMASK[i]＝(relationship[i]＝Cond)？True：False；

            else

                EMASK[i]＝(relationship[i]＝Cond)？True：False；

Unusual

Nothing. Programming is explained

This instruction is not subjected to the impact of element shielding.The counting of VCNTLZ leading zeroFormThe assembler syntax

VCNTLZ.dt VRd，VRb

VCNTLZ.dt SRd，SRb

Dt={b wherein, b9, h, w}. The pattern of supporting

S	V＜-V	S＜-S
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Each element among the Rb is carried out the counting of leading zero number; Count value is turned back among the Rd. Operation

      for(i＝0；i＜NumElem && EMASK[i]；i++){

          Rd[i]＝number of leading zeroes(Rb[i])；

Unusual

Nothing. Programming is explained

If whole positions are zero in the element, then the result equals the length (8,9,16 or 32 difference corresponding byte, byte9, halfword or word) of element.

The counting of leading zero has opposite relation (if being used in VCMPR instruction back) with the element position index. For being transformed into element position, to given data type, deduct the result of VCNTLZ from NumElem.VCOR or complement codeForm

The 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

Dt={b wherein, b9, h, w}. Notice that .w specifies identical operation with .f. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Complement code to Ra and Rb/ immediate operand is made logic OR, and the result is turned back to destination register Rd. Operation

  for(i＝0；i＜NumElem && EMASK[i]；i++){

      Bop[i]＝[VRb[i]‖SRb‖sex(IMM<8：0>)]；

      Rd[i]<k>＝-Ra[i]<k>|Bop[i]<k>，k＝for all bits in element i；

Unusual

Nothing.VCRSR returns from the subprogram conditionForm

The assembler syntax

VCRSR.cond

Cond={un wherein, lt, eq, le, gt, ne, ge, ov}. Explanation

If Cond is true, then return from sub-journey. This is not Branch-delay

If Cond is true, then the return address from be kept at the return address storehouse continues to carry out. If non-true, then continue to carry out from VPC+4. Operation

    If((Cond＝VCSR[SO，GT，EQ，LT])|(Cond＝un)){

            if(VSP＜4：0＞＝0){

                VISRC＜RASU＞＝1；

                signal ARM7 with RASU exception；

                VP_STATE＝VP_IDLE；

        }else{

                VSP＜4：0＞＝VSP＜4：0＞-1；

                VPC＝RSTACK[VSP＜3：0＞]；

                VPC＜1：0＞＝b’00；

        }

    }else VPC＝VPC+4；

Unusually

Invalid IA, the return address stack underflow.The conversion of VCVTB9 byte9 data typeForm

The assembler syntax

VCVTB9.md VRd，VRb

VCVTB9.md SRd，SRb

Md={bb9 wherein, b9h, hb9}. Support mode

S	V＜-V	S＜-S
					MD	bb9		b9h	hb9

Explanation

Each element among the Rb is transformed into byte9 (bb9) from byte, is transformed into halfword (b9h) or is transformed into byte9 (hb9) from halfword from byte9. Operation

    if(md<1：0>＝0){         //bb9 for byte to byte9 conversion

        VRd＝VRb；

        VRd<9i+8>＝VRb<9i+7>，i＝0 to 31(or 63 in VEC64 mode)}

    else if(md<1：0>＝2){    //b9h for byte9 to halfword conversion

        VRd＝VRb；

        VRd<18i+16：18i+9>＝VRb<18i+8>，i＝0 to 15(or 31 in VEC64 mode)}

    else if(md<1：0>＝3)    //hb9 for halfword to byte9 conversion

        VRd<18i+8>＝VRb<18i+9>，i＝0 to 15(or 31 in VEC64 mode)

Else VRd=undefined; Unusually

Nothing.

Programming is explained

Before together using this instruction with the b9h pattern, require programmer with the element number that reduces in shuffle (shuffling) the operation adjustment vector registor. Together use after this instruction with the hb9 pattern, require programmer with the element number that increases in the unshuffle operation adjustment object vector register. This instruction is not subjected to the impact of element shielding.The VCVTFF floating-point is to the conversion of fixed pointForm

The assembler syntax

VCVTFF VRd，VRa，SRb

VCVTFF VRd，VRa，#IMM

VCVTFF SRd，SRa，SRb

VCVTFF SRd, SRa, the pattern that #IMM supports

D：S：M

V＜-V，S

V＜-V，I

S＜-S，S

S＜-S，I

Explanation

The content of vector/scalar register Ra converts form＜X to, Y from 32 floating-points〉the fixed point real number, wherein the length of Y is specified by Rb (mould 32) or IMM field, and the length of X is specified by (length of 32-Y). X represents integer part, and Y represents fractional part. The result leaves among the vector/scalar register Rd. Operation

  Y_size＝{SRb％ 32‖IMM<4：0>}；

  for(i＝0；i＜NumElem；i++){

      Rd[i]＝convert to <32-Y_size.Y_size>format (Ra[i])；

Unusual

Overflow. Programming is explained

The Word data length is only supported in this instruction. Because structure does not support majority in the register according to type, the element shielding is not used in this instruction. Zero rounding procedure is cast out in this instruction of integer data type use.The VCVTIF integer is to the conversion of floating-pointFormThe assembler syntax

VCVTIF VRd，VRb

VCVTIF VRd，SRb

VCVTIF SRd, the pattern that SRb supports

D：S：M

V＜-V

V＜-S

S＜-S

Explanation

The content of vector/scalar register Rb is converted to floating type from int32, and the result leaves among the vector/scalar register Rd. Operation

   for(i＝0；i＜NumElem：i++){

       Rd[i]＝convert to floating point format(Rb[i])；

Unusual

Nothing. Programming is explained

The Word data length is only supported in this instruction. Because structure does not support majority in the register according to type, the element shielding is not used in this instruction.VD1CBR VCR1 subtracts 1 and conditional jumpFormThe assembler syntax

VD1 CBR.cond  # Offset

Cond={un wherein, lt, eq, le, gt, ne, ge, ov}. Explanation

If Cond is true, VCR1 subtracts 1 also to be shifted. This is not Branch-delay. Operation

VCR1＝VCR1-1；

If((VCR1＞0)&((Cond＝VCSR[SO，GT，EQ，LT])|(Cond＝un)))

    VPC＝VPC+sex(Offset<22：0>*4)；

Else VPC=VPC+4; Unusually

Invalid IA. Programming is explained

Notice that VCR1 subtracted 1 before jump condition is examined. When VCR1 is 0, carry out this instruction, cycle count effectively is set to 2³²-1。 VD2CBR VCR2 subtracts 1 and conditional jumpForm

The assembler syntax

VD2CBR.cond  # Offset

Cond={un wherein, lt, eq, le, gt, ne, ge, ov}. Explanation

If Cond is true, VCR2 subtracts 1 also to be shifted. This is not Branch-delay. Operation

VCR2＝VCR2-1；

If((VCR2＞0)&((Cond＝VCSR[SO，GT，EQ，LT])|(Cond＝un)))

    VPC＝VPC+sex(Offset<22：0>*4)；

Else VPC=VPC+4; Unusually

Invalid IA. Programming is explained

Notice that VCR2 subtracted 1 before jump condition is examined. When VCR2 is 0, carry out this instruction, cycle count effectively is set to 2³²-1。 VD3CBR VCR3 subtracts 1 and conditional jumpForm

The assembler syntax

VD3CBR.cond  # Offset

Cond={un wherein, lt, eq, le, gt, ne, ge, ov}. Explanation

When Cond is true, VCR3 subtracts 1 and shift. This is not Branch-delay. Operation

VCR3＝VCR3-1；

If((VCR3＞0)&((Cond＝VCSR[SO，GT，EQ，LT])|(Cond＝un)))

    VPC＝VPC+sex(Offset<22：0>*4)；

Else VPC=VPC+4; Unusually

Invalid IA. Programming is explained

Notice that VCR3 subtracted 1 before jump condition is examined. When VCR3 is 0, carry out this instruction, cycle count effectively is set to 2³²-1。 VDIV2N is by 2 ⁿ RemoveFormThe assembler syntax

VDIV2N.dt VRd，VRa，SRb

VDIV2N.dt VRd，VRa，# IMM

VDIV2N.dt SRd，SRa，SRb

VDIV2N.dt SRd，SRa，# IMM

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M		V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

The content of vector/scalar register Ra is by 2ⁿRemove, n is the positive integer content of scalar register Rb or 2MM here, and final result leaves among the vector/scalar register Rd. This instruction is used and is blocked (rounding off to zero) as rounding mode. Operation

     N＝{SRb％ 32‖IMM<4：0>}；

     for(i＝0；i＜NumElem && EMASK[i]：i++){

         Rd[i]＝Ra[i]/2 ^N；

Unusual

Nothing. Programming is explained

Notice that N is from SRb or IMM＜4:0〉5 figure places that obtain. To byte, byte9, halfword data type, programmer is responsible for being less than or equal in the correct specific data length N value of levels of precision. If it is greater than the precision of specific data length, element will be filled with sign bit. This instruction rounding mode that rounds off to zero.The VDIV2N.F floating-point is by 2 ⁿ RemoveFormThe assembler syntax

VDIV2N.f VRd，VRa，SRb

VDIV2N.f VRd，VRa，# IMM

VDIV2N.f SRd，SRa，SRb

VDIV2N.f SRd, SRa, the pattern that # IMM supports

D：S：M

V＜-V@S

V＜-V@I

S＜-S@S

S＜-S@I

Explanation

The content of vector/scalar register Ra is by 2ⁿRemove, n is the positive integer content of scalar register Rb or IMM here, and final result leaves among the vector/scalar register Rd. Operation

    N＝{SRb％ 32‖IMM<4：0>}；

    for(i＝0；i＜NumElem && EMASK[i]；i++){

        Rd[i]＝Ra[i]/2 ^N；

Unusual

Nothing. Programming is explained

Notice that N is from SRb or IMM＜4:0〉5 figure places that obtain.VDIVI is incomplete except initializingForm

The assembler syntax

VDIVI.ds VRb

VDIVI.ds SRb

Ds={b wherein, b9, h, w}. The pattern of supporting

S	VRb	SRb
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

The initialization step that the signed integer that execution does not recover removes. Dividend is double precision signed integer in the accumulator. If dividend is single-precision number, it must be arrived double precision by sign extended, and leaves among VAC0H and the VAC0L. Divisor is the single precision signed integer among the Rb.

If the symbol of dividend is identical with the symbol of divisor, then from an accumulator high position, deduct Rb. Such as difference, then Rb is added on the accumulator high position. Operation

    for(i＝0；i＜NumElem && EMASK[i]；i++){

        Bop[i]＝{VRb[i]‖SRb}

        if(VAC0H[i]<msb>＝Bop[i]<msb>)

            VAC0H[i]＝VAC0H[i]-Bop[i]；

        else

            VAC0H[i]＝VAC0H[i]+Bop[i]；

Unusual

Nothing. Programming is explained

Before division steps, programmer is responsible for checking and is overflowed or the zero situation about removing of quilt.VDIVS is incomplete except stepForm

The assembler syntax

VDIVS.ds VRb

VDIVS.ds SRb

Ds={b wherein, b9, h, w}. The pattern of supporting

S	VRb	SRb
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

The choosing that execution one tape symbol that does not recover removes is ridden instead of walk suddenly. The number of times that this command request is performed and length identical (for example, be 8 times to int8, int9 is 9 times, and int16 is that 16, int32 data type is 32) with data. The VDIVI instruction must be used once except before the step, produces the remainder of initial part in accumulator. Divisor is the single precision signed integer among the Rb. Each step is extracted a quotient digit and is moved on to the least significant bit of accumulator.

If the symbol of part remainder is identical with the symbol of divisor among the Rb in the accumulator, then from an accumulator high position, deduct Rb. If different, Rb is added on the accumulator high position.

If the symbol of the part remainder that draws in the accumulator (result who adds deduct) is identical with the symbol of divisor, then the merchant position is 1. If not identical, then the merchant position is 0. A move to left bit position and insert with the merchant of accumulator.

In the ending except step, remainder is in an accumulator high position, and the merchant is in the accumulator low level. This merchant is 1 complement form. OperationThe VESL element moves to left oneForm

The assembler syntax

VESL.dt SRc，VRd，VRa，SRb

Dt={b wherein, b9, h, w, f}. Notice that .w specifies identical operation with .f. The pattern of supporting

S		SRb
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

With the position that moves to left of the element among the vector registor Ra, Rb inserts from scalar register. The most left element that just is being moved out of turns back to scalar register Rc, and other element turns back to vector registor Rd.Operation

VRd[0]＝SRb；

for(i＝o；i＜NmElem-1；i++)

    VRd[i]＝VRa[i-1]；

SRc=VRa[NumElem-1]; Unusually

Nothing. Programming is explained

This instruction is not subjected to the impact of element shielding.The VESR element moves to right oneForm

The assembler syntax

VESL.dt SRc，VRd，VRa，SRb

Dt={b wherein, b9, h, w, f}. Notice that .w specifies identical operation with .f. The pattern of supporting

S		SRb
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

With the element of the vector registor Ra position that moves to right, Rb inserts from scalar register. The rightest element that just is being moved out of turns back to scalar register Rc, and other element turns back to vector registor Rd.Operation

SRc＝VRa[0]；

for(i＝o；i＜NumElem-2；i++)

    VRd[i]＝VRa[i+1]；

VRd[NumElem-1]=SRb; Unusually

Nothing. Programming is explained

This instruction is not subjected to the impact of element shielding.VEXTRT extracts an elementForm

The assembler syntax

VEXTRT.dt SRd，VRa，SRb

VEXTRT.dt SRd，VRa，# IMM

Dt={b wherein, b9, h, w, f}. Notice that .w specifies identical operation with .f. The pattern of supporting

D：S：M				S＜-S	S＜-I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Extract an element and deposit it in scalar register Rd from the Ra vector registor, the index of this register is pointed out by scalar register Rb or IMM field. Operation

index32＝{SRb％ 32‖IMM<4：0>}；

index64＝{SRb％ 64‖IMM<5：0>}；

index＝(VCSR<vec64>)？index64：index32；

SRd=VRa[index]; Unusually

Nothing. Programming is explained

This instruction is not subjected to the impact of element shielding.VEXTSGN2 extracts (1 ,-1) symbolForm

The assembler syntax

VEXTSGN2.dt VRd，VRa

VEXTSGN2.dt SRd，SRa

Dt={b wherein, b9, h, w}. The pattern of supporting

S	V＜-V	S＜-S
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

The value of symbol of compute vector/scalar register Ra element mode content is stored in the result among the vector/scalar register Rd. Operation

     for(i＝0；i＜NumElem && EMASK[i]；i++){

         Rd[i]＝(Ra[i]＜0)？-1：1；

Unusual

Nothing.VEXTSGN3 extracts (1,0 ,-1) symbolFormThe assembler syntax

VEXTSGN3.dt VRd，VRa

VEXTSGN3.dt SRd，SRa

Dt={b wherein, b9, h, w}. The pattern of supporting

S	V＜-V	S＜-S
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

The value of symbol of compute vector/scalar register Ra element mode content is stored in the result among the vector/scalar register Rd. Operation

       for(i＝0；i＜NumElem && EMASK[i]；i++){

           if(Ra[i]＞0)    Rd[i]＝1；

           elseif(Ra[i]＜0)Rd[i]＝-1；

           else            Rd[i]＝0；

Unusual

Nothing.VINSRT inserts an elementFormThe assembler syntax

VINSRT.dt VRd，SRa，SRb

VINSRT.dt VRd，SRa，# IMM

Dt={b wherein, b9, h, w, f}. Notice that .w specifies identical operation with .f. The pattern of supporting

D：S：M		V＜-S	V＜-I
						DS	int8(b)	int9(b9)	int16(h)	in32(w)

Explanation

The index of element among the scalar register Ra by scalar register Rb or the appointment of IMM field is inserted among the vector registor Rd. Operation

index32＝{SRb％ 32‖IMM<4：0>}；

index64＝{SRb％ 64‖IMM<5：0>}；

index＝(VCSR<vec64>)？index64：index32；

VRd[index]=SRa; Unusually

Nothing. Programming is explained

This instruction is not subjected to the impact of element shielding.VL loadsFormThe assembler syntax

VL.lt Rd，SRb，SRi

VL.lt Rd，SRb，# IMM

VL.lt Rd，SRb+，SRi

VL.lt Rd，SRb+，# IMM

Lt={b wherein, bz9, bs9, h, w, 4,8,16,32,64}, Rd={VRd, VRAd, SRd}. Notice that .b specifies identical operation with .bs9 .64 and VRAd can not be designated together. Cache-off is loaded use VLOFF. Operation

Load a vector registor or a scalar register in current or the alternate sets. Operation

EA＝SRb+{SRi‖sex(IMM<7：0>)}；

if(A＝1)SRb＝EA；

Rd=sees the following form:

LT	Load operation
		.b	SR d<7：0>；-BYTE[EA]
.bz9	SR d<8：0>＝zex BYTE[EA]
		.bs9	SR d<8：0>＝sex BYTE[EA]
.h	SR d<15：0>＝HALF[EA]
		.w	SR d<31：0>＝WORD[EA]
.4	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 3
		.8	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 7
.16	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 15
		.32	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 31
.64	VR 0d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 31  VR 1d<9i+8：9i>＝sex BYTE[EA+32+i]，i＝0 to 31

Unusually

Invalid data address, the access that does not line up. Programming is explained

This instruction is not subjected to the impact of element shielding.VLCB loads from cyclic bufferFormThe assembler syntax

VLCB.lt Rd，SRb，SRi

VLCB.lt Rd，SRb，# IMM

VLCB.lt Rd，SRb+，SRi

VLCB.lt Rd，SRb+，# IMM

Lt={b wherein, bz9, bs9, h, w, 4,8,16,32,64}, Rd={VRd, VRAd, SRd}. Notice that .b specifies identical operation with .bs9 .64 and VRAd can not be specified together. Cache-off is loaded use VLCBOFF. Explanation

From by SR_b+1In BEGIN pointer and SR_b+2In the cyclic buffer that limits of END pointer load a vector or scalar register.

Before loading and address renewal operation, greater than the END address, then effective address is adjusted such as effective address. In addition .h and .w scalar are loaded, the cyclic buffer border must be respectively and halfword and word boundary alignment. Operation

EA＝SR _b+{SRi‖sex(IMM<7：0>)}；

BEGIN＝SR _b+1；

END＝SR _b+2；

cbsize＝END-BEGIN；

if(EA＞END)EA＝BEGIN+(EA-END)；

if(A＝1)SR _b＝EA；

R _d=see following table:

LT	Load operation
		.bz9	SR d<8：0>＝zex BYTE[EA]
.bs9	SR d<8：0>＝sex BYTE[EA]
		.h	SR d<15：0>＝HALF[EA]
.w	SR d<31：0>＝WORD[EA]
		.4	VR d<9i+8：9i>＝sex BYTE[(EA+i＞END)？EA+i-cbsize：EA+i]，i＝0 to 3
.8	VR d<9i+8：9i>＝sex BYTE[(EA+i＞END)？EA+i-cbsize：EA+i]，i＝0 to 7

LT	Load operation
		.16	VR d<9i+8：9i>＝sex BYTE[(EA+i＞END)？EA+i-cbsize：EA+i]，i＝0 to 15
.32	VR d<9i+8：9i>＝sex BYTE[(EA+i＞END)？EA+i-cbsize：EA+i]，i＝0 to 31
		.64	VR 0d<9i+8：9i>＝sex BYTE[(EA+i＞END)？EA+i-cbsize：EA+i]＝0 to 31     VR 1d<9i+8：9i>＝sex BYTE[(EA+32+i>END)？EA+32+i-cbsize：；A+32+i].     i＝0 to31

Unusually

Invalid data address, the access that does not line up. Programming is explained

This instruction is not subjected to the impact of element shielding.

Condition below programmer must be determined this instruction is to press desired work:

BEGIN＜EA＜2*END-BEGIN

That is, EA＞BEGIN and EA-END＜END-BEGIN.VLD is two to be loadedFormThe assembler syntax

VLD.lt Rd，SRb，SRi

VLD.lt Rd，SRb，# IMM

VLD.lt Rd，SRb+，SRi

VLD.lt Rd，SRb+，# IMM

Lt={b wherein, bz9, bs9, h, w, 4,8,16,32,64}, Rd={VRd, VRAd, SRd}. Notice that .b specifies identical operation with .bs9 .64 and VRAd can not be specified together. Cache-off is loaded use VLDOFF. Explanation

Load two vector registors or two scalar registers in current or the alternate sets. Operation

EA＝SR _b+{SR _i‖sex(IMM<7：0>)}；

if(A＝1)SR _b＝EA；

R _d：R _d+1=see the following form:

LT	Load operation
		.z9	SR d<8：0>＝zex BYTE[EA]   SR d+1<8：0>＝zex BYTE[EA+i]
.bs9	SR d<8：0>＝zex BYTE[EA]   SR d+1<8：0>＝zex BYTE[EA+i]
		.h	SR d<15：0>＝HALF[EA]   SR d+1<15：0>＝HALF[EA+2]
.w	SR d<31：0>＝WORD[EA]   SR d+1<31：0>＝WORD[EA+4]
		.4	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 3   VR d+1<9i+8：9i>＝sex BYTE[EA+4+i]，i＝0 to 3
.8	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 7   VR d+1<9i+8：9i>＝sex BYTE[EA+8+i]，i＝0 to 7

LT	Load operation
		.16	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 15  VR d+1<9i+8：9i>＝sex BYTE[EA+16+i]，i＝0 to 15
.32	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 31  VR d+1<9i+8：9i>＝sex BYTE[EA+32+i]，i＝0 to 31
		.64	VR 0d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 31  VR 1d<9i+8：9i>＝sex BYTE[EA+32+i]，i＝0 to 31  VR 0d+1<9i+8：9i>＝sex BYTE[EA+64+i]，i＝0 to 31  VR 1d+1<9i+8：9i>＝sex BYTE[EA+96+i]，i＝0 to 31

Unusually

Invalid data address, the access that does not line up. Programming is explained

This instruction is not subjected to the impact of element shielding.VLI loads immediately and countsFormThe assembler syntax

VLI.dt VRd，# IMM

VLI.dt SRd，# IMM

Dt={b wherein, b9, h, w, f}. Explanation

Load immediate value to scalar or vector registor.

Scalar register is loaded, load byte, byte9, halfword or word according to data type. To byte, byte9 and halfword data type, unaffected those byte (byte9) are not changed. Operation

Rd=sees the following form:

DT	Scalar loads	Vector loads
			.i8	SR d<2：0>＝IMM<7：0>	VR d＝32 int8 elements
.i9	SR d<8：0>＝IMM<8：0>	VR d＝32 int9 elements
			.i16	SR d<15：0>＝IMM<15：0>	VR d＝16 int16 elements
.i32	SR d<31：0>＝sex IMM<18：0>	VR d＝8 int32 elements
			.f	SR d<31>＝IMM<18>(sign)   SR d<30：23>＝IMM<17：10>(exponent)   SR d<22：13>＝IMM<9：0>(mantissa)   SR d<12：0>＝zeroes	VR d＝8 float elements

Unusually

Nothing.VLQ four loadsForm

The assembler syntax

VLQ.lt Rd，SRb，SRi

VLQ.lt Rd，SRb，# IMM

VLQ.lt Rd，SRb+，SRi

VLQ.lt Rd，SRb+，# IMM

Lt={b wherein, bz9, bs9, h, w, 4,8,16,32,64}, Rd={VRd, VRAd, SRd}. Notice that .b specifies identical operation with .bs9 .64 and VRAd can not be specified together. Cache-off loading is utilized VLQOFF. Explanation

In current or alternate sets, load four vector registors or four scalar registers. Operation 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 the following form:

LT	Load operation
		.bz9	SR d<8：0>＝zex BYTE[EA] SR d+1<8：0>＝zex BYTE[EA+1] SR d+2<8：0>＝zex BYTE[EA+2] SR d+3<8：0>＝zex BYTE[EA+3]
.bs9	SR d<8：0>＝zex BYTE[EA] SR d+1<8：0>＝zex BYTE[EA+1] SR d+2<8：0>＝zex BYTE[EA+2] SR d+3<8：0>＝zex BYTE[EA+3]
		.h	SR d<15：0>＝HALF[EA] SR d+1<15：0>＝HALF[EA+2] SR d+2<15：0>＝HALF[EA+4] SR d+3<15：0>＝HALF[EA+6]

LT	Load operation
		.w	SR d<31：0>＝WORD[EA] SR d+1<31：0>＝WORD[EA+4] SR d+2<31：0>＝WORD[EA+8] SR d+3<31：0>＝WORD[EA+12]
.4	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 3 VR d+1<9i+8：9i>＝sex BYTE[EA+4+i]，i＝0 to 3 VR d+2<9i+8：9i>＝sex BYTE[EA+8+i]，i＝0 to 3 VR d+3<9i+8：9i>＝sex BYTE[EA+12+i]，i＝0 to 3
		.8	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 7 VR d+1<9i+8：9i>＝sex BYTE[EA+8+i]，i＝0 to 7 VR d+2<9i+8：9i>＝sex BYTE[EA+16+i]，i＝0 to 7 VR d+3<9i+8：9i>＝sex BYTE[EA+24+i]，i＝0 to 7
.16	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 15 VR d+1<9i+8：9i>＝sex BYTE[EA+16+i]，i＝0 to 15 VR d+2<9i+8：9i>＝sex BYTE[EA+32+i]，i＝0 to 15 VR d+3<9i+B：9i>＝sex BYTE[EA+48+i]，i＝0 to 15
		.32	VR d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 31 VR d+1<9i+8：9i>＝sex BYTE[EA+32+i]，i＝0 to 31 VR d+2<9i+8：9i>＝sex BYTE[EA+64+i]，i＝0 to 31 VR d+3<9i+8：9i>＝sex BYTE[EA+96+i]，i＝0 to 31
.64	VR 0d<9i+8：9i>＝sex BYTE[EA+i]，i＝0 to 31 VR 1d<9i+8：9i>＝sex BYTE[EA+32+i]，i＝0 to 31 VR 0d+1<9i+8：9i>＝sex BYTE[EA+64+i]，i＝0 to 31 VR 1d+1<9i+8：9i>＝sex BYTE[EA+96+i]，i＝0 t0 31 VR 0d+2<9i+8：9i>＝sex BYTE[EA+128+i]，i＝0 to 31 VR 1d+2<9i+8：9i>＝sex BYTE[EA+160+i]，i＝0 to 31 VR 0d+3<9i+8：9i>＝sex BYTE[EA+192+i]，i＝0 to 31 VR 1d+3<9i+8：9i>＝sex BYTE[EA+224+i]，i＝0 to 31

Unusually

Invalid data address, the access that does not line up. Programming is explained

This instruction is not subjected to the impact of element shielding.VLR oppositely loadsForm

The assembler syntax

VLR.lt Rd，SRb，SRi

VLR.lt Rd，SRb，# IMM

VLR.lt Rd，SRb+，SRi

VLR.lt Rd，SRb+，# IMM

Lt={4 wherein, 8,16,32,64}, Rd={VRd, VRAd}. Notice that .64 and VRAd can not be specified together. Loading utilizes VLROFF to Cache-off. Explanation

Load a vector registor by the inverse element sequence. The scalar destination register is not supported in this instruction. Operation

EA＝SR _b+{SR _i‖sex(IMM<7：0>)]；

if(A＝1)SR _b=EA; Rd=sees the following form:

LT	Load operation
.4	VR d[31-i]<8：0>＝sex BYTE[EA+i]，i＝0 to 3
		.8	VR d[31-i]<8：0>＝sex BYTE[EA+i]，i＝0 to 7
.16	VR d[31-i]<8：0>＝sex BYTE[EA+i]，i＝0 to 15
		.32	VR d[31-i]<8：0>＝sex BYTE[EA+i]，i＝0 to 31
.64	VR 0d[31-i]<8：0>＝sex BYTE[EA+32+i]，i＝0 to 31  VR 1d[31-i]<8：0>＝sex BYTE[EA+i]，0 to 31

Unusually

Invalid data address address, the access that does not line up. Programming is explained

This instruction is not subjected to the impact of element shielding.The VLSL logical shift leftFormThe assembler syntax

VLSL.dt VRd，VRa，SRb

VLSL.dt VRd，VRa，# IMM

VLSL.dt SRd，SRa，SRb

VLSL.dt SRd，SRa，# IMM

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M		V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Each element logical shift left of vector/scalar register Ra, least significant bit (LSB) position is inserted with zero, and shift amount is given in scalar register Rb or IMM field, and the result leaves among the vector/scalar register Rd. Operation

shift_amount＝[SRb ％ 32‖IMM<4：0>}；

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Rd[i]＝Ra[i]＜＜shift_amount：

Unusual

Nothing. Programming is explained

Notice that shift-amount is from SRb or IMM＜4:0〉5 figure places that obtain, for byte, byte9, halfword data type, programmer are responsible for correct shift amount of specifying the figure place that is less than or equal to data length. If this shift amount is greater than the data length of appointment, element will be filled with zero.The VLSR logic shift rightFormThe assembler syntax

VLSR.dt VRd，VRa，SRb

VLSR.dt VRd，VRa，# IMM

VLSR.dt SRd，SRa，SRb

VLSR.dt SRd，SRa，# IMM

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M		V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Each element logical shift to the right of vector/scalar register Ra, highest significant position (MSB) position is inserted with zero, and shift amount is given in scalar register Rb or IMM field, and the result leaves among the vector/scalar register Rd. Operation

shift_amount＝{SRb ％ 32‖IMM<4：0>}；

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Rd[i]＝Ra[i]zero＞＞shift_amount；

Unusual

Nothing. Programming is explained

Notice that shift-amount is from SRb or IMM＜4:0〉5 figure places that obtain, for byte, byte9, halfword data type, programmer are responsible for correct shift amount of specifying the figure place that is less than or equal to data length. If this shift amount is greater than the data length of appointment, element will be filled with zero.The VLWS span loadsForm

The assembler syntax

VLWS.dt Rd，SRb，SRi

VLWS.dt Rd，SRb，# IMM

VLWS.dt Rd，SRb+，SRi

VLWS.dt Rd，SRb+，# IMM

Dt={4 wherein, 8,16,32}, Rd={VRd, VRAd}. Notice that the .64 pattern is not supported, substitute with VL. Cache-off is loaded use VLWSOFF. Explanation

From effective address, as the span control register, load 32 bytes to vector registor VRd from memory with scalar register SRb+1.

The consecutive word joint number that LT specifies block size, each piece is loaded. SRb+1 specifies stride, separates the initial byte number of two continuous blocks.

Stride must be equal to or greater than block size. EA must be the data length of aiming at. Stride and block size must be several data length. Operation

EA＝SR _b+{SR _i‖sex(IMM<7：0>)}；

if(A＝1)SR _b＝EA；

Block-size＝{4‖8‖16‖32}；

Stride＝SR _b+1<31：0>；

for(i＝0；i＜VECSIZE/Block-size；i++)

for(j＝0；j＜Block-size；j++)

VRd[i*Block-size+j]＜8:0 〉=sex BYTE{EA+i*Stride+j}; Unusually

Invalid data address, unjustified access.VMAC takes advantage of and adds upForm

The assembler syntax

VMAC.dt VRa，VRb

VMAC.dt VRa，SRb

VMAC.dt VRa，# IMM

VMAC.dt SRa，SRb

VMAC.dt SRa，# IMM

Dt={b wherein, h, w, f}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)		int16(h)	int32(w)	float(f)

Explanation

Each element of Ra multiply by the intermediate object program that produces a double precision mutually with each element among the Rb; With each double precision element addition of each double precision element and the vectorial accumulator of this intermediate object program, with the double precision of each element with deposit in the vectorial accumulator.

Ra and Rb use the data type of appointment, and VAC uses suitable double precision datum type (16,32 and 64 the corresponding int8 of difference, int16 and int32). The high-order portion of each double precision element leaves among the VACH.

To floating type, all operations were number and result are single precisions. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Aop[i]＝{VRa[i]‖SRa}；

    Bop[i]＝{VRb[i]‖SRb}；

    if(dt＝float)VACL[i]＝Aop[i] ^*Bop[i]+VACL[i]；

    else VACH[i}：VACL[i]＝Aop[i] ^*Bop[i]+VACH[i]：VACL[i]；

Unusual

Overflow the operand that floating-point is invalid. Programming is explained

The int9 data type is not supported in this instruction, substitutes with the int16 data type.The VMACF decimal of taking advantage of and add upForm

The assembler syntax

VMACF.dt VRa，VRb

VMACF.dt VRa，SRb

VMACF.dt VRd，# IMM

VMACF.dt SRa，SRb

VMACF.dt SRa，# IMM

Dt={b wherein, h, w}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S ＜-S@S	S＜-S@I
						DS	int8(b)		int16(h)	int32(w)

Explanation

Each element of VRa multiply by the intermediate object program that produces a double precision mutually with each element among the Rb; This double precision intermediate object program is moved to left one; With each double precision element of the intermediate object program after the displacement and each double precision element addition of vectorial accumulator; The double precision of each element and being stored in the vectorial accumulator.

VRa and Rb use the data type of appointment, and VAC uses suitable double precision datum type (16,32 and 64 the corresponding int8 of difference, int16 and int32). The high-order portion of each double precision element leaves among the VACH. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

    VACH[i]：VACL[i]＝((VRa[i] ^*Bop[i])＜＜1)+VACH[i]：VACL[i]；

Unusual

Overflow. Programming is explained

The int9 data type is not supported in this instruction, substitutes with the int16 data type.The VMACL low level of taking advantage of and add upForm

The 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

Dt={b wherein, h, w, f}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)		int16(h)	int32(w)	float(f)

Explanation

Each element of VRa and each element among the Rb be multiply by mutually the intermediate object program of generation one double precision; Each double precision element addition with each double precision element and the vectorial accumulator of this intermediate object program; With the double precision of each element be stored in vectorial accumulator; To turn back to destination register VRd than low portion.

VRa and Rb use the data type of appointment, and VAC uses suitable double precision datum type (16,32 and 64 the corresponding int8 of difference, int16 and int32). The bit position of each double precision element leaves among the VACH.

To floating type, all operations were number and result are single precisions. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝{VRb[i]‖SRb}；

    if(dt＝float)VACL[i]＝VRa[i] ^*Bop[i]+VACL[i]；

    else VACH[i]：VACL[i]＝VRa[i] ^*Bop[i]+VACH[i]：VACL[i]；

    VRd[i]＝VACL[i]；

Unusual

Overflow the operand that floating-point is invalid. Programming is explained

The int9 data type is not supported in this instruction. Replace and use the int16 data type.VMAD takes advantage of and addsForm

The assembler syntax

VMAD.dt VRc，VRd，VRa，VRb

VMAD.dt SRc，SRd，SRa，SRb

Dt=(b, h, w) wherein. The pattern of supporting

S	VR	SR
					DS	int8(b)		int16(h)	int32(w)

Explanation

Each element of Ra and each element among the Rb be multiply by mutually the intermediate object program of generation one double precision; Make each element addition of each double precision element and the Rc of this intermediate object program; With the double precision of each element be stored in destination register Rd+1:Rd. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Aop[i]＝[VRa[i]‖SRa]；

    Bop[i]＝{VRb[i]‖SRb}；

    Cop[i]＝{VRc[i]‖SRc}；

    Rd+1[i]：Rd[i]＝Aop[i] ^*Bop[i]+sex_dp(Cop[i])；

Unusual

Nothing.VMADL takes advantage of and adds low levelForm

The assembler syntax

VMADL.dt VRc，VRd，VRa，VRb

VMADL.dt SRc，SRd，SRa，SRb

Dt={b wherein, h, w, f}. The pattern of supporting

S	VR	SR
					DS	int8(b)	float(b)	int16(h)	int32(w)

Explanation

Each element of Ra and each element among the Rb be multiply by mutually the intermediate object program of generation one double precision; Each element addition with each double precision element and the Rc of this intermediate object program; With the double precision of each element and low portion turn back to destination register Rd.

To floating type, all operations were number and result are single precisions. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Aop[i]＝{VRa[i]‖SRa}；

    Bop[i]＝{VRb[i]‖SRb}；

    Cop[i]＝{VRc[i]‖SRc}；

    if(dt＝float)Lo[i]＝Aop[i] ^*Bop[i]+Cop[i]；

    else Hi[i]：Lo[i]＝Aop[i] ^*Bop[i]+sex_dp(Cop[i])；

    Rd[i]＝Lo[i]；

Unusual

Overflow the operand that floating-point is invalid.VMAS takes advantage of and subtracts from accumulatorFormThe assembler syntax

VMAS.dt VRa，VRb

VMAS.dt VRa，SRb

VMAS.dt VRa，# IMM

VMAS.dt SRa，SRb

VMAS.dt SRa，# IMM

Dt={b wherein, h, w, f}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)		int16(h)	int32(w)	float(f)

Explanation

Each element among each element Rb of Ra be multiply by mutually the intermediate object program that produces a double precision; From each double precision element of vectorial accumulator, deduct each double precision element of intermediate object program; With the double precision of each element be stored in vectorial accumulator.

Ra and Rb use the data type of appointment, and VAC uses suitable double precision datum type (16,32 and 64 the corresponding int8 of difference, int16 and int32). The high-order portion of each double precision element leaves among the VACH.

To floating type, all operations were number and result are single precisions. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝{VRb[i]‖SRb}；

    if(dt＝float)VACL[i]＝VACL[i]-VRa[i] ^*Bop[i]；

    else VACH[i]：VACL[i]＝VACH[i]：VACL[i]-VRa[i] ^*Bop[i]；

Unusual

Overflow the operand that floating-point is invalid. Programming is explained

The int9 data type is not supported in this instruction, substitutes with the int16 data type.VMASF takes advantage of and subtracts from the accumulator decimalForm

The assembler syntax

VMASF.dt VRa，VRb

VMASF.dt VRa，SRb

VMASF.dt VRa，# IMM

VMASF.dt SRa，SRb

VMASF.dt SRa，# IMM

Dt={b wherein, h, w}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)		int16(h)	int32(w)

Explanation

Each element of VRa and each element among the Rb be multiply by mutually the intermediate object program of generation one double precision; The intermediate object program of double precision is moved to left one; Deduct each double precision element of the intermediate object program that is shifted from each double precision element of vectorial accumulator; With the double precision of each element with store vectorial accumulator into.

VRa and Rb use the data type of appointment, and VAC uses suitable double precision datum type (16,32 and 64 respectively to and int8, int16 and int32). The high-order portion of each double precision element leaves among the VACH. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

    VACH[i]：VACL[i]＝VACH[i]：VACL[i]-VRa[i] ^*Bop[i]；

Unusual

Overflow. Programming is explained

The int9 data type is not supported in this instruction, substitutes with the int16 data type.VMASL takes advantage of and subtracts from the accumulator low levelForm

The 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

Dt={b wherein, h, w, f}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)		int16(h)	int32(w)	float(f)

Explanation

Each element of VRa and each element among the Rb be multiply by mutually the intermediate object program of generation one double precision; Deduct each double precision element of intermediate object program from each double precision element of vectorial accumulator; With the double precision of each element be stored in vectorial accumulator; Low portion is stored in destination register VRd.

RVa and Rb use the data type of appointment, and VAC uses suitable double precision datum type (the corresponding int8 of 16,32 and 64 difference, int16 and int32). The high-order portion of each double precision element leaves among the VACH.

To floating type, all operations were number and result are single precisions. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝{VRb{i]‖SRb}；

    if(dt＝float)VACL[i]＝VACL[i]-VRA[i] ^*Bop[i]；

    else VACH[i]：VACL[i]＝VACH[i]：VACL[i]-VRa[i] ^*Bop[i]；

    VRd[i]＝VACL[i]；

Unusual

Overflow the operand that floating-point is invalid. Programming is explained

The int9 data type is not supported in this instruction. Replace and use the int16 data type.Maximum and the exchange of the paired mode of VMAXEFormThe assembler syntax

VMAXE.dt VRd，VRb

Dt={b wherein, b9, h, w, f}. The pattern of supporting

D：S：M	V＜-V
						DS	int8(b)	int9(b9)	int16(h)	int32(w)	float(f)

Explanation

VRa should equal VRb. When VRa and VRb not simultaneously, the result is undefined.

Each idol/odd data element of vector registor Rb is compared in pairs, and the right higher value of each data element stores the even number position into, and the right smaller value of each data element stores the odd positions of vector registor Rd into. Operation

for(i＝0；i＜NumElem && EMASK[i]：i＝i+2){

    VRd[i]＝(VRb[i]＞VRb[i+1])？VRb[i]：VRb[i+1]；

    VRd[i+1]＝(VRb[i]＞VRb[i+1])？VRb[i+1]：VRb[i]；

Unusual

Nothing.VMOV shiftsForm

The assembler syntax

VMOV.dt Rd，Rb

Dt={b wherein, b9, h, w, f}. The register name of stipulating on Rd and the Rb indicating structure.

Note .w and the identical operation of .f indication. The mode declaration pattern specification of supporting

The transfer of content of register Rb is to register Rd. Group field assigned source and destination register group. The mark way of register group is:

Current group of vector registor of VR

VRA alternate sets vector registor

The SR scalar register

The SP special register

RASR return address stack register

VAC vector accumulator register (referring to following VAC register coding schedule)

Group＜3:0 〉	The source group	The purpose group	Note
				0000			Keep
0001	VR	VRA
				0010	VRS	VR
0011	VRA	VRA
				0100			Keep
0101			Keep
				0110	VRA	VAC
0111	VAC	VRA
				1000			Keep
1001	SR	VRA
				1010			Keep
1011			Keep
				1100	SR	SP
1101	SP	SR
				1110	SR	RASR
1111	RASR	SR

Note vector registor to be sent to scalar register with this instruction. The VEXTRT instruction provides for this reason.

VAC register coding is used following table:

R<2：0>	Register	Note
			000	Undefined
001	VAC0L
			010	VAC0H
011	VAC0	Specify VAC0H:VAC0L both. As be appointed as the source, the VRd+1:VRd register pair is updated. VRd must be even numbered register.
			100	Undefined
101	VAC1L
			110	VAC1H
111	VAC1	Specify VAC1H:VAC1L both. As be appointed as the source, the VRd+1:VRd register pair is updated. VRd must be even numbered register.
			Other	Undefined

Operation

Rd=Rb is unusual

The anomalous event mode bit is set in VCSR or VISRC will causes corresponding anomalous event. Programming is explained

This instruction is not subjected to the impact of element shielding. Note, be used in the concept that does not have alternate sets under the VEC64 pattern, under the VEC64 pattern, this instruction can not be used for shifting from the register of alternate sets or to the register of alternate sets.VMUL takes advantage ofForm

The assembler syntax

VMUL.dt VRc，VRd，VRa，VRb

VMUL.dt SRc，SRd，SRa，SRb

Dt={b wherein, h, w}. The pattern of supporting

S	VR	SR
					DS	int8(b)		int16(h)	int32(w)

Explanation

Each element of Ra and each element among the Rb be multiply by mutually the result of generation one double precision; With the double precision of each element with turn back to destination register Rc:Rd.

Ra and Rb use the data type of appointment, and Rc:Rd uses suitable double precision datum type (16,32 and 64 the corresponding int8 of difference, int16 and int32). The high-order portion of each double precision element leaves among the Rc. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Aop[i]＝{VRa[i]‖SRa}；

    Bop[i]＝{VRb[i]‖SRb}；

    Hi[i]：Lo[i]＝Aop[i] ^*Bop[i]；

    Rc[i]＝Hi[i]；

    Rd[i]＝Lo[i]；

Unusual nothing. Programming is explained

The int9 data type is not supported in this instruction, substitutes with the int16 data type. Floating type is not supported in this instruction yet, because the result of expansion is the data type that is not supported.VMULA takes accumulatorForm

The assembler syntax

VMULA.dt VRa，VRb

VMULA.dt VRa，SRb

VMULA.dt VRa，# IMM

VMULA.dt SRa，SRb

VMULA.dt SRa，# IMM

Dt={b wherein, h, w, f}. The pattern of supporting

D：S：M	V@V	V@S	V@I	S@S	S@I
						DS	int8(b)		int16(h)	int32(w)	float(f)

Explanation

Each element of VRa and each element among the Rb be multiply by mutually the result of generation one double precision; This result is write accumulator.

Floating type, all operations were number and result are single precisions. Operation

for(i＝0；i＜NumElem && EMASK[i]：i++){

    Bop[i]＝[VRb[i]‖SRb]；

    if(dt＝＝float)VACL[i]＝VRa[i] ^*Bop[i]；

    else VACH[i]：VACL[i]＝VRa[i] ^*Bop[i]；

Unusual

Nothing. Programming is explained

The int9 data type is not supported in this instruction. Replace and use the int16 data type.VMULAF takes the accumulator decimalFormThe assembler syntax

VMULAF.dt VRa，VRb

VMULAF.dt VRa，SRb

VMULAF.dt VRa，# IMM

VMULAF.dt SRa，SRb

VMULAF.dt SRa，# IMM

Dt={b wherein, h, w}. The pattern of supporting

D：S：M	V@V	V@S	V@I	S@S	S@I
						DS	int8(b)		int16(h)	int32(w)

Explanation

Each element among each element of VRa and the Rb be multiply by mutually produce the intermediate object program with double precision; This double precision intermediate object program moves to left one; The result writes accumulator. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝[VRb[i]‖SRb‖sex(LMM<8：0>)}；

    VACH[i]：VACL[i]＝(VRa[i] ^*Bop[i])＜＜1；

Unusual

Nothing. Programming is explained

The int9 data type is not supported in this instruction, substitutes with the int16 data type.VMULF takes advantage of decimalForm

The 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

Dt={b wherein, h, w}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)		int16(h)	int32(w)

Explanation

Each element of VRa and each element among the Rb be multiply by mutually the intermediate object program of generation one double precision; This double precision intermediate object program moves to left one; Result's high-order portion is turned back to destination register VRd+1, and low portion turns back to destination register VRd. VRd must be an even numbered register. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

    Hi[i]：Lo[i]＝(VRa[i] ^*Bop[i])＜＜1；

    VRd+1[i]＝Hi[i]；

    VRd[i]＝Lo[i]；

Unusual

Nothing. Programming is explained

The int9 data type is not supported in this instruction, substitutes with the int16 data type.VMULFR takes advantage of decimal and rounds offForm

The 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

Dt={b wherein, h, w}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)		int16(h)	int32(w)

Explanation

Each element among each element of VRa and the Rb be multiply by the intermediate object program that produces a double precision mutually; This double precision intermediate object program moves to left one; This intermediate object program that is shifted is rounded to high-order portion; High-order portion turns back to destination register VRd. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

    Hi[i]：Lo[i]＝(VRa[i] ^*Bop[i])＜＜1；

    if(Lo[i]<msb>＝＝1)Hi[i]＝Hi[i]+1；

    VRd[i]＝Hi[i]；

Unusual

Nothing. Programming is explained

The int9 data type is not supported in this instruction, substitutes with the int16 data type.VMULL takes advantage of low levelForm

The 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

Dt={b wherein, h, w, f}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)		int16(h)	int32(w)	float(f)

Explanation

Each element among each element of VRa and the Rb be multiply by the result who produces a double precision mutually; Result's low portion turns back to destination register VRd.

To floating type, all operations were number and result are single precisions. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝{VRb[i]‖SRb}；

    if(dt＝float)Lo[i]＝VRa[i] ^*Bop[i]；

    else Hi[i]：Lo[i]＝VRa[i] ^*Bop[i]；

    VRd[i]＝Lo[i]；

Unusual

Overflow the operand that floating-point is invalid. Programming is explained

The int9 data type is not supported in this instruction. Replace and use the int16 data type.VNAND and non-FormThe 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

Dt={b wherein, b9, h, w}. Notice that .w specifies identical operation with .f. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Corresponding positions in each and the Rb/ immediate operand of each element among the Ra is carried out logic NAND, and the result turns back among the Rd. Operation

for(i＝0；i＜NumElem && EMASK[i]：i++){

    Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

    Rd[i]<k>＝-(Ra[i]<k>&Bop[i]<k>)，for k＝all bits in element i；

Unusual

Nothing.VNOR or non-Form

The 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

Dt={b wherein, b9, h, w}. Notice that .w specifies identical operation with .f. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Corresponding positions in each and the Rb/ immediate operand of each element among the Ra is made logic NOR; The result turns back among the Rd. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

    Rd[i]<k>＝-(Ra[i]<k>|Bop[i]<k>). for k＝all bits in element i；

Unusual

Nothing.VOR orFormThe 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

Dt={b wherein, b9, h, w}. Notice that .w specifies identical operation with .f. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Corresponding positions in each and the Rb/ immediate operand of each element among the Ra is carried out logic OR; The result turns back among the Rd. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

    Rd[i]<k>＝Ra[i]<k>|Bop[i]<k>，for k＝all bits in element i；

Unusual

Nothing.VORC or complement codeFormThe 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

Dt={b wherein, b9, h, w}. Notice that .w specifies identical operation with .f. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Complement code to corresponding positions in each and the Rb/ immediate operand of each element among the Ra is carried out logic OR; The result turns back among the Rd. Operation

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

    Rd[i]<k>＝Ra[i]<k>|-Bop[i]<k>，for k＝all bits in element i；

Unusual

Nothing.VPFTCH looks aheadFormThe assembler syntax

VPFTCH.ln SRb，SRi

VPFTCH.ln SRb，# IMM

VPFTCH.ln SRb+，SRi

VPFTCH.ln SRb+，# IMM

Ln={1 wherein, 2,4,8}. Explanation

Capable from effective address a plurality of vector data Cache that begin to look ahead. The number that Cache is capable is designated as follows:

LN＜1:0 〉=00: the Cache of 1 64 byte of looking ahead is capable

LN＜1:0 〉=01: the Cache of 2 64 bytes of looking ahead is capable

LN＜1:0 〉=10: the Cache of 4 64 bytes of looking ahead is capable

LN＜1:0 〉=11: the Cache of 8 64 bytes of looking ahead is capable

If effective address does not drop on the border of 64 bytes, then at first block in case with the boundary alignment of 64 bytes. Operation exception

Invalid data address anomalous event. Programming is explained

EA＜31:0〉point out a byte address in the local memory.VPFTCHSP is prefetched to scratchpad memoryForm

The assembler syntax

VPFTCHSP.ln SRp，SRb，SRi

VPFTCHSP.ln SRp，SRb，# IMM

VPFTCHSP.ln SRp，SRb+，SRi

VPFTCHSP.ln SRP，SRb+，# IMM

Ln={1 wherein, 2,4,8}. Notice that VPFTCH and VPFTCHSP have same command code. Explanation

Transmit the piece of a plurality of 64 bytes from memory to scratchpad memory. Effective address provides the initial address of memory, and SRp provides the initial address of scratchpad memory. The number of 64 block of bytes is specified as follows:

LN＜1:0 〉=00: the piece that transmits 1 64 byte

LN＜1:0 〉=01: the piece that transmits 2 64 bytes

LN＜1:0 〉=10: the piece that transmits 4 64 bytes

LN＜1:0 〉=11: the piece that transmits 8 64 bytes

If effective address does not drop on the border of 64 bytes, at first block so that with the boundary alignment of 64 bytes. If the scratchpad memory pointer address among the SRp does not drop on the border of 64 bytes, it also block with the boundary alignment of 64 bytes. The scratchpad memory pointer address of alignment increases to transmit byte number. Operation

EA＝SRb+{SRi‖sex(IMM<7：0>)}：

if(A＝1)SRb＝EA；

Num_bytes＝{64‖128‖256‖512}；

Mem_adrs＝EA<31：6>：6b’000000；

SRp＝SRp<31：6>：6b’000000；

for(i＝0；i＜Num_bytes；i++)

SPAD[SRp++]=MEM[Mem_adrs+i]; Unusually

Invalid data address anomalous event.The VROL ring shift leftForm

The assembler syntax

VROL.dt VRd，VRa，SRb

VROL.dt VRd，VRa，# IMM

VROL.dt SRd，SRa，SRb

VROL.dt SRd，SRa，# IMM

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M		V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Each data element ring shift left of vector/scalar register Ra, the figure place that moves to left provides in scalar register Rb or IMM field, and the result deposits vector/scalar register Rd in. Operation

rotate_amount＝{SRb ％ 32‖IMM<4：0>}；

for(i＝0；i＜NumElem && EMASK[i]；i++){

    Rd[i]＝Ra[i]rotate_left rotate_amount；

Unusual

Nothing. Programming is explained

Notice that rotate-amount is from SRb or IMM＜4:0〉5 figure places that obtain. To byte, byte9, halfword data type, programmer is responsible for correct cyclic shift total amount of specifying the figure place that is less than or equal to data length. If the displacement total amount is greater than the data length of appointment, then the result is undefined.

Notice that ring shift left n position is equivalent to ring shift right ElemSize-n position, ElemSize represents the figure place of data-oriented length here.The VROR ring shift rightForm

The assembler syntax

VROR.dt VRd，SRa，SRb

VROR.dt VRd，SRa，# IMM

VROR.dt SRd，SRa，SRb

VROR.dt SRd，SRa，# IMM

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M		V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Each data element ring shift right of vector/scalar register Ra, the figure place that moves to right provides in scalar register Rb or IMM field, and the result deposits vector/scalar register Rd in. Operation

  rotate_amount＝{SRb ％ 32‖IMM<4：0>}；

  for(i＝0；i＜NumElem && EMASK[i]；i++){

      Rd[i]＝Ra[i]rotate_right rotate_amount；

Unusual

Nothing. Programming is explained

Notice that rotate-amount is from SRb or IMM＜4:0〉5 number obtaining. To byte, byte9, halfword data type, programmer is responsible for correct cyclic shift total amount of specifying the figure place that is less than or equal to data length. If the total amount that should be shifted is greater than the data length of appointment, then the result is undefined.

Notice that ring shift right n position is equivalent to ring shift left ElemSize-n position, ElemSize represents the figure place of data-oriented length here.VROUND gives up into the integer number with floating numberForm

The assembler syntax

VROUND.rm VRd，VRb

VROUND.rm SRd，SRb

Rm={ninf wherein, zero, near, pinf}. The pattern of supporting

D：S：M

V＜-V

S＜-S

Explanation

The content of the floating point data format of vector/scalar register Rb rounds off becomes immediate 32 integers (Word), and this result leaves among the vector/scalar register Rd. Rounding mode is stipulated in RM.

RM<1：0>	Pattern	Meaning
			00	ninf	Round off to-∞
01	zero	Round off to zero
			10	near	Round off to immediate even number
11	pinf	Round off to+∞

Operation

  for(i＝0：i＜NumElem：i++){

      Rd[i]＝Convert to int32(Rb[i])：

Unusual

Nothing. Programming is explained

This instruction is not subjected to the impact of element shielding.VSATL is saturated to lower boundForm

The 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

Dt={b wherein, b9, h, w}. Note counting immediately for 9 and do not support the .f data type. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)	float(f)

Explanation

Each data element of vector/scalar register Ra and its corresponding lower bound comparison check in vector/scalar register Rb or IMM field. If the value of data element less than this lower bound, then is configured to equal lower bound, and final result deposits vector/scalar register Rd in. Operation

  for(i＝0；i＜NumElem && EMASK[i]：i++){

      Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

      Rd[i]＝(Ra[i]＜Bop[i])？Bop[i]：Ra[i]；

Unusual

Nothing.VSATU is saturated to high limitForm

The assembler syntax

VSATU.dt VRd，SRa，SRb

VSATU.dt VRd，SRa，SRb

VSATU.dt VRd，SRa，# IMM

VSATU.dt SRd，SRa，SRb

VSATU.dt SRd，SRa，# IMM

Dt={b wherein, b9, h, w, f}. Note counting immediately for 9 and do not support the .f data type. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)	float(f)

Explanation

Each data element of vector/scalar register Ra and its corresponding high limit comparison check in vector/scalar register Rb or IMM field. If the value of data element then be configured to equal high limit, and final result deposits vector/scalar register Rd in greater than this high limit. Operation

 for(i＝0；i＜NumElem && EMASK[i]；i++){

     Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}：

     Rd[i]＝(Ra[i]＞Bop[i])？Bop[i]：Ra[i]；

Unusual

Nothing.VSHFL shufflesForm

The assembler syntax

VSHFL.dt  VRc，VRd，VRa，VRb

VSHFL.dt  VRc，VRd，VRa，SRb

Dt={b wherein, b9, h, w, f}. Notice that .w specifies identical operation with .f. The pattern of supporting

S	VRb	SRb
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Content and the Rb of vector registor Ra shuffle, and the result leaves vector registor Rc:Rd in, and is as shown below:Operation exception

Nothing. Programming is explained

The element shielding is not used in this instruction.VSHFLH shuffles a high positionForm

The assembler syntax

VSHFLH.dt VRd，VRa，VRb

VSHFLH.dt VRd，VRa，SRb

Dt={b wherein, b9, h, w, f]. Notice that .w specifies identical operation with .f. The pattern of supporting

S	VRb	SRb
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Content and the Rb of vector registor Ra shuffle, and result's high-order portion leaves vector registor Rd in, and is as shown below:

Operation exception

Nothing. Programming is explained

The element shielding is not used in this instruction.VSHFLL shuffles low levelFormThe assembler syntax

VSHFLL.dt VRd，VRa，VRb

VSHFLL.dt VRd，VRa，SRb

Dt={b wherein, b9, h, w, F}. Notice that .w and .f specify same operation. The pattern of supporting

S	VRb	SRb
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

Content and the Rb of vector registor Ra shuffle, and result's low portion leaves vector registor Rd in, and is as shown below:Operation exception

Nothing. Programming is explained

The element shielding is not used in this instruction.The VST storageForm

The assembler syntax

VST.st Rs，SRb，SRi

VST.st Rs，SRb，# IMM

VST.st Rs，SRb+，SRi

VST.st Rs，SRb+，# IMM

St={b wherein, b9t, h, w, 4,8,16,32,64}, Rs={VRs, VRAs, SRs}. Note .b and the identical operation of .b9t indication .64 and VRAs can not be specified together. VSTOFF is used in storage to Cache-off. Explanation

Store a vector or scalar register. Operation

EA＝SR _b+{SR _i‖Sex(IMM<7：0>)}；

if(A＝1)SR _b＝EA；

MEM[EA]=see the following form:

ST	Storage operation
		.b	BYTE[EA]＝SR s<7：0>
.h	HALF[EA]＝SR s<15：0>
		.w	WORD[EA]＝SR s<31：0>
.4	BYTE[EA+i]＝VR s<9i+7：9i>i＝0 to 3
		.8	BYTE[EA+i]＝VR s<9i+7：9i>，i＝0 to 7
.16	BYTE[EA+i]＝VR s<9i+7：9i>，i＝0 to 15
		.32	BYTE[EA+i]＝VR s<9i+7：9i>，i＝0 to 31
.64	BYTE[EA+i]＝VR 0s<9i+7：9i>，i＝0 to 31 BYTE[EA+32+i]＝VR 1s<9i+7：9i>，i＝0 to 31

Unusually

Invalid data address, the access that does not line up. Programming is explained

This instruction is not subjected to the impact of element shielding.VSTCB stores cyclic buffer intoFormThe assembler syntax

VSTCB.st Rs，SRb，SRi

VSTCB.st Rs，SRb，# IMM

VSTCB.st Rs，SRb+，SRi

VSTCB.st Rs，SRb+，# IMM

St={b wherein, b9t, h, w, 4,8,16,32,64}, Rs={VRs, VRAs, SRs}. Note .b and the identical operation of .b9t indication .64 and VRAs can not be specified together. Cache-off is used VSTCBOFF. Explanation

Store vector or scalar register into from cyclic buffer, the border of cyclic buffer is by SR_b+1In BEGIN pointer and SR_b+2In the END pointer determine.

Before upgrading operation in storage and address, if effective address greater than the END address, then it will be adjusted. In addition, must be respectively and the boundary alignment of halfword and word to the border of .h and .w scalar loaded cycle buffer. Operation

EA＝SR _b+{SR _i‖sex(IMM<7：0>)}；

BEGIN＝SR _b+1；

EMD＝SR _b+2；

cbsize＝END-BEGIN；

if(EA＞END)EA＝BEGIN+(EA-END)；

if(A＝1)SR _b＝EA；

MEM[EA]=see the following form:

ST	Storage operation
		.b	BYTE[EA]＝SR s<7：0>；
.h	HALF[EA]＝SR s<15：0>；
		.w	WORD[EA]＝SR s<31：0>；
.4	BYTE[(EA+i＞END)？EA+i-cbsize：EA+i]＝VR s<9i+7：9i>，i＝0 to 3
		.8	BYTE[(EA+i＞END)？EA+i-cbsize：EA+i]＝VR s<9i+7：9i>，i＝0 to 7
.16	BYTE[(EA+i＞END)？EA+i-cbsize：EA+i]＝VR s<9i+7：9i>，i ＝ 0 to 15
		.32	BYTE[(EA+i＞END)？EA+i-cbsize：EA+i]＝VR s<9i+7：9i>，i＝0 to 31
.64	BYTE[(EA+i＞END)？EA+i-cbsize：EA+i]＝VR 0s<9i+7：9i>，i＝0 to 31 BYTE[(EA+32+i＞END)？EA+32+i-cbsize：EA+32+i]＝ VR 1s<9i+7：9i>， i＝0 to 31

Unusually

Invalid data address, unjustified access. Programming is explained

This instruction is not subjected to the impact of element shielding.

Programmer must determine following condition so that this instruction by desirable work:

BEGIN＜EA＜2*END-BEGIN

That is, EA＞BEGIN and EA-END＜END-BEGINThe two storages of VSTDFormThe assembler syntax

VSTD.st Rs，SRb，SRi

VSTD.st Rs，SRb，# IMM

VSTD.st Rs，SRb+，SRi

VSTD.st Rs，SRb+，# IMM

St={b wherein, b9t, h, w, 4,8,16,32,64}, Rs={VRs, VRAs, SRs}. Notice that .b specifies identical operation with .b9t .64 and VRAs can not be specified together. VSTDOFF is used in storage to Cache-off. Explanation

Storage comes two vector registors or two scalar registers since current or alternate sets. Operation

EA＝SR _b+{SR _i‖sex(IMM<7：0>)}；

if(A＝1)SR _b＝EA；

MEM[EA]=see the following form:

ST	Storage operation
		.b	BYTE[EA]＝SR s<7：0>  BYTE[EA+1]＝SR s+1<7：0>
.h	HALF[EA]＝SR s<15：0>  HALF[EA+2]＝SR s+1<15：0>
		.w	WORD[EA]＝SR s<31：0>  WORD[EA+4]＝SR s+1<31：0>
.4	BYTE[EA+i]＝VR s<9i+7：9i>，i＝0 to 3  BYTE[EA+4+i]＝VR s+1<9i+7：9i>，i＝0 to 3
		.8	BYTE[EA+i]＝VR s<9i+7：9i>，i＝0 to 7  BYTE[EA+8+i]＝VR s+1<9i+7：9i>，i＝0 to 7
.16	BYTE[EA+i]＝VR s<9i+7：9i>，i＝0 to 15  BYTE[EA+16+i]＝VR s+1<9i+7：9i>，i＝0 to 15

ST	Storage operation
		.32	BYTE[EA+i]＝VR s<9i+7：9i>，i＝0 to 31   BYTE[EA+32+i]＝VR s+1<9i+7：9i>，i＝0 to 31
.64	BYTE[EA+i]＝VR 0s<9i+7：9i>，i＝0 to 31   BYTE[EA+32+i]＝VR 1s<9i+7：9i>，i＝0 to 31   BYTE[EA+64+i]＝VR 0s+1<9i+7：9i>，i＝0 to 31   BYTE[EA+96+i]＝VR 1s+1<9i+7：9i>，i＝0 to 31

Unusually

Invalid data address, unjustified access. Programming is explained

This instruction is not subjected to the impact of element shielding.VSTQ four storagesForm

The assembler syntax

VSTQ.st Rs，SRb，SRi

VSTQ.st Rs，SRb，# IMM

VSTQ.st Rs，SRb+，SRi

VSTQ.st Rs，SRb+，# IMM

St={b wherein, b9t, h, w, 4,8,16,32,64}, Rs={VRs, VRAs, SRs}. Notice that .b specifies identical operation with .b9t .64 and VRAs can not be specified together. VSTQOFF is used in storage to Cache-off. Explanation

Storage is from four vector registors or four scalar registers of current or alternate sets. Operation

EA＝SR _b+{SR _i‖sex(IMM<7：0>)}；

if(A＝1)SR _b＝EA；

MEM[EA]=see the following form:

ST	Storage operation
		.b	BYTE[EA]＝SR s<7：0> BYTE[EA+1]＝SR s+1<7：0> BYTE[EA+2]＝SR s+2<7：0> BYTE[EA+3]＝SR s+3<7：0>
.h	HALF[EA]＝SR s<15：0> HALF[EA+2]＝SR s+1<15：0> HALF[EA+4]＝SR s+2<15：0> HALF[EA+6]＝SR s+3<15：0>
		.w	WORD[EA]＝SR s<31：0> WORD[EA+4]＝SR s+1<31：0> WORD[EA+8]＝SR s+2<31：0> WORD[EA+12]＝SR s+3<31：0>

ST	Storage operation
		.4	BYTE[EA+i]＝VR s<9i+7：9i>，i＝0 to 3   BYTE[EA+4+i]＝VR s+1<9i+7：9i>，i＝0 to 3   BYTE[EA+8+i]＝VR s+2<9i+7：9i>，i＝0 to 3   BYTE[EA+12+i]＝VR s+3<9i+7：9i>，i＝0 to 3
.8	BYTE[EA+i]＝VR s<9i+7：9i>，i＝0 to 7   BYTE[EA+8+i]＝VR s+1<9i+7：9i>，i＝0 to 7   BYTE[EA+16+i]＝VR s+2<9i+7：9i>，i＝0 to 7   BYTE[EA+24+i]＝VR s+3<9i+7：9i>，i＝0 to 7
		.16	BYTE[EA+i]＝VR s<9i+7：9i>，i＝0 to 15   BYTE[EA+16+i]＝VR s+1<9i+7：9i>，i＝0 to 15   BYTE[EA+32+i]＝VR s+2<9i+7：9i>，i＝0 to 15   BYTE[EA+48+i]＝VR s+3<9i+7：9i>，i＝0 to 15
.32	BYTE[EA+i]＝VR s<9i+7：9i>，i＝0 to 31   BYTE[EA+32+i]＝VR s+1<9i+7：9i>，i＝0 to 31   BYTE[EA+64+i]＝VR s+2<9i+7：9i>，i＝0 to 31   BYTE[EA+96+i]＝VR s+3<9i+7：9i>，i＝0 to 31
		.64	BYTE[EA+i]＝VR 0s<9i+7：9i>，i＝0 to 31   BYTE[EA+32+i]＝VR 1s<9i+7：9i>，i＝0 to 31   BYTE[EA+64+i]＝VR 0s+1<9i+7：9i>，i＝0 to 31   BYTE[EA+96+i]＝VR 1s+1<9i+7：9i>，i＝0 to 31   BYTE[EA+128+i]＝VR 0s+2<9i+7：9i>，i＝0 to 31   BYTE[EA+160+i]＝VR 1s+2<9i+7：9i>，i＝0 to 31   BYTE[EA+192+i]＝VR 0s+3<9i+7：9i>，i＝0 to 31   BYTE[EA+224+i]＝VR 1s+3<9i+7：9i>，i＝0 to 31

Unusually

Invalid data address, unjustified access. Programming is explained

This instruction is not subjected to the impact of element shielding.VSTR oppositely storesFormThe assembler syntax

VSTR.st Rs，SRb，SRi

VSTR.st Rs，SRb，#IMM

VSTR.st Rs，SRb+，SRi

VSTR.st Rs，SRb+，#IMM

St={4 wherein, 8,16,32,64}, Rs={VRs, VRAs}. Notice that .64 and VRAs can not be specified together. VSTROFF is used in storage to Cache-off. Explanation

Press inverse element sequential storage vector registor. The scalar data source register is not supported in this instruction. Operation

EA＝SR _b+{SR _i‖sex(IMM<7：0>)}；

if(A＝1)SR _b＝EA；

MEM[EA]=see the following form:

ST	Storage operation
		.b	BYTE[EA+i]＝VR s[31-i]<7：0>，for i＝0 to 31
.h	HALF[EA+i]＝VR s[15-i]<15：0>，for i＝0 to 15
		.w	WORD[EA+i]＝VR s[7-i]<31：0>，for i＝0 to 7
.4	BYTE[EA+i]＝VR s[31-i]<7：0>，i＝0 to 3
		.8	BYTE[EA+i]＝VR s[31-i]<7：0>，i＝0 to 7
.16	BYTE[EA+i]＝VR s[31-i]<7：0>，i＝0 to 15
		.32	BYTE[EA+i]＝VR s[31-i]<7：0>，i＝0 to 31
.64	BYTE[EA+32+i]＝VR 0s[31-i]<7：0>，i＝0 to 31 BYTE[EA+i]＝VR 1s[31-i]<7：0>，i＝0 to 31

Unusually

Invalid data address, unjustified access. Programming is explained

This instruction is not subjected to the impact of element shielding.The storage of VSTWS spanForm

The assembler syntax

VSTWS.st Rs，SRb，SRi

VSTWS.st Rs，SRb，# IMM

VSTWS.st Rs，SRb+，SRi

VSTWS.st Rs，SRb+，# IMM

St={8 wherein, 16,32}, Rs={VRs, VRAs}. Note not supporting the .64 pattern, substitute with VST. VSTWSOFF is used in storage to Cache-off. Explanation

From effective address, use scalar register SR_b+1As the span control register, 32 bytes from vector registor VRs to memory stores.

ST indication block size, from the consecutive word joint number of each piece storage. SR_b+1The initial byte number of indication stride, two continuous blocks of separation.

Stride must be equal to or greater than block size. EA must align data length. Stride and block size must be most according to length. Operation

EA＝SR _b+{SR _i‖sex(IMM<7：0>)}；

if(A＝1)SR _b＝EA；

Block-size＝{4‖8‖16‖32}；

Stride＝SR _b+1<31：0>；

for(i＝0；i＜VECSIZE/Block-size；i++)

for(j＝0；j＜Block-size；j++)

BYTE[EA+I ^*Stride+j]＝VRs{i ^*Block-size+j}＜7:0 〉; Unusually

Invalid data address, unjustified access.VSUB subtractsFormThe assembler syntax

VSUB.dt VRd，VRa，VRb

VSUB.dt VRd，VRa，SRb

VSUB.dt VRd，VEa，# IMM

VSUB.dt SRd，SRa，SRb

VSUB.dt SRd，SRa，# IMM

Dt={b wherein, b9, h, w, f}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@f	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)	float(f)

Explanation

Deduct the content of vector/scalar register Rb from the content of vector/scalar register Ra, its result leaves among the vector/scalar register Rd. Operation

     for(i＝0；i＜NumElem && EMASK[i]；i++){

         Bop[i]＝{Rb[i]‖SRb‖sex(IMM<8：0>)}；

         Rd[i]＝Ra[i]-Bop[i]；

Unusual

Overflow the operand that floating-point is invalid.VSUBS subtracts and setForm

The assembler syntax

VSUBS.dt SRd，SRa，SRb

VSUBS.dt SRd，SRa，# IMM

Dt={b wherein, b9, h, w, f}. The pattern of supporting

D：S：M				S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)	float(f)

Explanation

Deduct SRb from SRa; The result deposits SRd in, and the VFLAG position among the VCSR is set. Operation

Bop＝{SRb‖sex(IMM<8：0>)}；

SRd＝SRa-Bop；

VCSR＜lt, eq, gt 〉=status (SRa-Bop); Unusually

Overflow the operand that floating-point is invalid.VUNSHFL goes to shuffleForm

The assembler syntax

VUNSHFL.dt VRc，VRd，VRa，VRb

VUNSHFL.dt VRc，VRd，VRa，SRb

Dt={b wherein, b9, h, w, f}. Note .w and the identical operation of .f indication. The pattern of supporting

S	VRb	SRb
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

The content of vector registor VRa and Rb go to shuffle and send into vector registor VRc:VRd, and be as follows:

Operation exception

Nothing. Programming is explained

The element shielding is not used in this instruction.VUNSHFLH goes to shuffle a high positionForm

The assembler syntax

VUNSHFLH.dt VRd，VRa，VRb

VUNSHFLH.dt VRd，VRa，SRb

Dt={b wherein, b9, h, w, f}. Note .w and the identical operation of .f indication. The pattern of supporting

S	VRb	SRb
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

The content of vector registor VRa and Rb are gone to shuffle; Result's high-order portion turns back to vector registor VRd, and is as follows:Operation exception

Nothing. Programming is explained

The element shielding is not used in this instruction.VUNSHFLL removes to shuffle low levelFormThe assembler syntax

VUNSHFLL.dt VRd，VRa，VRb

VUNSHFLL.dt VRd，VRa，SRb

Dt={b wherein, b9, h, w, f}. Notice that .w specifies identical operation with .f. The pattern of supporting

S	VRb	SRb
					DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

The content of vector registor VRa and Rb are gone to shuffle; Result's low portion turns back to vector registor VRd, and is as follows:

Operation exception

Nothing. Programming is explained

The element shielding is not used in this instruction.The VWBACK write-backForm

The assembler syntax

VWBACK.ln SRb，SRi

VWBACK.ln SRb，# IMM

VWBACK.ln SRb+，SRi

VWBACK.ln SRb+，# IMM

Ln={1 wherein, 2,4,8}. Explanation

Its index is capable by (opposite with those of EA coupling with its label) Cache of the EA appointment among the vector data Cache, comprises the data of revising such as it, then is updated in the memory. If capable designated more than a Cache, when they comprise the data of revising, the capable memory that is updated to of back Cache in succession. The number that Cache is capable is specified as follows:

LN＜1:0 〉=00: the Cache that writes 1 64 byte is capable

LN＜1:0 〉=01: the Cache that writes 2 64 bytes is capable

LN＜1:0 〉=10: the Cache that writes 4 64 bytes is capable

LN＜1:0 〉=11: the Cache that writes 8 64 bytes is capable

If effective address does not drop on the border of 64 bytes, then it at first block with the boundary alignment of 64 bytes. Operation exception

Invalid data address anomalous event. Programming is explained

EA＜31:0〉point out the byte address in the local memory.VWBACKSP is from the scratchpad memory write-backForm

The assembler syntax

VWBACKSP.ln SRp，SRb，SRi

VWBACKSP.ln SRp，SRb，# IMM

VWBACKSP.ln SRp，SRb+，SRi

VWBACKSP.ln SRp，SRb+，# IMM

Ln={1 wherein, 2,4,8}. Notice that VWBACK uses identical command code with VWBACKSP. Explanation

Transmit the piece of a plurality of 64 bytes from scratchpad memory to memory. Effective address provides the initial address of memory, and SRp provides the initial address of scratchpad memory. The number of 64 block of bytes is specified as follows:

LN＜1:0 〉=00: the piece that transmits 1 64 byte

LN＜1:0 〉=01: the piece that transmits 2 64 bytes

LN＜1:0 〉=10: the piece that transmits 4 64 bytes

LN＜1:0 〉=11: the piece that transmits 8 64 bytes

If effective address does not drop on the border of 64 bytes, then it at first block with the boundary alignment of 64 bytes. If the pointer address of the scratchpad memory among the SRp does not drop on the border of 64 bytes, also to block and and and the boundary alignment of 64 bytes. The pointer address of the scratchpad memory of alignment increases with the byte number that transmits. Operation

  EA＝SRb+{SRi‖sex(IMM<7：0>)}；

  if(A＝1)SRb＝EA；

  Num_bytes＝{64‖128‖256‖512}；

  Mem_adrs＝EA<31：6>：6b’000000；

  SRp＝SRp<31：6>：6b’000000；

  for(i＝0；i＜Num_bytes；i++)

SPAD[SRp++]=MEM[Mem_adrs+i]; Unusually

Invalid data address anomalous event.The VXNOR XNORFormThe 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

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

The content of the content of vector/scalar register Ra and vector/scalar register Rb is carried out the logic XNOR, and the result deposits among the vector/scalar register Rd. Operation

    for(i＝0；i＜NumElem && EMASK[i]；i++){

        Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

        Rd[i]<k>＝-(Ra[i]<k>^Bop[i]<k>)，for k＝all bits in element i；

Unusual

Nothing.The VXOR XORFormThe 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

Dt={b wherein, b9, h, w}. The pattern of supporting

D：S：M	V＜-V@V	V＜-V@S	V＜-V@I	S＜-S@S	S＜-S@I
						DS	int8(b)	int9(b9)	int16(h)	int32(w)

Explanation

The content of the content of vector/scalar register Ra and vector/scalar register Rb is carried out the logic XOR, and the result deposits vector/scalar register Rd in. Operation

      for(i＝0；i＜NumElem && EMASK[i]；i++){

          Bop[i]＝{VRb[i]‖SRb‖sex(IMM<8：0>)}；

          Rd[i]<k>＝Ra[i]<k>^Bop[i]<i>，for k＝all bits in element i；

Unusual

Nothing.The whole elements of VXORALL XORFormThe assembler syntax

VXORALL.dt SRd，VRb

Dt={b wherein, b9, h, w}. Notice that .b specifies identical operation with .b9. The pattern of supporting

DS

int8(b)

int9(b9)

int16(h)

int32(w)

Explanation

The least significant bit of each element is together by XOR among the VRb, and 1 result turns back on the least significant bit of SRd. This instruction is not subjected to the impact of element shielding. Operation exception

Nothing.

Claims (9)

1. processor comprises:

A scalar register is suitable for storing single scalar value;

A vector registor is suitable for storing a plurality of data elements; With

Treatment circuit, it is connected to described scalar register and described vector registor, wherein this treatment circuit is carried out multiple operation concurrently in response to single instruction, and a data element in every kind of described vector registor of operation handlebar combines with the described scalar value in the described scalar register.

2 one kinds of operation processing circuits comprise to carry out the method for instruction:

Read to consist of the register data element of vector value component; With

Carry out parallel work-flow, this operation handlebar scalar value combines with each data element, to produce vector result.

3 methods as claimed in claim 2, the described parallel work-flow of wherein carrying out comprises multiplies each other described scalar value with each described data element, to produce the vector data result.

4. method as claimed in claim 2, the described parallel work-flow of wherein carrying out comprise described scalar value are added on each described data element, to produce the vector data result.

5. method as claimed in claim 2 also comprises and reads described scalar value to combine with described data element from the second register, and wherein this second register is suitable for storing single scalar value.

6. method as claimed in claim 2 also comprises and extracts described scalar value to combine with described data element from instruction.

7. the method for an Operation Processor comprises:

Scalar register and vector registor are provided in described processor, and wherein each scalar register is suitable for storing single scalar value, and each vector registor is suitable for storing a plurality of data elements that consist of component of a vector;

Be assigned to a register number to each scalar register, this register number is different from the register number that is assigned to other scalar register;

Be assigned to a register number to each vector registor, this register number is different from the register number that is assigned to other vector registor, and at least some register number that wherein is assigned to described vector registor is identical with the register number that is assigned to described scalar register;

Form an instruction, this instruction comprises first operand and second operand, and wherein first operand is the register number of sign scalar register, and second operand is the register number of mark vector register; With

Carry out described instruction with at transferring data by the described scalar register of described first operand sign and between by the data element in the described vector registor of described second operand sign.

8. method as claimed in claim 7, wherein:

The described instruction that forms also comprises the 3-operand for the data element that is identified at a vector; Wherein

Carry out described instruction with at transferring data by the described scalar register of described first operand sign and between by the data element of the described 3-operand sign in the described vector registor of described second operand sign.

9. method as claimed in claim 7, wherein:

The described instruction that forms also comprises the 3-operand for sign the second scalar register; Wherein

Carry out described instruction with transferring data between the data element in the described vector registor that identifies at the described scalar register that is identified by described first operand with by described second operand and identified by the value for storage in described second scalar register.

Images