Digital signal processor architecture with an ALU and a serial processing section operating in parallel
This application is related to commonly-owned, concurrently filed applications entitled &#34;Microinstruction Sequencer Capable of Instructing Arithmetic, Logical and Data Move Operations in a Conditional Manner&#34; (Pat. #4,891,754), &#34;Serial Arithmetic Processor&#34; (Pat. #4,858,163), and Parallel Arithmetic-Logic Unit for Use as an Element of a Digital Signal Processor (Pat. # 4,888,722) all of which are hereby incorporated by reference herein. 
     BACKGROUND 
     This invention relates to digital signal processing microchips (DSP&#39;s) and more particularly to the architecture of a digital signal processor embodied in a single very large scale integrated silicon chip (VLSI) which is capable of conducting adapative differential pulse code modulation (ADPCM) telecommunication algorithms. 
     Digital signal processors have been known in the art for some time. (See e.g., L. Robert Morris, &#34;Digital Signal Processing Microprocessors: Forward to the Past?&#34; IEEE MICRO, Vol. 6, No. 6, pp. 6-8, December 1986). Typically they are high speed reduced instruction set devices which are capable of carrying out limited tasks such as addition, subtraction, multiplication, division, and shifting operations in a much quicker time frame then the slower, more powerful microprocessors. The DSP&#39;s of the art typically include a microinstruction sequencer (MIS) including a read only memory (ROM), a random access memory RAM, an arithmetic-logic unit (ALU), a high speed multiplier, and related storage registers. The MIS typically acts to control the functioning of the DSP. The ALU typically performs arithmetic and logic functions under the control of the DSP. The RAM is used to store values which are sent to the DSP from circuitry exterior to the DSP as well as values which are computed by the ALU or directly generated in the ROM of the MIS. The registers are typically used as input or output storage for each of the elements of the DSP. 
     While the combination of a MIS, a RAM, a multiplier, and an ALU in a DSP permit a DSP to perform a wide range of functions in an efficient manner, it will be appreciated that complex algorithms such as the ADPCM algorithm are not as easily accommodated by such an arrangement. Indeed, in attempting to perform the ADPCM algorithm with the DSP&#39;s of the art, several DSP&#39;s have had to be utilized. 
     SUMMARY OF THE INVENTION 
     It is therefore an object of the invention to provide a digital signal processor architecture which can accommodate the performance of functions and algorithms of a complex nature. 
     It is a further object of the invention to provide a digital signal processor capable of performing at least one ADPCM algorithm wherein the digital signal processor is embodied in a single VLSI. 
     It is another object of the invention to provide a digital signal processor having an arithmetic processor and an ALU wherein the arithmetic processor conducts repetitively used mathematically complex functions through the use of hardware. 
     In accord with the objects of the invention, a digital signal processor is provided and comprises: 
     (a) a microinstruction sequencer for controlling the functioning of the digital signal processor, including a coded ROM, means for addressing the ROM, means for decoding the ROM code into control and data signals, and means for sending the control and data signals to desired locations; 
     (b) an arithmetic-logic unit (ALU) for performing arithmetic and logic functions under the control of said control code; and 
     (c) an arithmetic processor means for conducting under the control of said control code complex arithmetic functions; 
     (d) a RAM for receiving and storing data which is sent to the RAM under control of said control signals from at least one of said microinstruction sequencer, said ALU, said arithmetic processor means, and circuitry exterior to said digital signal processor, and for sending data to at least one of said ALU, said arithmetic processor means, said microinstruction sequencer and said circuitry exterior to said digital signal processor under control of said control signals; and 
     (e) a data bus capable of being written to and read by said arithmetic processor means, said ALU means, said microinstruction sequencer, and said RAM means. 
     Preferably, the microinstruction sequencer, the RAM, the ALU, and the arithmetic processor all include registers at their input and/or output for storing data which has been or is to be processed and/or for controls. Because the RAM, ALU and arithmetic processor are all controlled by the MIS, they are all connected thereto. Likewise, because the MIS, the ALU, and the arithmetic processor all receive data from and are capable of writing to the RAM, they and the RAM are interconnected via the data bus. Moreover, preferably, the arithmetic processor and arithmetic logic unit are capable of functioning in parallel so that algorithms with arithmetically complex functions may be conducted in an expeditious manner. 
     The entire digital signal processor preferably shares the VLSI chip in which it is embodied with an input/output section. The I/O section interfaces the DSP with the &#34;outside world&#34; such as with one or more buses carrying telecommunication data as well as with user control lines where an ADPCM algorithm is to be implemented. In this manner data to be encoded or decoded is received by the DSP, properly processed, and then sent to its proper destination outside of the DSP. Likewise, &#34;external&#34;  flags may be set by a user or system to help control various aspects of the MIS. 
    
    
     Other objects, features, and advantages of the invention will become apparent to those skilled in the art upon reference to the following detailed description of the invention and the accompanying drawings. 
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 shows the placement of FIGS. 1A, 1B and 1C which are block diagrams of the digital signal processor of the invention in conjunction with an I/O section of the VLSI on which the digital signal processor is implemented; 
     FIGS. 2a-2e are top level flow diagrams for accomplishing the ADPCM algorithm with the DSP of the invention; 
     FIG. 3 shows the placement of FIGS. 3A and 3B which are block diagrams of the microinstruction decoder of the microinstruction sequencer of the digital signal processor of FIG. 1; 
     FIG. 4 is a timing diagram for the MIS of the DSP of FIG. 1; 
     FIG. 5 is a simplified block diagram of the serial arithmetic processor of the DSP of FIG. 1; 
     FIG. 6 shows the placement of FIGS. 6A and 6B which are block diagrams of the first common means of the serial arithmetic processor of the DSP of FIG. 5; 
     FIG. 7 is a timing diagram of the first common means of FIG. 6; 
     FIG. 8 shows the placement of FIGS. 8A, 8B and 8C which are logic diagrams of an alternative embodiment shifter for the first common means of FIG. 6; 
     FIG. 9 shows the placement of FIGS. 9A, 9B and 9C which are block diagrams of the second common means of the serial arithmetic processor of FIG. 5; 
     FIG. 10a is a timing diagram for carrying out an eight by fourteen bit signed mangitude multiplication in the second common means of FIG. 9; and 
     FIG. 10b is a timing diagram for carrying out a floating point multiplication in the second common means of FIG. 9. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     The digital signal processor 10 of the invention basically comprises a microinstruction sequencer 20 having a ROM 25, a parallel-arithmetic logic unit (PALU) 40, a data RAM section 60, and a serial arithmetic processor 70. Because at least the microinstruction sequencer, the arithmetic-logic unit and the serial arithmetic processor each contain novel arrangements, the detals of each will be set forth hereinafter in separate sections. However, how these elements interact with each other to provide a unique DSP, and how the ADPCM algorithm may be expeditiously implemented therein is the focus of this separate invention. 
     Before focusing on the elements of the DSP, it is noted that the DSP does not function in a void. Thus, a data and control input/output section 80 is provided on the VLSI with the DSP and interfaces the DSP to other circuits. It will be appreciated, however, that the functioning of the DSP is not dependent on the data and control I/O structure. Indeed, depending on the desired application of the DSP, different I/O structures would be desired. 
     For purpose of example, the DSP of the invention is described herein with reference to performing the ADPCM algorithm. Thus, the I/O section includes: a PCM serial input data port 82 for receiving a mu-law or A-law compressed PCM bit stream in accod with CCITT Recommendation G.711; an ADPCM serial input data port 84 for receiving an ADPCM bit stream; clock circuitry 86 for synchronizing and controlling the DSP clocking; a PCM serial output data port 90 for transmitting a reconstructed PCM bit stream; an ADPCM serial output data port 92 for transmitting an ADPCM bit stream; and self test control circuitry 96 for testing the functioning of the DSP. In addition, the I/O section includes three flag inputs 88 for selecting eight possible algorithms as set forth with reference to FIG. 2b, and a law flag for selecting the PCM law to be followed (A-law or mu-law). Also, internal encode and decode flags are generated in response to external synchronization information and respectively control the encode and decode cycles of the DSP. The flags are sent as inputs to the microsequencer controller 32 of the MIS 20 so that the microsequencer controller can perform conditional branch, conditional arithmetic, conditional logical, and conditional data move operations. 
     While the MIS of the DSP is controlled to a certain extent by the supplied flags, it will be appreciated that the DSP is able to control the I/O 80 hardware through the microinstructions of the ROM in the MIS. As will be seen in detail hereinafter, two primary microinstructions of the MIS are used to control the two data input ports. These microinstructions are designated Move Port 1 (MVP1) and Move Port 2 (MVP2) and are used to input data from the data input ports 82 and 84 to a desired location in the DSP. In addition, in the secondary microinstruction field of the MIS, two microinstructions are provided for loading data ports 90 and 92 as well as three microinstructions for setting three self test flags. 
     Before returning to the elements of the DSP invention, it is instructive to review the ADPCM algorithm which is advantageously carried out by the DSP invention. The steps of the ADPCM algorithm may be seen by reference to the top level flow charts of FIGS. 2a-2e. With reference to FIG. 2a, upon receipt of an external reset signal, the DSP VLSI device performs at 100 a diagnostic check of the RAM section of the DSP. In performing the diagnostic test, other sections of the device such as the PALU and MIS sections are also exercised. If the test is successful, the external pin labelled &#34;DEVICE FAIL&#34; is set high at 104. If the test should fail, the DEVICE FAIL pin is left in the low condition at 102. Regardless, the reset routine continues and initializes both the encoder and decoder at 106 by setting the variables of the algorithm to predefined conditions. At 108 the reset routine enters the encode/decode arbiter where the program idles and waits for either an encode or decode flag to be set so as to trigger the encode or decode process. Where an encode flat is set, the routine continues as is shown in FIGS. 2b and 2c, whereas where the decode flag is set, the routine continues as is shown in FIGS. 2d and 2e. 
     Turning to FIGS. 2b and 2c where the encode flow diagrams show the main operations accomplished by the encoder, RAM page zero is selected at 110 as it is used exclusively by the encoder. The robbed-bit signalling flag (OVFLG), which is set in response to the external signalling frame signal SGNF it tested at 112. If the robbed-bit signalling flag is true (high), the software defined robbed-bit signalling flag RBS is set high (true) at 114. Otherwise, the RBS flag is set false (low) at 116. The RBS flag together wth the external flag inputs PTH, EXT, and NAM representing the external algorithm select inputs ALGSEL2, ALGSEL 1, and ALGSEL0, respectively, are at 118 used by the algorithm identification subroutine to determine the appropriate encoding algorithm and bit-rate to execute. For example, if the nominal bit-rate selected is thirty-two kbps, and if the RBS flat is true indicating that this frame should be processed for robbed-bit signalling, then the twenty-four kbps algorithm will be selected. This switching allows the signalling bit to be inserted into the shifted outgoing ADPCM data word in a controlled manner, where the signalling bit is inserted into the lsb position by the transmit ADPCM data port. On the other hand, if the RBS flag is false, the thirty-two kbps algorithm will be selected at 118. 
     According to the provided embodiment, the definition for the algorithm select bits used by the algorithm identification routine is as follows: 
     
         ______________________________________                                    
ALGSEL2 ALGSEL1   ALGSEL0    DESCRIPTION                                  
______________________________________                                    
0       0         0          32 kbps CCITT G.721                          
0       0         1          32 kbps ANSI (3/85)                          
0       1         0          40 kbps (reserved)                           
0       1         1          24 kbps                                      
1       0         0          32 kbps CCITT/ANSI                           
                             (7/86)                                       
1       0         1          32 kbps other                                
1       1         0          16 kbps (reserved)                           
1       1         1          PCM Pass-through                             
______________________________________                                    
 
    
     The algorithm identification carried out at 118 leaves software defined flags set. These flags are subsequently used by the encode subroutines to control the encode process. 
     Following the algorithm identification subroutine, the PCM input data port 82 is read at 120. The external flags PTH, EXT and NAM are tested at 122 to determine the pass-through condition. If the condition is true, the input PCM value is immediately output at 124 as the ADPCM data word via the ADPCM data output port 92, and a return from the encode routine is issued. In returning from the encode routine, the encode flag is cleared at 125 and control of the program returns to the encode/decode arbiter at 108. If the pass-through condition is false, the encode program continues by executing a series of subroutines. The detailed description of each of the subroutines is given in the ANSI Committee T1 &#34;Draft Proposed American Standard 32 kbps ADPCM Algorithm and Line Format,&#34; document No. T1/LB 81, July 23, 1986 which is hereby incorporated by reference herein. Thus, at 126, sections 6.2.1, 6.2.2, and 6.2.3 of the said document No. T1/LB 81 are executed. At 128, the inverse quantizer values, W[I(k)], and F[I(k)] are determined. At 130, the inverse adaptive quantizer routine (section 6.2.4) is called, while at 132, the signal reconstruct routine (section 6.2.7) is called. At 134 the adaptive predictor and tone transition detector sections (6.2,7 and 6.2.8) are called, with the quantizer scale factor adaptation speed control subroutine (section 6.2.6) being called from within the adaptive predictor routine. Upon return and completion of the predictor subroutine at 134, the RBS flag is interrogated at 138. If the flag is high (true), the value I is shifted one bit position to the left at 140 to allow the signalling bit to be inserted into the lsb position by the transmit ADPCM port 92. Regardless, the value I, whether shifted or not, is outpt to the ADPCM data port 92 at 142. The quantizer scale factor adaptation routine (section 6.2.5) is then called and executed at 144. Finally, the encode routine ends with the clearing of the encode flag at 146 and a return to the encode/decode arbiter which waits at 108. 
     Turning to FIGS. 2d and 2e, the shown decode flow diagrams outline the main operations accomplished by the decoder. Thus, at 148, page one of the RAM which is used exclusively by the decoder is selected. The robbed-bit signalling flag (OVFLG) which is set in response to the external signalling frame signal SGNF is tested at 152, and if true causes the robbed-bit signalling frame counter to be loaded a 150 with a value of 4096. Otherwise, at 154 the robbed-bit signalling frame counter is logically shifted one bit position to the left. The reason for maintaining a signalling frame counter arises from the need to determine the second frame following the occurrence of the signalling frame sync signal SGNF. 
     The robbed-bit signalling flag (OVFLG) together with the external flag inputs PTH, EXT, and NAM are then used at 155 by the algorithm identification subroutine (as previously described with reference to the encoder), which leaves software defined flags set. These flags are subsequently used by the decode subroutines to control the decode process. 
     Following the algorithm select routine, the PCM input data port 82 is read at 156. The external flags are then tested at 157 to determine whether the pass-through condition is present. If the condition is true, the input PCM value is immediately output at 158 as the PCM data word via the PCM output port 90 and a return from the decode routine is issued. In returning from the decode routine to the encode/decode arbiter waiting at 108, the decode flag is cleared at 159. If the pass-through condition is false, the msb of the robbed-bit signalling frame counter is tested at 160 for a value of one. If the msb has a value of one, the received I value is shifted at 162 by one bit position to the right to compensate for the fact that the lsb was used to convey signalling information. Regardless, the program continues and a series of subroutines defining the decode process are executed. It is of note that if the robbed-bit signalling flag is never set, the robbed-bit signalling frame counter will always be zero and the signalling frame condition will never be detected. It is also of note that if, for example, the selected bit rate is thirty-two kbps, that the algorithm will switch to the twenty-four kbps algorithm during the frame in which the msb of the robbed-bit frame counter is a value of one. 
     At steps 163, 164, and 165, the routines set forth at 128, 130, and 132 of the encoder algorithm are executed. Then at 166 and 167, the output PCM format conversion routine (section 6.3.6) and the synchronous coding adjustment routine (section 6.3.7) are called and executed. After the execution of the synchronous coding adjustment routine, the reconstructed PCM value is output at 168 to the PCM output data port. Then at 169, 170, and 171, the routines set forth at 134, 136, and 144 of the encoder algorithm are executed. Finally, the decode routine ends with the clearing of the decod flag at 172, and a return to the encode/decode arbiter which is waiting at 108. 
     Returning to the DSP invention shown in FIG. 1, the data RAM section 60 preferably includes a one hundred twenty-eight by sixteen bit RAM array 62, a sixteen bit input register 64 (Register C), a sixteen bit bidirectional buffer 66, and a controller 68. The one hundred twenty-eight by sixteen bit RAM array 252 is preferably organized into two sixty-four by sixteen bit pages. This arrangement is advantageous for the implementation of the ADPCM algorithm as the encoder for the algorithm is assigned page zero and the decoder is assigned page one. As will be seen with reference to the MIS, the microcode permits page zero or page one of the RAM to be selected, and locations within the selected page to be addressed from the data bus 39 as well as by direct memory addressing by the ROM operand. 
     The input register 64 to the RAM array 62 is sixteen bits in length and may be used as a temporary register or as an input register to the RAM array. Input register 64 (register C) is loaded by selection according to the command (REG C SEL/) of an operand of the MIS ROM 25. A bus 67 internal to the RAM section 60 allows the data to be output back to the primary DSP data bus 39 via the bidirectional buffer 66, or alternatively to be written into the RAM 62 through the application of a STORE Register C secondary microinstruction (described hereinafter with regard to the Microinstruction Sequencer). As the STORE microinstruction is a secondary microinstruction, it may be implemented concurrently with some other operation. 
     The sixteen bit bidirectional buffer 66 provides a gateway (i.e. buffer) between the data bus of the DSP and the internal bus of the RAM. The buffer 66 also provides a means of outputting data directly from Register C or the RAM 62 onto the DSP data bus 39 and for writing data directly from the DSP data bus into the RAM. These operations are supported by the MOVE REG C (MVC) and LOAD DATA MEMORY (LDM) microinstructions and the STORE data memory secondary microinstruction respectively, all of which are described hereinafter with regard to the MIS. Also, the STORE REG C secondary microinstruction is used to write data from Register C into the RAM. 
     As indicated in FIG. 1, ports 1 and 2 (84 and 82) are connected to the internal RAM bus 67, and data from these ports must pass through the buffer 66. The selection of ports 1 and 2 to control the RAM bus is made by the RAM controller by using the MA1 and MA0 controls. 
     Finally, with regard to the RAM section 60, the RAM controller 68 acts as the brain of the RAM section. The RAM controller provides the necessary clocking and timing signals to the RAM array 62, register C 64 and the bidirectional buffer 66. In addition, the RAM controller 68 arranges the RAM section such that the signals from the decoder of the MIS (e.g. update register C; write register C into RAM; output register C onto data bus; write RAM location onto data bus; write data bus to RAM location, etc.) may be implemented by the RAM section. Thus, the RAM controller 68 (MA0 and MA1 as control inputs) decodes the received signals so as to enable the RAM memory 62, select register C 64, select the the page of the RAM memory, etc. 
     THE SERIAL ARITHMETIC PROCESSOR 
     Turning to FIG. 5, a simplified block diagram of the serial arithmetic processor 70 capable of performing the LOG, FLOAT, ANTILOG, MULTIPLICATION, and FLOATING POINT MULTIPLICATION functions on incoming data as is required by the ADPCM algorithm is seen. Typically, a sixteen bit word is received by the processor 70 via a data bus, and the sixteen bits are stored in a register 72 (Register D). Depending on the various control signals received, and in accord with a clock signal, the contents of the register 72 are sent via a pre-shift multiplexer 420, to a first common means 430, or to the multiplier means 460 via a multiplicand register 450 or a multiplexer 454. Thus, if the contents of the register 72 are to be processed according to the LOG, FLOAT, or ANTILOG functions, a first common means 430 is loaded via the pre-shift multiplexer 420. On the other hand, if a MULTIPLICATION function is to be accomplished, the common multiplier 460 is loaded with the multiplier via the multiplexer 454 and the multiplicand register 450 is loaded with the multiplicand. As will be described in detail hereinafter, if a FLOATING POINT MULTIPLICATION is to be carried out, the multiplier must first be processed by the float converter 434 prior to being sent via multiplexer 454 to the common multiplier 460 (the multiplicand typically having already undergone such a conversion and being stored in a floating point format). 
     The manner in which data coming from the register 72 is pre-shifted by the pre-shift multiplexer 420 depends on control signals provided to the pre-shift multiplexer by a controller 470 seen in FIG. 6. The function of the data pre-shift multiplexer is to format the data via parallel bit selection so that common means can properly process the data to provide any of the required functions. Thus, the formatted data will be loaded into a first common means 430, which performs either a LOG, FLOAT, or ANTILOG function on the data as is suggested by boxes 432, 434, and 436. The particular manner in which the data is pre-shifted data is dependent on the function to be accomplished, and the pre-shift multiplexer 420 accomplishes the same under the control of the control signals. If the LOG 432 or ANTILOG 436 functions are utilized, the processed data is then sent out of the serial processor 70 via an output multiplexer 440 which formats the processed data. If the FLOAT 434 function is utilized, the processed data is output via output multiplexer 440 if the data undergoing the FLOAT function is not being used as the multiplier of a FLOATING POINT MULTIPLICATION. If the data undergoing the FLOAT function 434 is the multiplier of a FLOATING POINT MULTIPLICATION function, the processed floating point multiplier data is sent via multiplexer 454 to serial multiplier 460 such that it can be multiplied with the floating point multiplicand contained in register 450. 
     With either of the multiplication functions, the multiplicand register must be loaded with one word of data (the multiplicand) while a multiplier shift register of the multiplier 460 is loaded with a second word of data (the multiplier). The MULTIPLICATION and FLOATING POINT MULTIPLICATION functions may then be carried out by the second common (multiplier) means 460 which forwards the results to output multiplexer 440. However, as above-stated, in the FLOATING POINT MULTIPLICATION the multiplicand and multiplier are first converted via the FLOAT function in first common means 430 prior to being processed by second common means 460. Thus, a first word of data is processed by the first common means 430 to provide a floating point multiplicand which may be reentered into register 72 and stored in muliplicand register 450. A second word (the multiplier data) is then similarly processed. However, instead of reentering the information in register 72, the floating point multiplier is sent directly to the multiplier common means 460 via the multiplexer 454. 
     Before turning to FIG. 6, it is instructive to review the manner in which log conversions (LOG function), floating point conversions (FLOAT function), and antilog conversions (ANTILOG function) are accomplished algorithmically. In a log conversion (LOG), in accord with the ADPCM standards, an approximation is obtained by setting the integer part of the log equal to the exponent of the base two linear number (i.e. the digit of the left-most &#34;1&#34;), and setting the fractional part of the log (mantissa) equal to the remaining digits of the unsigned magnitude number. For example, if a unsigned number N is set as follows: 
     
         __________________________________________________________________________
0 0  0 0  0 0 0  0 0 0 0  1 1 1 0 1                                       
15                                                                        
  14 13                                                                   
       12 11                                                              
            10                                                            
              9  8 7 6 5  4 3 2 1 0                                       
2 2  2 2  2 2 2  2 2 2 2  2 2 2 2 2                                       
__________________________________________________________________________
 
    
     it is readily seen that the digit having the left-most &#34;1&#34; value is the 2 4  digit. The integer part of the log which is four bits long to accommodate all possible values in the sixteen bit word is therefore set to 0100 which is equal to the exponent value 4. The fractional part of the log which is preferably seven bits long is then set to the remaining digits with additional zeroes: i.e. 1101000. The log value for N is seen as the combination of the exponent and the mantissa: 0.100.1101000. 
     The log value for N may also be described and obtained by the following algorithm for a fifteen bit unsigned magnitude number: 
     
         ______________________________________                                    
EXP =         14 where 16384 &lt;= N                                         
              13 where 8192 &lt;= N &lt;= 16383                                 
              .                                                           
              .                                                           
              .                                                           
              1 where 2 &lt;= N &lt;= 3                                         
              0 where 0 &lt;= N &lt;= 1                                         
MANT = ((N &lt;&lt;7) &gt;&gt;EXP) AND 127                                            
______________________________________                                    
 
    
     Thus, LOG (N)=EXP&lt;&lt;7 OR MANT, where &lt;&lt; means shift left and &gt;&gt; means shift right. In finding the mantissa where the number N is shifted left by seven places and then shifted right by the number of places defined by the exponent value, with the resulting digits then being processed via a logical AND with the value 127 (1111111), it should be noted that the shifting occurs by originally placing the fractional point to the right of the 2 0  digit and then shifting. Thus, after shifting N left by seven places, the number appears as 111010000000. After shifting right by four places, the number appears as 11101000. Using a logical AND with 01111111, the value 01101000 or 1101000 is derived. It will be appreciated by those skilled in the art that the effect of using a logical AND of 01111111 with a supplied number is to nullify the exponent defining bit while permitting the bits following the exponent defining bit to maintain their values. 
     The FLOAT operation is similar in some respects to the LOG operation. Four bits are used to define the exponent, and the exponent value is set equal to the LOG exponent plus one, except for the case where the number is zero, and the exponents take the same zero value. The format of the mantissa differs significantly, however, as only six bits are required for the mantissa, and the mantissa value is essentially a truncated portion of the number itself. 
     The algorithm for obtaining a floating point value for a sixteen bit signed magnitude linear number is as follows: 
     
         ______________________________________                                    
SGN =        N &gt;&gt;15                                                       
MAG =        N AND 32767                                                  
EXP =        15 where 16384 &lt;= MAG                                        
             14 where 8192 &lt;= MAG &lt;= 16383                                
             .                                                            
             .                                                            
             .                                                            
             2 where 2 &lt;= MAG &lt;= 3                                        
             1 where MAG = 1                                              
             0 where MAG = 0                                              
MANT =       1 &lt;&lt;5 IF MAG = 0                                             
             (MAG&lt;&lt;6)&gt;&gt;EXP otherwise                                      
______________________________________                                    
 
    
     Thus, FLOAT (N)=SGN&lt;&lt;15+EXP&lt;&lt;6+MANT. Using the number 1000000000011101 (-29 in signed decimal), the FLOAT function may be obtained by first recognizing that the value of the number N is 29. The exponent would therefore be set to five (one greater than the base two position of the first &#34;1&#34; bit), or 101 in base two. With the exponent so set, the mantissa is determined by shifting the number left by six positions: 11101000000, and then by shifting right by the value of the exponent (5): 111010. The FLOAT number is set to the OR value of the following numbers: 
     
         ______________________________________                                    
SGN = 1000000000000000                                                    
               EXP = 101000000                                            
                            MANT = 111010                                 
______________________________________                                    
 
    
     such that the final number is 1000000101.111010. Those skilled in the art will appreciate that the original number 11101 (N) remains intact in the floating point representation as the purpose of the floating point representation is to essentially normalize the number N. The exponent is used to accomplish that normalization. It will also be appreciated that by shifting the number N left six places and then right by the value of the exponent, a mantissa of six bits in length containing the number N starting at its most significant will be obtained. 
     The ANTILOG function (log domain to linear domain conversion) is basically the inverse of the LOG function. The exponent value is determined, and a logic &#34;1&#34; is inserted into the bit position (two to the power of the exponent value) corresponding thereto. The mantissa is then positioned into the bit positions to the right of the bit position defined by the exponent. For example, the ANTILOG function of the log value 0100.1101000 is determined as follows: The exponent value 0100 is equivalent to the number four. Thus, a &#34;1&#34; is put in the two to the fourth bit position, and the mantissa 1101000 (or as much as will fit in the word) is located thereafter. The linear value becomes 0000000000011101. Reference to the LOG algorithm above shows that the same linear value produced the log value 0100.1101000 which was the starting value of this ANTILOG calculation. 
     Turning to FIGS. 6 and 7, a block and timing diagram of the first common means which contains circuitry for performing the LOG, FLOATING POINT, and ANTILOG functions is seen. The common means generally comprises a controller 470, and a bidirectional shift register 472. In the implementation of FIG. 6, a counter 474, an incrementer 476, and a zero detector 478 are all included for expeditiously determining exponent values for the LOG and FLOAT functions and for helping control the shift register in the ANTILOG function. In addition, a pre-shift multiplexer 420 is used to pre-shift the incoming data bits so as to expedite the execution of the functions. 
     The controller 470 of the common means 430 controls the pre-shift multiplexer 420 and other elements of the first common means 430, and is controlled itself by software for providing the processing of data according to the ADPCM algorithm. In particular, the controller 470 outputs two controlling select bits (IS1 and IS0) to the pre-shift multiplexer as a function of the particular function (LOG, FLOAT or ANTILOG) to be performed as well as a function of the zero detector 478 hereinafter described (and the msb of the log exponent E3 during the ANTILOG conversion). The control bits IS1 and IS0 direct data in register 72 though the proper sections of the pre-shift multiplexer 420 so that the data may be properly preprocessed (pre-shifted) to permit the functions to be expeditiously performed. Thus, as will be described in more detail hereinafter, if a LOG or FLOAT function is to be performed, the sixteen bits are preprocessed in sections A or B of the pre-shift multiplexer. If, on the other hand, an ANTILOG function is to be performed, the bits are preprocessed in sections C or D of the data pre-shift multiplexer 420. As will be appreciated from FIG. 6, the data being loaded in register D 72 is preferably in coordination with the control selects of the LOG, FLOAT, or ANTILOG functions of the controller 470. In this manner, by the time of the next clock cycle, the pre-shift multiplexer 420 will have received control information (IS1 and IS0) from the controller so that it will know how to preprocess the data. The control selects, however, may be applied at some time later after register D 72 has been loaded. In this case, the LOG, FLOAT, or ANTILOG functions will not begin until the application of the appropriate control select. 
     Two additional control bits (SS1 and SS0) from the controller 470 are used to direct the bidirectional shift register 472 to shift left or right, to hold or to load. Thus, in performing a FLOAT function, it is imperative to determine the location of the left-most bit with a value of &#34;1&#34;. One manner of making the determination is by presetting a counter such as counter 474 to the value fifteen, and decrementing the counter each time the sixteen bit number (the msb being the sign bit and not being used for this determination) is shifted one place to the left. The shift decrement operation is then repeated until a logic 1 appears in bit position fifteen of the shift register. The value of the counter 474 is then taken to correspond to the exponent value. 
     The preferred manner of determining the location of the left-most bit with the value of &#34;1&#34; is to logically OR the seven most significant bits (excluding the sign bit) of the sixteen bit word, as at 478 of FIG. 6. If the result of the logical OR provides a &#34;1&#34;, it is known that the left-most logic 1 appears in bits eight through fourteen. If the result of the logical OR 478 is a &#34;0&#34;, it is known that the left-most logic &#34;1&#34; appears in bits zero through seven. In this manner, the number of shift cycles is reduced as the sixteen bit word may be preshifted (using the data pre-shift multiplexer 420) by eight bit positions to the left when the OR gate value is &#34;1&#34;. Regardless, the output of zero detector 478 is sent to controller 470 (as MSB7) so that the proper pre-shifting and shifting decisions may be undertaken at the data format multiplexer 420 and shift register 472. 
     Finally, with regard to the controller 470 control signals, the controller outputs output select signals OS1 and OS0 to control the output multiplexer 440 in conjunction with the serial processor output enable signal SRL-EN generated externally of the serial processor. As will be discussed hereinafter, the output select signals permit the processed data to be properly formatted (i.e. post-processed) for output to a desired location. 
     In accord with FIGS. 6 and 7, the timing and flow of data for performing the LOG, FLOAT, and ANTILOG functions is as follows. During the first cycle, the selection of the LOG, FLOAT or ANTILOG function is accomplished by using external means (e.g. a microinstruction sequencer) to signal the controller 470. At the end of a first cycle, data is loaded in register 72 (Register D) which is selected by the external means. When the external means determines that a function is to be performed, the contents of Register D are sent to the bidirectional shift register 472 via the pre-shift multiplexer 420 by the end of the second cycle. Also, during cycle two, the counter 474 is loaded with an appropriate value (seven [15 bits-preshift of 8 bits] for the LOG or FLOAT operations, or the inverse value of the three least significant bits of the ANTILOG exponent). Cycles three through nine are used to shift data in the shift register and to decrement the counter 474 until the shift enable input into the controller 470 is disabled. From cycle ten onwards, data may be removed from the output data multiplexer 440. 
     Returning particularly to FIG. 6, if a LOG function is to be accomplished, the bits in register 72 are to be preprocessed in section A or B of the data pre-shift mux 420 depending on whether the a logic &#34;1&#34; is found in bits eight through fourteen of the data. This information is always available to the controller 470, as while the bits are in register 72, bits eight though fourteen are logically ORed at OR gate 478. The output of gate 478 is sent as a control input MSB7 into controller 470. If a &#34;1&#34; is found in bits seven trough fourteen, the fifteen bits occupying positions 0-14 pass through section A of pre-shift multiplexer 420, where bits fifteen and zero are set to zero, and bits 1-14 are kept intact. Also, the output of the zero detector 478 is used as the most significant exponent bit of the LOG function and is set to &#34;1&#34; as bit A10 of the output multiplexer 440 section A. This is in accord with the LOG algorithm where the value of the four bit exponent must be eight (binary 1000) or greater if a &#34;1&#34; is locate in bits 8-14. With bits 1-14 intact in the shift register, the register may be shifted left each clock cycle as long as the shift enable control signal to the controller 470 permits. Before the first shift left occurs, the bit occupying the msb position in the shift register 472 is read, and since bit fifteen was preset to zero, the shift enable input into controller 470 remains active. At the end of the cycle, the down counter 474 is decremented from its initial value of seven to six. As the first shift left occurs, the bit originally in the fourteen bit position moves into the fifteenth bit position (msb) of the shift register 472. If that bit is a &#34;1&#34;, AND gate 482 goes high because during a LOG function, the antilog enable control is high. With AND gate 482 high, OR gate 484 goes high, thereby informing the controller 470 via a high shift enable feedback that shifting should not continue. At the same time, the decrementing of the down counter 474 is disabled such that the value of six is maintained. With down counter 474 having a value of six, three bits corresponding to a value &#34;110&#34; would be at the output of the counter 474. These three bits would join the &#34;1&#34; bit which was output at zero detector 478 to form a digital exponent of &#34;1110&#34;; or &#34;14&#34; in decimal notation. It is clear that the maximum LOG exponent would be &#34;14&#34;, as the left-most logic &#34;1&#34; which was used for computing the LOG value was in the 2 14  bit position. Hence, the fifteenth bit was preprocessed in the data pre-shift multiplexer 420 to be a zero so that down counter 474 would be counted down by one so that the maximum exponent value of fourteen would be obtained. 
     If the fourteenth bit was not a &#34;1&#34;, it would be appreciated that the procedure of shifting and down counting would continue until a &#34;1&#34; occupied the msb of the shift register 472. At that point, the down counter value expressed digitally would be combined with the zero detector 478 output to provide the four bits representing the LOG exponent. Also, the bits then occupying the fourteenth through eighth bit positions of the shift register output would comprise the mantissa of the LOG value, as the mantissa as previously defined is taken as the seven bits following the left-most &#34;1&#34; value. Thus, as seen in section A of output multiplexer 440, the fourteenth through eighth bits of the shift register 472 are inserted into bit positions A6 through A0, and the complete LOG value is provided. By convention, the LOG value is expressed with sixteen bits: bits fifteen through eleven being set to zero; bits ten through seven being the exponent and bits six through zero being the mantissa. 
     If the original sixteen bit word which is to be expressed as a LOG does not have a &#34;1&#34; value in bit positions fourteen through eight, the zero detector 478 would register a &#34;0&#34;. That result would cause a zero to be located at bit A10 (the msb of the exponent) of the output multiplexer 440, and would also be sent to the controller 470 via the MSB7 control signal. The controller in turn would cause selects IS1 and IS0 to select the B section of the pre-shift multiplexer 420 to preprocess the word in register 72. Thus, the bits occupying bit locations seven through zero would be input into positions fifteen through eight of the shift register 472, and bit positions seven through zero would be set to values of zero. When the msb of the shift register 472 was read, if it was a &#34;1&#34;, the active low shift enable signal would be set high via AND gate 482 and OR gate 484 and the down counter 474 would be disabled. Thus, the down counter would read &#34;111&#34; (seven in decimal) as the original word had a &#34;1&#34; value in its seventh bit position. Because the msb of the exponent was already set to zero, the proper value would be obtained. The three bits from the counter 474 would then be entered as exponent bits A9 through A7 in the output multiplexer 440 as previously described, and the seven bit mantissa would also be obtained as previously described. It should be noted however, that when a preshifting of eight bits was provided by the pre-shift mux 420, the seven bit mantissa necessarily includes at least one zero which was not part of the original sixteen bit word but which was supplied by the pre-shift mux itself. 
     If the msb in the shift register 472 was a &#34;0&#34;, rather than a &#34;1&#34;, the down counter would be decremented at the end of the clock cycle, and the shift register would shift left. The sixth bit which was originally inserted into the fourteenth bit slot of the shift register 472 would then occupy the msb location and would be read as previously described. If it was also a &#34;0&#34;, the process would continue with the fifth bit, the fourth bit . . . until the down counter reached a value of zero. At that point, zero detector 486 would go high, forcing OR gate 484 to go high and causing the shift enable signal to signal the controller 470 to go high and disable further shifting. An exponent value of 0000 and a mantissa value of 0000000 would properly result, as the original word had a zero value. 
     It will be appreciated that much of the circuitry provided for accomplishing the LOG function is used in carrying out the FLOAT function as afore-defined. Thus, with the FLOAT function, the seven bits occupying bit locations fourteen through eight are logically ORed at 478 so that a control signal MSB7 can be sent to the controller 470 to help the controller determine whether the sixteen bit word held in register 72 should be preprocessed by section A or section B of the pre-shift multiplexer 420. It will be appreciated that the preprocessing of LOG and FLOAT functions is identical, as is the manner of shifting the shift register 472 and decrementing the down counter 474. The primary difference between the LOG and FLOAT functions is that as afore-stated, the exponent for the FLOAT function must be one greater than that of the LOG function. Thus, the msb of the exponent coming from zero detector 478, as well as the remaining three bits coming from down counter 474 are sent to an incrementer 476, where the command to increment is the msb from shift register 472. When the value of the msb of shift register 472 is a &#34;1&#34;, a value one is added to the four exponent bits. However, in keeping with the definition for the FLOAT function, the exponent is not incremented if the msb of the shift register 472 is a &#34;0&#34;. The FLOAT exponent is then sent to section B of the output multiplexer as bits nine through six. The six bit mantissa which is defined as the left-most &#34;1&#34; value bit in the sixteen bit word and the five bits following that bit is derived either by reading bits fifteen through eleven in the shift register 472 or equivalently by reading bits fourteen through eleven of the shift register 472 and setting the msb of the mantissa to a value of &#34;1&#34;. Regardless, the six bit mantissa is placed as bits five through zero in the B section of the output multiplexer 440. It should be noted, that if the value of the original sixteen bit word is zero, the four bit FLOAT exponent will always properly be zero (0000) in accord with the previously described algorithm, as a &#34;1&#34; is not seen at the msb of the shift register 472. 
     Where an ANTILOG function is to be performed, the word in register 72 is a LOG value with a four bit exponent and a seven bit mantissa. In accord with the provided circuitry, the msb of the four bit exponent (in position ten of register 72) is read by controller 470 at control input E3 to determine whether the word should be preprocessed through Section C or Section D of pre-shift multiplexer 420; the former being used where the exponent msb is a &#34;1&#34;, and the latter where it is a &#34;0&#34;. Thus, if the exponent msb is a &#34;1&#34;, the mantissa occupying bits positions six through zero of Register D 72 are preprocessed by the pre-shift multiplexer 420 to be located in bit positions fourteen through eight of the shift register 472, with bits seven through zero being set to &#34;0&#34; as the value of the exponent dictates that the mantissa is higher than or equal to 2 8 ). If the exponent msb is a &#34;0&#34;, the mantissa is preprocessed to be located in bit positions six through zero of shift register 472 because the value of the exponent dictates that the mantissa is less than 2 8 . Regardless, in both situations, in accord with the ANTILOG algorithm a bit of the value &#34;1&#34;, is inserted in the bit position one higher than the msb of the mantissa. Thus, the pre-shift multiplexer 420 causes bit location fifteen or seven is set to a value of &#34;1&#34; depending on whether preprocessing was through section C or D of the pre-shift mux 420. 
     While the msb of the exponent determines the manner in which the mantissa is preprocessed, the remaining three bits help determine the number of shifts needed. Clearly, if the exponent was &#34;1110&#34;, which would have been the highest number allowable as bit position fifteen is reserved for the sign bit, the mantissa which has had a &#34;1&#34; placed in front of it in bit position fifteen of the shift register 472 requires one shift (&#34;001&#34; binary) to be located properly as the first &#34;1&#34; should be located in bit position fourteen. On the other hand, if the exponent was &#34;1000&#34;, the first &#34;1&#34; should occur in bit position eight. Thus, the register 472 should be shifted right seven times (&#34;111&#34; binary). In other words, the register 472 should be shifted right by the value of the inverted remaining three bits of the exponent. Thus, an inverter 492 is provided for inverting the three remaining bits of the exponent. Provided the ANTILOG function is being carried out and not the LOG or FLOAT function, these three inverted bits are used to set down counter 474. The shift register 472 is then shifted right until the down counter reaches a value of zero thereby disabling the shifter. As the shift register shifts right, zeroes are inserted into the msb&#39;s of the word located in the shift register. The ANTILOG value is then drawn entirely from the bits fourteen through zero located in the (bidirectional) shift register 472. 
     While the circuitry of FIG. 6 is one manner of shifting bits to find the exponent for the LOG and FLOAT operations, it will be appreciated that other means may also be provided. Thus, as seen in FIG. 8, a flash converter 720 utilizes a majority logic encoder 725 to search for the position of the most significant logic bit having a value of one. While the encoder 725 contains numerous AND and OR gates, it is capable of performing its function in a time of on the order of one clock cycle (100 ns). The encoder shown in FIG. 8 contains separate logic sections for the LOG and FLOAT functions as the required exponent of the FLOAT operation is one greater than that of the LOG operation, unless the exponent is zero. Thus, inputs to section A are required to provide the LOG output, while the FLOAT is accomplished by section B of FIG. 8. A logic controller 730 is provided to permit the outputs of section A or B to be processed through AND gate array 735, and the proper exponent is received as bits S3-S0. 
     In order to obtain the mantissa for the LOG or FLOAT operations for the flesh converter 720, the sixteen bit word N is received by a shifter 760 which shifts the word according to the value of the exponent S3-S0. Thus, for a LOG operation, the mantissa is obtained by shifting the word N by the difference of sixteen and the value of the exponent S3-S0. For the FLOAT operation, on the other hand, the word N is shifted by the difference of fifteen and the value of exponent S3-S0. 
     Those skilled in the art will appreciate that a flash technique could also be used to implement the ANTILOG function. The magnitude shifter 760 would be used to properly locate the bits in the resulting sixteen bit word. 
     It will be appreciated that however the LOG, FLOAT and ANTILOG functions are carried out, according to the invention common means are provided so that the similarities of the functions may be exploited. Typically, the common means for performing the LOG, FLOAT and ANTILOG functions will include a shifter of some type, logic circuitry in conjunction with the shifter to accomplish the different functions before and/or after shifting, and a control means for directing the logic means and/or shifter. 
     Before turning to FIG. 9, a review of the MULTIPLICATION and FLOATING POINT MULTIPLICATION algorithms which are implemented by the secoond common means is in order. In the MULTIPLICATION algorithm of ADPCM, an eight bit signed magnitude multiplier and a fourteen bit signed magnitude multiplicand are preferably multiplied according to a well known add and right shift technique (although parallel multiplication could be used), where a decision is made either to add the multiplicand to a partial product or to add zero depending upon whether the multiplier digit under consderation is a &#34;1&#34; or a &#34;0&#34;. (See, e.g. Hayes, J. P. &#34;Computer Architecture and Organization&#34;, Computer Science Series, McGraw Hill (1978, pp. 88-90). In multiplying two digital numbers, the number of resulting bits equals the sum of the length of each number. Thus, because in effect the MULTIPLICATION algorithm multiplies a seven bit magnitude word by a thirteen bit magnitude word, a twenty bit product results. According to the algorithm, the six least significant bits are truncated from the twenty bit word to provide a fourteen bit product, and the sign bit is attached thereto. 
     While the signed magnitude MULTIPLICATION algorithm is very straight-forward, the FLOATING POINT MULTIPLICATION algorithm is more intricate. Thus, a four bit exponent by six bit mantissa multiplicand is multiplied by an identically arranged multiplier, and the floating point product is then converted into a signed magnitude format. The algorithm for accomplishing the same is as follows: 
     
         __________________________________________________________________________
SIGN =                                                                    
      SlGN (MULTIPLIER) XOR SIGN (MULTIPLICAND)                           
EXP = EXP (MULTIPLIER) + EXP (MULTlPLICAND)                               
MANT =                                                                    
      [(MANT (MULTIPLIER) × MANT (MULTIPLICAND) + 48) &gt;&gt;4]          
      where the value in [ ] is &gt;&gt;(19 - EXP) if EXP &lt;=26                  
      or the value in [ ] is &lt;&lt;(EXP - 19) &amp; 32767 if EXP                  
__________________________________________________________________________
      &gt; 26                                                                
 
    
     A second common means 460 for carrying out the signed magnitude MULTIPLICATION and the FLOATING POINT MULTIPLICATION is seen in FIG. 9, and basically comprises a multiplicand register 450, a multiplier register 505 capable of being shifted, a shiftable partial product register 510 for holding the partial product and for providing a shifted final product, an adder 515 for adding the multiplicand to the partial product, and a gating means 520 for controlling the addition of either the multiplicand or zero with the partial product depending on the multiplier digit under consideration. 
     In accord with the detailed circuitry of FIG. 9, the timing diagram of FIG. 10a, and the ADPCM algorithm, in performing a MULTIPLICATION a seven bit magnitude taken as the multiplier is read from Register D 72 and loaded via section A of the multiplier select multiplexer 454 into the multiplier register 505 under the control of the active low mulitplier load enable signal (MULTIPLIER-LD-EN). At another point in time, a thirteen bit magnitude taken as the multiplicand is read from register 72 and loaded via section A of the multiplicand select multiplexer 522 into the multiplicand register 500 under the control of the active low multiplicand load enable signal (MULTIPLICAND-LD-EN). The multiplier and multiplicand are processed separately. The control signals MULTIPLIER-LD-EN and MULTIPLICAND-LD-EN are derived as a result of the external active low LMULT signal applied while register 72 was being loaded or at some other time. The first presentation of the LMULT signal causes MULTIPLIER-LD-EN to be generated while the second presentation causes MULTIPLICAND-LD-EN to be generated. The act of reading the partial product register 510 ensures that the presentation of LMULT will generate the proper signal and eliminates the possibility of the control signals being out of sequence. 
     The control signals MULTIPLIER-LD-EN and MULTIPLICAND-LD-EN are both generated from a delayed version of the LMULT signal which is called LMULT-DLY and which occurs one clock cycle after LMULT to ensure that data read from register 72 has settled. The multiplication process is initiated by the rising edge of the MULTIPLICAND-LD-EN signal which in turn generates an active low shift enable signal called MSHIFT-EN which controls the updating of the partial product register 510 via the product register controller 532. 
     Initially, the partial product register 510 is set to zero. At a clock cycle, the least significant bit of the multiplier in multiplier register 505 is read along with the bits in the multiplicand register 450 by AND gates 520. If the least significant bit of the multiplier is a &#34;0&#34;, clearly, all the bits entering adder 515 will be &#34;0&#34; because regardless of the value of the bits in the multiplicand register 450, the AND gates 520 will only go high if both inputs are high. On the other hand, if the lsb of the multiplier is a &#34;1&#34;, it will be appreciated that the the AND gates 520 will provide the identical value stored in the multiplicand register 450. Regardless, the value exiting the AND gates 520 is added in adder 515 to the value of bits located in the partial product register 510. A &#34;shift right&#34; is accomplished by requiring that the bit added to the n&#39;th bit exiting the n&#39;th AND gate 520 is added to the n+1&#39;th bit of the partial product register. 
     On the next clock cycle, the bits in the multiplier register 505 are shifted such that the second lsb now occupies the lsb bit position. As before, the value of the now lsb is ANDed at 520 with the multiplicand, and the resulting values are sent to adder 515. At adder 515, the new set of bit values are added to the partial product contained in the partial product shift register 510. Of course, again the n&#39;th bit from AND gates 520 is added to the n+1&#39;th bit from the register 510, with the fourteenth bit (PD13) of the product register being determined according to any &#34;carry&#34; necessary by the bits in the thirteenth bit positions. This course is repeated six times until the seventh bit is read from the multiplier register 505 and processed. The procedure is then stopped by the control signal MSHIFT going high which results in new signals from the product register controller 532. The control signals PS1 and PS0 from the controller 532 tell the product register 510 to hold the partial product as a final product. 
     It will be appreciated, as stated above, that causing the n+1&#39;th bit of partial product register 510 to be added to the n&#39;th bit of the multiplicand register automatically causes a right shift to occur. It will also be appreciated that the least significant six partial product bits shifted to the right are not retained in the partial product register, and that only a truncated product of fourteen bits will occupy bit positions thirteen through zero of the partial product register. This is in accord with the ADPCM algorithm which requires such a truncated fourteen bit product. In addition, a fifteenth bit of the partial product register will be of a value zero since the input to the register is set to the zero value. Further, a sixteenth bit, the sign bit, is determined by taking the sign bits of the multiplicand and the multiplier, and performing an exclusive OR (XOR) logic operation on them as seen at 536. The result is then sent through a negative zero trap 538 where a check is made to guarantee that a sign bit indicative of the negative and a word of all zeroes is not output because such an output would be indicative of a maximum negative value in two&#39;s complement when a conversion from signed magnitude to the two&#39;s complement is undertaken using the CVT microinstruction of the MIS and PALU. Thus, the negative zero trap 538 switches the sign bit to a positive value for zero in such a case. The sign bit output of the negative zero trap 538 and the fifteen bit output of the bidirectional partial product shift register 510 are then sent as a sixteen bit word to the output multiplexer 440 of FIGS. 5 and 6 such that the result may be directed to a desired location. 
     In performing a FLOATING POINT MULTIPLICATION, the multiplier and multilicand must be in floating point format prior to the multiplication. In the ADPCM algorithm, the floating point multiplicand is used a number of times, and therefore the floating point value for the multiplicand is stored in RAM for use when needed. Because the multiplier value is typically changing (as opposed to the multiplicand), the multiplier is not stored as a floating point value. Thus, prior to a FLOATING POINT MULTIPLICATION, the signed magnitude format multiplier must be converted into a floating point representation. Thus, in accord with the afore-described FLOAT operation, the value is so converted. While the multiplier is being converted into floating point representation, the floating point multiplicand may be loaded into Register D and then loaded into multiplicand register 450 via section B of the multiplicand select multiplexer 522. Section B receives the six bit mantissa of the floating point multiplicand (located in bit positions five through zero of the sixteen bit word) and locates them in bit positions six through one. The four bit exponent of the multiplicand (in bit positions nine through six) are sent to adder 542, and the sign bit (bit position fifteen) is sent to sign calculator 536. 
     Because the floating point multiplier might not be available when the multiplicand is loaded into the second common means, it is necessary to provide a delay before starting the multiplication process. The delay is provided by a FMULT delay  controller 500, which generates a START signal when it detects that the SHIFT-EN signal controlling shift register 472 of FIG. 6 has gone high (i.e. the FLOAT operation of the first common means has been completed). The START signal in turn enables the MSHIFT-EN signal which starts the multiplication process. The multiplication process is permitted, because when the FLOAT operation is terminated, the floating point multiplier value is transferred from the shift register 472 of the first common means to the multiplier register 505 of the second common means via section B of the multiplier select multiplexer 454. Thus, the bits in bit positions fourteen through ten of the shift register 472 are placed in bit positions four through zero of the multiplier register 505 where bit position five is set to a logic &#34;1&#34; as the msb of the mantissa of a floating point representation is always a one as previously described. Bit position six in the multiplier register 505 is set to zero. In a similar manner, the four bit floating point multiplier exponent and the sign bit are received from the first common means of FIG. 6 and are respectively sent to the adder 542 and the sign calculation means 536, where a determination of the product and sign is had. 
     In the multiplication process, the mantissas as loaded in the multiplier register 505 and multiplicand register 450 may be multiplied by using AND gates 520, adder 515 and the bidirectional partial product shift register 510 as afore-described with reference to the signed magnitude MULTIPLICATION function. It will be noted that in accord with the ADPCM algorithm, the value of forty-eight (110000 in binary) is added to the partial product by initially presetting bit locations five and six of the adder 515 equal to one and adding them to the value proceeding through AND gates 520. In this regard, OR gates 544 are used to load the forty-eight value into the adder 515 under the control of a Load-48 control signal. 
     Once the multiplication of the mantissas and the addition of the value forty-eight have taken place, a twelve bit product is situated in bit locations PQ1 through PQ12 of the partial product register 510. Then, accordinng to the ADPCM algorithm, the product must be converted to a linear domain representation by shifting the mantissa product as afore-described. Thus, the exponents of the floating point represented words are added at adder 542. The value nineteen is then subtracted from the value of the exponent sum at 546. The resulting value is then limited at limiter 548 to at most a value of nine and at least a value of minus eight. The value in register 548 is then used to control via controller 532 the direction of shifting of the partial product register 510, and via shift duration controller 552 the number of shifts of the bidirectional partial product shift register 510. As is indicated in FIG. 9 at duration controller 552 and in FIG. 10, the duration controller 552 outputs a control ISHIFT which uses the value of limiter 548 to shift the partial product register 510 (i.e. the duration of ISHIFT=EXP(MULTIPLICAND)+EXP(MULTIPLIER)+19, such that -9&lt;ISHIFT&lt; 10, with the sign of the added exponents determining the direction of shift; a positive value indicating a left shift and a negative vaue indicating a right shift). The thus-shifted linear product value is then subjected to a logical AND operation with the decimal value 32767 (0111111111111111 in binary) as required by the ADPCM algorithm by limiting the length of the partial product register 510 to fifteen bits. Thus, the values that could occupy bit positions fifteen and sixteen given a maximum right shift are negated (by being lost, i.e. shifted out of the register) and the values located in bit positions fourteen through zero are retained. The sign bit is meanwhile determined via circuitry 536 in the same manner as the signed magnitude MULTIPLICATION sign bit, and is processed through negative zero trap 538 to provide the sign bit. As was the case with the MULTIPLICATION function, the sign bit output of the negative zero trap 538 and the fourteen bit output of the bidirectional partial product shift register 210 are sent as a sixteen bit word to the output multiplexer 440 of FIGS. 5 and 6 such that the result may be directed to a desired location. 
     Those skilled in the art will recognize that the second common means which performs the MULTIPLICATION and FLOATING POINT MULTIPLICATION functions is able, if desired, to operate concurrently with the first common means which performs the LOG, FLOAT and ANTILOG function. In particular, in conducting the FLOATING POINT MULTIPLICATION, a multiplier value may be converted to a floating point format by the FLOAT function while the multiplicand is being loaded into the multiplicand register. In this manner, an efficient implementation of the PREDICTOR of the ADPCM algorithm may be had as the FLOAT and FLOATING POINT MULTIPLICATION operations are interleaved. It will also be appreciated that the second common means is efficient in that the FLOATING POINT MULTIPLICATION and signed magnitude MULTIPLICATION functions use much common circuitry in their execution. 
     There has been described and illustrated herein a serial processor capable of conducting various ADPCM functions, including LOG, ANTILOG, FLOAT, MULTIPLICATION, and FLOATING POINT MULTIPLICATION. While particularly circuitry has been set forth and described, it will be appreciated that various other means for accomplishing the same will be within the grasp of those skilled in the art. For example, while the second common means of the invention was described in terms of a signed magnitude multiplication, the multiplier and multiplicand could be in two&#39;s complement form, and the appropriate circuitry could be provided to carry out the multiplications. Thus, it should be appreciated that the thrust of the invention is the understanding that at least large portions of the LOG, ANTILOG, and FLOAT functions can all be performed using common circuitry (first common means), and that large portions of the MULTIPLICATION and FLOATING POINT MULTIPLICATION functions can also be performed using common circuitry (second common means). While another aspect of the invention is that the first common means and the second common means may be processing information in parallel, particularly where a FLOATING POINT MULTIPLICATION is to be accomplished, it will be appreciated that other arrangements might negate the benefits of such an arrangement. For example, if a flash converter were used to perform the LOG and FLOAT functions such that the function could be accomplished in just a few clock cycles rather than the ten required by the arrangement provided, it will be appreciated that a flash converter could be located at the output of register 15. Thus, the first common means could be located in a sequential manner rather than in a parallel manner with the second common means, such that the first common means would be accessible as required, and bypassed when desired. Controls would be used to send the output of the first common means to a desired location such that for the FLOAT, LOG, and ANTILOG functions, the output would be sent to output multiplexer 120, except where the FLOAT function was being utilized as part of a FLOATING POINT MULTIPLICATION. In that situation, the output of the first common means would be sent to the multiplier register 205 as well as the adder 242. Likewise, if a LINEAR MULTIPLICATION function was to be accomplished, or if a floating point value of the multiplicand was to be loaded, the first common means would be bypassed and the information from register 15 would be directed to the second common means. Therefore, it will be apparent to those skilled in the art that other changes and modifications may be made to the invention as described in the specification without departing from the spirit and scope of the invention as so claimed. 
     THE MICROINSTRUCTION SEQUENCER 
     In accord with the preferred embodiment of the invention, a microinstruction sequencer 20 for a digital signal processor capable of performing the ADPCM algorithm is seen in FIG. 1. At the heart of the MIS 20 is a one thousand twenty-four by twenty-nine bit (i.e. one thousand twenty-four words of twenty-nine bits in length, where bit position twenty-eight is the location of the msb and bit position zero is the location of the lsb) microinstruction ROM 25 which controls the performance of the ADPCM algorithm, and a microinstruction decoder 30 which receives the twenty-nine bits of each ROM word into its various registers and forwards the information as control information or data to various destinations. As will be described in detail hereinafter, the microinstruction decoder 30 preferably includes a multiplexer which is used in one of the MIS sequencer 20 fields for selecting one set of bits from a plurality of sets of bits in the ROM word which are used to instruct an arithmetic-logic unit 40. The multiplexer is preferably controlled by the microsequencer controller 32 which also controls other circuitry of the MIS 20. 
     Before reviewing the microinstruction fields (such as the conditional field) and the capabilities of the MIS of the invention, a review of the other circuitry of the MIS is useful. Thus, the microinstruction sequencer 20 of the invention preferably includes a microinstruction address register 33 for locating the ROM pointer and an incrementer 34 for incrementing the value of the microinstruction address register 33 and ROM pointer with each clock cycle. Further, to help permit subroutines to be able to be carried out, a four level last-in-first-out stack 36 is provided for storing &#34;next&#34; addresses. In this manner, when the ROM program calls a subroutine at another location, the next address which is produced by the incrementer 34 is stored in the stack 36. When the microinstructions (29 bit words) of the subroutine are completed and a &#34;return&#34; command is issued, the microinstruction address register 33 is loaded with the address from the top of stack 36. Finally, a microinstruction next address multiplexer 38 is provided to permit only one of the four-level stack 36, the incrementer 34, the ROM 25 (in the form of a direct address) and a data bus 39 to provide the information for updating the microinstruction address register 33. It will be appreciated that the four-level stack 36 and the microinstruction next address multiplexer 38 are both under the control of the microsequencer controller 32 which as aforestated also acts to control a multiplexer in the microinstruction decoder 30. The microsequencer controller 32 is in turn controlled by flags which are set by circuitry external to the MIS 20. 
     Of the twenty-nine bits exiting ROM 25 with each clock cycle, the two most significant bits are preferably reserved for defining the field of the microinstruction. Thus, field zero (&#34;00&#34;) has been set as the arithmetic, logical and data move field; field one (&#34;01&#34;) as the branch field; field two (&#34;10&#34;) as the immediate data field; and field three (&#34;11&#34;) as the conditional arithmetic field. The mnemonic and corresponding function of the arithmetic, logic, and data move capabilities (field &#34;00&#34;) of the MIS of the invention are set forth below in Table 1a, and the bit assignments for the same are seen in Table 1b. Likewise, the mnemonics and corresponding functions and bit assignments of the branch, immediate data, and conditional arithmetic fields are seen respectively in Tables 2a and 2b, 3a and 3b, and 4a and 4b below, while secondary field microinstructions which may be embedded in (i.e. occur in parallel with) the microinstructions of fields zero and two, and the bit assignments therefor are set forth in Tables 5a and 5b. In all fields, the following symbols and abbreviations are used: 
     
         ______________________________________                                    
symbol    meaning                                                         
______________________________________                                    
sh        magnitude shift value in the range of +4 to -8                  
dd        destination registers (A, B, C, D) or combination               
mm        direct data memory address                                      
n         direct branch address                                           
*         bus data                                                        
i         set i=J for Jump, i=C for Call, or i=R for Return               
N         if N is not present then condition is true; if N is             
          present then condition is false                                 
b         sixteen bit immediate data value                                
&lt;&gt;        items within brackets are user defined                          
[ ]       items within brackets are optional                              
______________________________________                                    
 
    
     Particularly, with regard to the shift &#34;sh&#34; function, a shift left (positive shift) is denoted by the letter L, while a shift right (negative shift) is denoted by the letter R. Also, one to four register destinations may be specified when the register destination &#34;dd&#34; is set forth. Further, with regard to the letter N, if a mnemonic includes the letter &#34;N&#34; at the end thereof, the logical NOT of the mnemonic is carried out. If the letter &#34;N&#34; is not in the mnemonic, the mnemonic stays intact, i.e. the mnemonic condition is true. 
     As will be appreciated with reference to Tables 1a and 1b, standard arithmetic and logic commands associated with many DSPs are found in the microinstruction set of the MIS 10 of the invention. For example, addition, subtraction, absolute value, negation, incrementation, no operation, etc. are all specified as microinstruction, as are the logical microinstruction OR, AND, and XOR. In addition, a non-standard operation CVT is specified as performing a two&#39;s compliment to signed magnitude conversion or vice versa. 
     As an example of the arithmetic functions available and the manner in which the ROM has been coded to instruct the same, the twenty-nine bit code for the arithmetic ADD function seen in Table 1a as ADD &lt;sh,dd&gt; is found in Table 1b as: 
     
         00 0010--SH----DD--00 
    
     As previously mentioned, the first two (&#34;00&#34;) bits define the field to be the arithmetic, logical and data move field. The next four bits &#34;0010&#34; in the I26-I23 bit positions uniquely  define the arithmetic function to be the addition function (although as will be seen hereinafter, those four bits alone do not uniquely define all operations in field &#34;00&#34; as the &#34;no operation&#34; and some of the &#34;data move&#34; functions all share the same I26-I23 code). The bits in bit positions I22-I19 are then used to define the shift SH by which the contents of Register A of the PALU 40 will be shifted. As will be appreciated, since shifts of +4 to -8 are allowed, the thirteen possible values may be easily represented uniquely by the provided four bits. While the addition function supports a desired shift, those skilled in the art will recognize that various of the arithmetic operations (e.g. negation, absolute value, incrementation, etc) do not permit a shifting because the functions operate on a value located in other than Register A. Thus, for those operations, the value &#34;0100&#34; which corresponds to a shift of zero is specified and is located in bit positions I22-I19. 
     Bits I18-I15 of the twenty-nine bits operational code word for the addition function are used to signify the destination of the sum, and for the provided embodiment can comprise registers A, B, C and D. As seen by Table 1b, if the register is to receive information, the bit value for its corresponding bit location is set to zero. Of course, with the no operation function, the destination bits I18-I15 are all set to a value of one as no information is being sent to the registers because no operation is being performed. In this manner, the no operation function may be distinguished from the other data move functions, as all four bits of I18-I15 are set to a value of one for the no operation function, while for the other data move functions such a result will never arise. 
     Bits I10-I6, and I5-I0 of the addition function are left for secondary microinstructions which will be discussed in more detail hereinafter. Bits I14 and I13, which are left undefined in the addition function, are sometimes used with reference to secondary microinstructions, and sometimes to distinguish data move commands as will be discussed in more detail hereinafter. Finally, bits I12 and I11 contain a two bit select code which enable the output bus drivers of various blocks of the DSP including: the PALU; the serial processor; the immediate ROM data port; or the RAM, I/O ports and register C (all seen with reference to the FIG. 1). Thus, where an addition function is being carried out, the arithmetic-logic unit output bus driver will be enabled as it is the PALU which will conduct the addition of the values in the two registers associated therewith. Likewise, the sum of the values will be sent from the PALU to the specified registers. 
     As seen in Table 1a, not only are arithmetic and logic functions included in field &#34;00&#34;, but data move commands are likewise included. The data in any of four registers, two data ports, or in a location of the data RAM, may be sent to any of registers A, B, C, and D. In addition, the data in a RAM location which may be specified by an address value from the ROM (LDM command) or specified by the value on a bus (LDMB command) may be sent to any of the four registers A, B, C, and D. Also supported is the data move of the compliment of the data and data moves with shifting of the data in register A. 
     The data move commands as outlined in Table 1b primarily rely on bits I26-I23 and I14-I11 to distinguish among them. Thus, because only a few subcombinations for bits I26-I23 uniquely remain in field &#34;00&#34; after the arithmetic and logical functions are defined, only three data move functions are uniquely identified by those bits. However, the remaining data move functions (except for LDM and LDMB) are identified uniquely by defining bits I14-I11 or a subcombination of those bits. The LDM and LDMB functions are defined uniquely, as seen in Table 1b, by requiring that the bits I10-I16 and I5-I0 differ in the two functions. In the LDM microinstruction, the data stored in the RAM memory location defined by bits I5-I0 is loaded into the registers set forth in bits I18-I15 (bits I10-I6 being reserved for secondary microinstructions), while in the LDMB microinstruction bits I10-I6 are specified uniquely to indicate that the RAM memory location must be defined by the value on the bus at the end of the cycle. It will be appreciated, therefore, that the LDMB microinstruction is in effect a primary microinstruction having a secondary microinstruction component. 
     Because all of the field &#34;00&#34; microinstructions with the exception of the LDMB command can be used in conjunction with a secondary microinstruction, a review of the secondary microinstruction set seen in Tables 5a and 5b is in order. In all cases, identification of the secondary microinstruction is gained by decoding bits I10-I6 as thirty-two such secondary microinstructions could be uniquely identified by the five bits. Among the secondary microinstructions are control instructions to control hardware, and in particular the serial processor of the DSP. The control instructions control an initiation of a LOG function, ANTILOG function, FLOATING POINT CONVERSION function, SIGNED MAGNITUDE MULTIPLICATION function, and FLOATING POINT MULTIPLICATION function, as well as selecting the appropriate output from the serial arithmetic processor. These particular functions are described in great detail with regard to the serial processor of the DSP. The control field in the secondary microinstruction set further permits the setting of various flags as desired, as well as the selection of pages zero and one (for ADPCM encoding and decoding) of RAM 60 of the DSP. 
     A second field of the secondary microinstruction set includes data output instructions which control the selection of data output ports three and four (90 and 92) of the ADPCM VLSI device. Finally, the secondary microinstruction set includes a third field which allows the RAM of the DSP to be updated. As seen in Tables 5a and 5b, the RAM address identified is updated either directly or through a bus directed technique with the bits located in locations I5-I0 defining the RAM location (i.e. data memory address) to receive the information stored in an associated register (register C) or found on the data bus. In particular, the STC microinstruction causes the RAM address specified in the operand to be updated with the value stored in register C. The STCB microinstruction causes the RAM address specified by the value on the data bus from the previous cycle (i.e. the current cycle is being executed) to be updated with the value stored in register C. In the ST microinstruction, the value on the bus is stored in the RAM address specified by the operand, while in the STB microinstruction, the value on the bus is stored in the RAM address specified by the value on the data bus from the previous cycle. It will be appreciated that where the RAM is being updated, values of zero are placed in bit positions I14 and I13 in the primary microinstruction which is in parallel with the secondary microinstruction. The reason for defining bit positions I14 and I13 in this manner is that those two bits are used within the RAM section 60 to decode which of the RAM 62, Register C 64, and Ports 1 and 2 (84 and 82) are to drive the RAM bus. 
     Returning to the primary microinstruction fields, the branch field, with its operations and bit assignments being defined in Tables 2a and 2b respectively, is identified by bits &#34;01&#34; in the two msb&#39;s of the twenty-nine bit words issuing from the ROM. The branch field supports both unconditional and conditional branching including both conditional and unconditional jumps, calls, and returns. All branching (except for the RTEI and RTDI commands which also set flags and represent the end of the encoding and decoding algorithm sections of the code) is identified in field &#34;01&#34; by setting both bits I26 and I25 to values of one. In addition, the branch field supports commands which clear the encoder and decoder interrupt flags of the ADPCM DSP, as well as a command which resets the microinstruction address register. These operations, and the RTEI an RTDI comands are identified by bits I26, I25, I10, and I9 as seen in Table 2b. The branch field, however, does not support secondary microinstructions. 
     Unconditional branching is identified by setting bits I8-I4 to the value &#34;01111&#34;, while conditional branching will have many different values in those bit positions but never that particular value. The particular unconditional branch operation (i.e. any of two &#34;jump&#34;, two &#34;call&#34;, or three &#34;return&#34; operations) is defined by bits I3-I0, with all three return operations sharing the same I3-I0 code but with different I26 and I25 values as previously stated. Thus, a &#34;jump&#34; operation dictated by the operational code leaving the ROM is given a code 1001 in bits I3-I0. The address in the ROM to which the program is to jump is dictated by ten bits (I24-I15) which can generate any of the 1024 twenty-nine bit word direct address locations. If the jump operation is dictated by the value on the bus (JUMP * operation having a code 0001 in bits I3-I0), the value on the bus is taken to be the location in the ROM to which the ROM pointer must be set. In addition, where values are to be obtained from a bus, (for both conditional and unconditional branch operations) bits I14-I11 are set to &#34;0010&#34;. 
     Turning to the conditional branch operations set forth in Tables 2a and 2b, it is seen that the conditional branch microinstructions include &#34;IF-THEN-JUMP&#34;, &#34;IF-THEN-CALL&#34;, and &#34;IF-THEN-RETURN&#34;, with the conditionals (i.e. IF) being flag inputs derived from the PALU 40 and the I/O circuits 80. Bits I28 and I27 set forth the branch field, with bits I26 and I25 set to values of one to indicate a branch operation. Bits I24 through I15 set forth the location in ROM to which the ROM pointer is to be set if the condition set forth in bits I8 through I4 is met. Bit I8 in the conditional branch operations is reserved for permitting the opposite of the function (i.e. NOT) to be performed rather than the specified function itself. Thus, if the mnemonic set forth in Table 2a includes an N, bit I8 (N) is set to a value of &#34;1&#34; to indicate that the NOT of the mnemonic is to be accomplished. Otherwise, bit I8 is set to a value of &#34;0&#34;. Also, it should be noted that in six circumstances, bit I8 is determined by the XOR of a preassigned value and the value of N which is set to &#34;1&#34; if the NOT is to be accomplished and to &#34;0&#34; otherwise. 
     In the conditional branch operation, bits I7 through I4 are used to uniquely define most of the operations. However, because eighteen different conditional branch operations are specified, and only fifteen different combinations of bits I7 through I4 are available (0111 having been used to specify an unconditional branch), three conditional branch operations must share the same I7 through I4 code with three other operations. Thus, bit I8 which as aforedescribed is used for negation is used to distinguish among the operations in each of the three pairs. Since mnemonic pairs iPSA (if register A is positive) and iNGA (if register A is negative), and iPSB (if register B is positive) and iNGB (if register B is negative) are already the negatives of each other, the sharing of bit I8 has no effect at all, as the XOR of bit I8 with the value &#34;1&#34; where the NOT is desired simply gives the code of the other function of the pair. Likewise, with regard to iMLW and iALW which share code &#34;1000&#34; in bits I7 through I4, it will be understood that if A-Law is not be utilized in the ADPCM algorithm, then mu-Law is being utilized, and vice versa. 
     Further defining the conditional branch operations, it will be seen that bits I10, I9 an I2 are used to set the branch function which is to be implemented. Bits I10 and I9 are particularly used to control the microinstruction next address multiplexer 38. Thus, if bits I10 and I9 are both zero, the next address multiplexer 38 clears or resets the address register 33. If the bit values are &#34;01&#34;, such as in the normal sequence of microinstructions and where the encode or decode flags are reset, the next address is taken from the incrementer 34. If the bit values are &#34;10&#34;, a program &#34;return&#34; is accomplished by taking the next address from the top of stack 36. Finally, if bits I10 and I9 have the value &#34;11&#34;, a &#34;jump&#34; or &#34;call&#34; is accomplished, with the next address being supplied by the ROM 25 or the bus 39. Bit I3 is used to distinguish between those situations, as bit I3 is set to a value of zero where a bus directed branch is to be accomplished and to a value of one where a direct branch operation is to be accomplished. 
     Bits I10 and I9 are also used to control the stack 36 along with bit I2. The stack has four control states: HOLD, PUSH, POP, and RESET. The HOLD state is used both where the the next address multiplexer 38 obtains its next address from the incrementer 34 (bits I10 and I9 set to &#34;01&#34;), and where a &#34;jump&#34; is executed (bits I10 and I9 set to &#34;11&#34;). The POP state is used when a &#34;return&#34; is executed (bits I10 and I9 set to &#34;10&#34;). The PUSH state is used when a &#34;call&#34; is executed (bits I10 and I9 set to &#34;11&#34;), and the RESET state is used when the address circuitry is to be reset (bits 10 and I9 set to &#34;00&#34;). Since bit values &#34;11&#34; in bit positions I10 and I9 could indicate either a HOLD state for a &#34;jump&#34; or a PUSH state for a &#34;call&#34;, bit I2 is used to distinguish between them. Thus, where bits I10, I9, and I2 are all set to one, a &#34;call&#34; is indicated. If bits I10 an I9 are set to one while bit I2 is set to zero, a &#34;jump&#34; is indicated. 
     Bit I3 of the branch field is used to indicate whether the address in bits I24 through I15 is coming from the ROM operand or whether it is being taken from the least significant ten bits on the bus. If bit I3 has a zero value, the branch address is bus directed, while if bit I3 has a value of one, the branch address is dictated by the operand and is called an &#34;direct address&#34;. Where a direct address is specified, bits I14 through I11 are left undefined. However, where the branch address is bus directed, bits I14 through I11 are set to the values &#34;0010&#34; which is indicative of bus direct addressing in the unconditional branch operations. 
     Finally, with regard to the twenty-nine bit words of the branch field, bit I0 is used to define the reset condition, and bit I1 is used to indicate whether the operation is to be a one clock cycle or two clock cycle operation. Where bit I1 has a value of &#34;1&#34;, a two clock cycle operation is indicated, and where bit I1 has a value of &#34;0&#34;, a one clock cycle operation is indicated. This feature will be more completely discussed hereinafter with reference to the conditional arithmetic field and FIG. 4. 
     The above discussion of bit locations may be seen with reference to any of the branch microinstructions. For example, the operation code for the instruction if register A is greater than register B call ROM location 0011001111 would be CGTT 0011001111, and the bit assignment would be 01110011001111xxxx11001111111. The two msb&#39;s would set forth the branch field, with the next two bits indicating a branch operation. The next ten bits would define the ROM location which is being called, with the bits in the fourteen through eleven slot being undefined. Bits I10 and I9 are then set to a value of &#34;11&#34; to indicate a call operation, while bit I8 is set to zero to indicate the true case. Bits I7 through I4 would then set forth the select of the AGTTB flag input (i.e. &#34;if register A is greater than register B&#34;), while the four remaining bits would be set to a value of one to indicate that the branch operation is a direct call operation. 
     A third field in the microinstruction set is the immediate data field which is identified by the bits &#34;10&#34; in the msb bit positions. As seen in Tables 3a and 3b, the immediate data field supports only a single microinstruction, although the secondary microinstructions previously set forth with respect to Tables 5a and 5b are also supported. The single instruction supported by field &#34;10&#34; is to load a coefficient stored in ROM into desired registers. The single coefficient is a sixteen bit word which is listed in bit locations I26-I19, I14, I13, and I5-I0. Bit locations I18 through I15 are used to set the registers into which the sixteen bit word is to be loaded. Bits I12 and I11 are set to &#34;01&#34; to specify that the ROM will drive the bus 39. Finally, bits I10 through I6 are used for the secondary microinstructions as set forth in Tables 5a and 5b. 
     The final field supported in the MIS is the conditional arithmetic field designated with bit values of &#34;11&#34; in the two msbs. The conditional arithmetic field allows one of two arithmetic or data move commands to be implemented depending upon the state of the conditional and is therefore capable of performing the IF-THEN-ELSE function aforedescribed. 
     As seen in Table 4a, the conditional arithmetic field supports all of the conditionals of the branch field (&#34;01&#34;); i.e. iPSA, iNGA, iPSB, iNGB, etc. The arithmetic functions supported, which are chosen as a result of the determination of the conditionals, include all the arithmetic functions in the arithmetic and data move field (&#34;00&#34;), and also four data move functions: move register A with shift; move complement of register A with shift; move register B; and move complement of register B. Field &#34;11&#34; also supports a two cycle no operation function, but does not support secondary microinstructions. 
     The coding of the supported conditional arithmetic field functions is seen in Table 4b. As aforestated, the two msb&#39;s are set to values of one. The bit code for a first arithmetic function which can be performed is set in bit locations I26 through I23. With those four bits, sixteen unique arithmetic or data move functions may be defined. Likewise, the bit code for a second arithmetic function which can be performed is set in bits I3 through I0, allowing a different one of the sixteen unique arithmetic or data move functions to be chosen. The control bits for choosing which arithmetic function is to be performed are located in bits I8 through I4 and comply with the code set forth with regard to the identical bits in Table 3b. Thus, IF the conditional set forth in bits I8 through I4 is satisfied, THEN the arithmetic or data move function set forth in bits I26 through I23 are accomplished in the ALU; ELSE (i.e. if the conditional is not satisfied) the arithmetic or data move function set forth in bits I3 through I0 is accomplished in the ALU. 
     It will be seen in Table 4b that the arithmetic and data move functions set forth in bit locations I26 through I23 and I3 through I0 each include a shift capability. Thus, the shift bits for the first arithmetic or data move function are placed in bit locations I22 through I19 while the second set of shift bits are located in bit locations I14, I13, I10 and I9. The results of the arithmetic or data move functions are loadable into any or all of the four registers indicated by bits I18 through I15 (a no operation being carried out by setting all of those bits to a value of one such that no register accepts the bits). Finally, bits I12 and I11 contain a two bit select code &#34;00&#34; which specifies that the bus 39 is to be driven by the PALU 40. 
     The conditional arithmetic field operations as provided preferably take two clock cycles to be implemented due to the fact that it is desirable to wait for the flag inputs selected by bits I8 through I4 to settle prior to using them to control the selection of the arithmetic function to be performed. Indeed, it is desirable to wait until the end of a cycle before determining whether the conditional is true or not. Thus, as seen in the timing diagram of FIG. 4 which is a timing diagram for the IF-THEN-ELSE instructions 
     
         IF value&gt;5120 THEN value=5120 ELSE value=value 
    
     
         IF value&lt;544 THEN value=544 ELSE value=value, 
    
     Register A is loaded with a value during clock cycle two and Register B is loaded with the value 5120 during clock cycle three. The comparison of Registers A and B to provide a flag is possibly not available until the end of clock cyclc three. Thus, the AGTT $MVB #MVA microinstruction cannot be addressed until clock cycle four. In other words, because the AGTT (Register A greater than Register B) flag might not be available until the end of clock cycle three, the microinstruction to be decoded may have to be decoded during clock cycle 4 and can therefore only be executed during clock cycle 5. 
     An examination of the conditional branch microinstructions shows that those conditional branch microinstructions requiring flag information from the PALU are designated as two clock cycle instructions by the location of a logic &#34;1&#34; in bit position I1. It will be appreciated, however, that if the previous microinstruction does not cause a change in the flag state of the PLU, there is no reason to provide two clock cycles for the execution of branch microinstructions using flags from the PALU. Indeed, the branch instruction can be executed in one cycle. Those skilled in the art will recognize that this option (a one clock cycle branch) could be made available through a modification to the microcode assembler, either through the use of a different mnemonic or by appending an option character to the present mnemonic. It will also be appreciated that the bus directed conditional branch microinstructions are designated as one cycle operations. The reason for such a designation is that it is preferable to prevent the bus from floating for an entire cycle prior to being read. Thus, the microcode should be arranged such that the microinstruction immediately prior the bus directed branch does not change the flag state of the PALU. If, however, the branch address is coming from the PALU (which is not the case in the ADPCM microinstruction code) and the carry flag, for example, must be tested, then the branch must wait one cycle before executing, and the bus must be allowed to float. Again, the provision of a one or two cycle bus directed branch could be arranged through previously described modifications to the system. It is also noted that all the conditional arithmetic microinstructions (field three) are designated as two clock cycle operations. While again it might be possible to perform the conditional arithmetic microinstruction in one cycle if no flags were changing, such a situation is not supported as there are not sufficient bits in the twenty-nine bit words to allow such an arrangement given the options supported by field three. It will be appreciated however, that by changing the other options, or by adding a bit to the word length, a one or two clock cycle opion could be implemented. 
     Turning to FIG. 3, it is seen that the microinstruction decoder 30 of the MIS 20 includes several registers as well as several multiplexers. The twenty-nine bit words exiting ROM 25 are read by several of the registers depending upon the field to which the word belongs. Thus, a microinstruction field decoder 202 receives the most significant bits I28 and I27 of the ROM word and provides signals to enable the other registers as desired. The enabling of the registers for a particular field is indicated by the letters &#34;FLD&#34;, the number of the field enabled, and an arrow into the register. 
     Where an arithmetic, logical, or data move operation is to be conducted (field &#34;00&#34;), bits I26 through I23 are sent through multiplexer 204 to the enabled PALU register 206 which sends the bits as function control bits to the PALU. In a similar manner, bits I22-I19 are sent through multiplexer 208 to the enabled shift control register 212 which sends the bits as shift control bits to the shifter of the PALU. Both multiplexers 204 and 208, as will be described in greater detail hereinafter, are under the control of the microinstruction sequencer controller 32. Bits I18 through I15 are sent to the destination register 216 which selects the registers in the DSP to receive the results of the operation, while bits I12 and I11 are sent to one of four decoder 218 and then to source register 222 (which also receives bits I14 and I13 which decodes the elements of the RAM section) where they are used to decode which section of the DSP (in this case the PALU) is to drive the bus 39. 
     In the field &#34;00&#34; arrangement, bits I10-I6 are sent to the secondary microinstruction field decoder register 226 which decodes the secondary microinstructions and provides corresponding control signals as indicated to the I/O section of the ADPCM VLSI device as well as to the various sections of the DSP. Finally, bits I5-I0 are sent via multiplexer 228 to the RAM address register 232 to specify the RAM read or write address. As indicated, the MIS controller 32, can also control multiplexer 228 and can specify that the RAM address to be specified is the address indicated by the six lsb&#39;s on the bus 39. In this manner the LDMB instruction is implemented. 
     Turning to field &#34;01&#34;, it will be appreciated that the only circuitry which decodes field &#34;01&#34; is the field decoder 202 which receives the two msb&#39;s, the secondary field decoder 226 which receives bits I26, I25 and I0 and generates the RTEI, RTDI, and RESET ENABLE control signals, and the MIS controller 32 which in field &#34;01&#34; receives the remaining bits except for bits I24 through I15. As aforestated with regard to Tables 2a and 2b, bits I8-I4 are used to determine which flag input into the MIS controller 32 is to be read, while bits I10, I9, and I3 and I2 are used to permit the microsequencer controller 32 to control the stack 36, and the next address multiplexer 38. Bits I1 and I0 which are also sent to the MIS controller 32 permit the controller 32 to specify a one or two clock cycle operation (by causing the microinstruction register 33 and pointer to the ROM to not provide an additional microinstruction to decode and execute in the case of a two clock cycle operation). Bits I26, I25 and I0 are sent to the secondary field decoder 226, where I26 and I25 are decoded and generate the RTEI and RTDI signals, while I0 is used to reset all the MIS circuitry for the RESET operation. Bits I24 through I15 which set forth a direct branch address (or indicate a bus directed address) are sent to the microinstruction register 33 via the next address register 38 via an internal bus 37 (seen in FIG. 1). 
     In field &#34;2&#34; (&#34;10&#34;), the microinstruction field decoder 202 receives bits I28 and I27, the destination register 216 receives bits I18-I15, the source register 222 and one of four decoder 218 receives bits I14-I11, and the secondary microinstruction field decoder 226 receives bits I10-I6 just as in field &#34;0&#34; (&#34;00&#34;). However, bits I26-I19, I14, I13 and I5-I0 are sent to the ROM data coefficient register 236 from whence they are sent out on the bus 39 to the registers defined by destination register 216. 
     For the conditional ALU operations of field &#34;3&#34; (&#34;11&#34;), the microinstruction field decoder 202, the destination register 216, and the source register 222 and one of four decoder 218 receive bits I28-27, I18-15 and I12-I11 respectively (bits I14 and I13 which specify the circuitry driving the internal RAM bus being irrelevant in field &#34;3&#34;). The remainder of the bits are divided among two sets of bits (I23-I20, and I3-I0) for instructing the PALU as to the function it is to perform, two sets of shift bits (I22-I19, and I14-I13 and I10-I9) for instructing the shifter of the PALU as to the shifting it is to perform, a set of control bits (I8-I4) for instructing the MIS controller 32 as to which set of PALU and shift bits are to be passed through multiplexers 204 and 208 to the ALU and shift registers 206 and 212. Thus, the MIS controller 32, based on flag inputs which are specified by bits I8 through I4, controls multiplexers 204 and 208 to allow only one set of PALU function control bits to the PALU register 206 and the corresponding set of PALU shift control bits to the shift register 212. 
     The operation of various elements of the MIS 20 seen in FIGS. 1 and 3 may be better understood from the following sequence of microinstructions: 
     
         __________________________________________________________________________
800     CPSA: LABEL; Call &#34;Label&#34; if Reg. A &gt;=0                           
801     MVC:  *;     Move contents of Reg. C                              
                     to bus                                               
        $STC: MEM.LOC 7;                                                  
                     Store contents of Reg. C in                          
                     RAM                                                  
                     memory location 7 (secondary                         
                     microinstruction)                                    
802     LDMB: A;     Load Reg. A with value in                            
                     memory                                               
                     loc. specified by value on bus                       
803     . . .                                                             
1022                                                                      
   LABEL                                                                  
        AGT:  C;     IF value in Reg. A &gt; value in                        
        $ADD: R4;    Reg. B, THEN C = (1/16)A + B;                        
        #MYA: R2;    ELSE C = (1/4)A                                      
1023    RETN:        Return to main program (801)                         
__________________________________________________________________________
 
    
     Step 800 of the microinstruction sequence is seen to be a field one conditional branch operation which would be coded: 
     
         01111111111110xxxx11110101111 
    
     with bits I28 and I27 being decoded by field decoder 202 to indicate field one; bits I26 and I25 going to MIS controller 32 to indicate a conditional branch; bits I24 through I15 specifying the location 1022 of the subroutine Label; bits I14 through I11 being left undefined; bits I10, I9 and I2 going to MIS controller 32 to indicate a CALL operation; bits I8 through I4 going to MIS controller 32 to indicate that the A SIGN BIT FLAG obtained from the PALU 40 is to be inspected; and bits I3, I1 and I0 going to the MIS controller 32 to MIS housekeeping functions such as the cycle length of the operation, etc. If the A SIGN BIT FLAG has a logic &#34;1&#34; (i.e. true), the CALL proceeds with the microsequencer controller 32 instructing the next address multiplexer 38 to send the microinstruction register 33 the value 1022 (&#34;1111111110&#34;), and instructing the stack 36 to place the address 801 stored in the incrementer 34 on the top of the stack. 
     Microinstruction 1022 is a field three microinstruction which would be coded: 11001000111011000001001111100. Bits I28 and I27 would be decoded by the field decoder 202 to control the registers to receive the remaining bits. Bits I26-I23 would provide the code for the PALU function &#34;ADD&#34; the values in Registers A and B, while bits I3-I0 would provide the code for the data move command &#34;MOVA A&#34;. Likewise, bits I22 through I19 would indicate a right shift of Register A by four places (a division by sixteen) while bits I14-I13 and I10-I9 would indicate a shift right of Register A by two places (division by four), with the output of the PALU going to Register C as dictated by bits I18-I15 received by destination register 216. MIS controller 32 is told by bits I8-I4 that it should check a flag output by the comparator 46 of the PALU 40 which indicates whether the value in Register A 42 is greater than the value in Register B 44. If the flag indicates true, the MIS controller 32 causes multiplexers 204 and 208 to accept bits I26-I23 and bits I22-I19 respectively. If the flag indicates false, bits I3-I0 and I14-I13 and I10-I9 are passed to the PALU function control register 206 and PALU shift control register 212 respectively through multiplexers 204 and 208 under the control of MIS controller 32. The bus driver of the PALU is enabled to output the results of the PALU operation to Register C of the RAM section 60 by bits I12 and I11 which are read by one of four decoder 218 and source register 222 and which specify the bus driver of the PALU 40. 
     After a field three operation, the MIS controller 32 instructs the next address multiplexer 34 to pass the address located in the incrementer 34 to the microinstruction register 33. Thus, the next addressed location in ROM is location 1023 which sets forth a field one &#34;RETURN&#34; operation coded 0111xxxxxxxxxxxxxx10011111101. Without going through all the details, it will be appreciated that bits I10 and I9 which are decoded at the MIS controller 32 indicate that the &#34;RETURN&#34; is to be executed. In response, the MIS controller 32 causes the stack 36 to pop the address 801 from the stack and to load that via next address multiplexer 38 into the microinstruction register 33. Also, the pointer in the stack is decremented. 
     Turning to microinstruction 801, a field zero and secondary microinstruction are set forth in the code: 0011110100111100101001000111. For field zero, bits I26-I23 instructing the PALU are set to a default value &#34;1111&#34;, while bits I22-I19 are set to the default value &#34;0010&#34;, since the PALU is not actively involved in the move Register C operation. Bits I18 through I15 which are read by the destination register 216 indicate that none of the registers are to receive the moved bits (although the data bus will). Bits I14 through I11 are used by the source register 222 to enable the bus drivers of the RAM section 60, and in particular Register C of the RAM section. Finally, bits I10-I0 are sent to the secondary microinstruction field register and decoder 226 where bits I10-I6 indicate that the contents of Register C are to be stored in the RAM memory, and bits I5-I0 are given to indicate that the memory loction is location &#34;7&#34; (i.e. &#34;000111&#34;). Again, since the MIS controller is aware of the field of the previous instruction, it causes the microinstruction register 33 to receive its next address from the incrementer 34 via the next address multiplexer 38. 
     The last microinstruction of the given sequence is also a field zero microinstruction and is coded 00111101001110111001110xxxxxx. Here bit I15 is a value &#34;0&#34; to indicate to the destination register 216 that Register A is to be loaded. The value to be loaded into Register A is the data from the RAM address location specified by the least significant six bits of the data bus set in the previous cycle 801 when the contents of Register C were loaded onto the bus. 
     There has been described and illustrated herein a microinstruction sequencer capable of instructing arithmetic, logical and data move operations in a conditional manner. While the invention has been described in detail with regard to the microcode and the manner in which the microcode is decoded and acted upon, those skilled in the art will appreciate that different bit assignments and different functions could be provided while still carrying out the invention. For example, the microinstruction fields could be assigned different numbers. Or, if the PALU had been provided with a shifter for register B, a different set of functions could be provided, such as add the value of register A shifted left two places to the value of register B shifted right three placed. Further, if desired, microinstructions and circuitry could be provided to permit conditional data move operations where the source of data is a RAM location, or a register other than the registers of the PALU. Likewise, the destination of conditional arithmetic, logical, and data move operations could be made contingent on the conditional (e.g. IF condition TRUE, C=B; ELSE D=A; IF condition FALSE, C=PORT 1; ELSE B=PORT 2; IF condition TRUE, A= RAM LOC m; ELSE A=RAM LOC n). Additional functions of this genre might be achieved by lengthening the bit length of the microinstructions or by defining additioal microinstruction fields. Of course, appropriate multiplexer logic circuitry (as shown in phantom as multiplexers 217, 219, and 229) would have to be added in conjunction with the source decode register 222, the RAM address register 232 and the destination register 216. Therefore, it will be apparent to those skilled in the art that other changes and modifications may be made to the invention as described in the specification without departing from the spirit and scope of the invention as so claimed. 
     THE PARALLEL ARITHMETIC-LOGIC UNIT 
     The preferred PALU 40 of the invention is seen in FIG. 1, and preferably comprises: a first register 42 (register A) for storing data; a second register 44 (register B) for storing data; an unsigned magnitude comparator means 46; a shifter 48 for shifting the bits in register 20; and an arithmetic-logic core means 50 for performing arithmetic, logic, and data move functions. As is suggested by FIG. 1, registers 42 and 44, shifter 48, and the arithmetic-logic core 50 are all controlled by a microinstruction sequencer which can select registers 42 and 44, provide shift control bits to shifter 48, and provide function control bits to arithmetic-logic core 50. 
     Registers 42 and 44 are preferably sixteen bits in length. Both registers are loaded on the positive edge of the clock by the application of an active low select derived from decoded microinstruction sequencer instructions called REG A SEL and REG B SEL respectively. The most significant bit of both registers 42 and 44 are output to the microinstruction sequencer as register 42 and register 44 sign bit flags, named ASIGN and BSIGN respectively. 
     The shifter 48 is located between register 42 and the &#34;A&#34; input into the arithmetic-logic unit core 50. The shifter thereby enables a shift operation to be performed on the data held in register 42. While a large range of shift values could be supported by the shifter, for purposes of implementing the ADPCM algorithm, the shifter 48 supports as many as eight shifts to the right (with extension of the sign bit), and as many as four shifts to the left (with zero filling of the bits to the right of the 1sb). In this manner, the value in register 42 may be divided by two for a single shift right, by four for two shifts right . . . and by two hundred and fifty-six if eight right shifts are carried out. Likewise, the value in register 20 may be multiplied by two for a single shift left . . . and by sixteen for four shifts left. The number and direction of shifting is supplied by control bits decoded in the ALU decode register of the microinstruction sequencer. To permit the thirteen shift states (-8 to 0 to 4), four bits (which could support sixteen states) are required. 
     The unsigned magnitude comparator 46 continually performs an unsigned comparison on the values stored in registers 42 and 44. Logic means (not shown) are preferably used to make the comparison. As a result of the comparison, the comparator 46 preferably outputs five flag combinations (3 flag bits) representative of the following conditions: Register 42&gt;Register 44; Register 42=Register 44; Register 42&lt;Register 44; Register 42&gt;=Register 44; and Register 42&lt;=Register 44; with the latter two conditions being derived from the former three conditions. The three output flags are sent to the microinstruction sequencer, for among other reasons, to help it determine the truth of a conditional such that it will be able to properly instruct the arithmetic-logic unit core 50 as to the function it is to execute. 
     The provision of the comparator (which may be an unsigned magnitude, signed magnitude, or two&#39;s compliment comparator as desired) for continually comparing the outputs of registers 42 and 44 is a significant feature of the digital signal processor which is provided to implement the ADPCM algorithm. Without the comparator, compare operations would have to be conducted by the arithmetic-logic unit core 50 via subtraction techniques. As a result, two passes through the PALU 40 would be required to conduct a conditional arithmetic, conditional data move, or conditional logical instruction, thereby slowing down the process. Moreover, ROM space in the microinstruction sequencer would have to be expanded as additional instructions would be required to conduct a conditional instruction. 
     The preferred arithmetic-logic core 50 of the invention is provided with the capability of performing the following arithmetic, logical and data move operations: 
     
         ______________________________________                                    
A SUB B  register 42 as shifted minus register 44                         
A SBB B  register 44 minus register 42 as shifted                         
A ADD B  register 42 as shifted plus register 44                          
CVT B    convert register 44 from two&#39;s complement to sign                
         magnitude or visa versa                                          
ABS B    absolute value of register 44                                    
NEG B    negate value of register 44                                      
INC B    increment value of register 44                                   
DEC B    decrement value of register 44                                   
A XOR B  XOR function register 42 as shifted with register 44             
A ORR B  OR function register 42 as shifted with register 44              
A AND B  AND function register 42 as shifted with register 44             
MVA      place contents of register 42 as shifted onto bus                
MVNA     place complement of shifted register 42 onto bus                 
MVB      place contents of register 44 onto bus                           
MVNB     place complement of register 44 onto bus                         
______________________________________                                    
 
    
     The means for accomplishing most of the above-listed functions in the arithmetic-logic core means are well known to those skilled in the art. In fact, even the ABS B and CVT B functions which are not standard in PALU&#39;s, could be easily implemented in a PALU by one skilled in the art. 
     As with the control bits for the shifter 48, the four control bits for determining which function the arithmetic-logic core means will execute is supplied by control bits decoded in the ALU decode register of the microinstruction sequencer. In turn, the arithmetic-logic core 50 supplied the microinstruction sequencer with two flags which indicate arithmetic overflow and carry conditions in the arithmetic-logic core 50. 
     With the provided registers 42 and 44, comparator 46, and arithmetic-logic core 50, it will be appreciated that a conditional operation such as an upper bound may be executed in a single pass through the PALU. Thus, after loading Register A 42 with first value, and Register B 44 with a second value, the comparative status of the registers (i.e. is A&gt;B; is A=B; is A&lt;B; is A&gt;=B; is A&lt;=B) will be automatically available to the microinstruction sequencer via the flags of the comparator 46. Without having to have first instructed the arithmetic-logic core 50 of the PALU 40 to subtract the value in Register B from the value in Register A to obtain a determination of the relative values, the microinstruction sequencer can then make a decision as to the what value to set the value in Register A and can issue its first instruction to the arithmetic-logic core of the PALU. Microinstruction sequencer means for accomplishing this decision and function in a single microinstruction will be seen with reference to the patent application entitled &#34;Microinstruction Sequencer Capable of Instructing Arithmetic Logical and Data Move Operations in a Conditional Manner&#34; (Pat. #4,891,754), which has already been incorporated herein by reference. 
     There has been described and illustrated herein a parallel arithmetic-logic unit capable of executing conditional arithmetic, logical and data move operations in a single pass. While each element of the PALU has been described in detail, it will be appreciated that it is within the scope of the invention to change such detail. Thus, while the arithmetic-logic core of the PALU has been particularly described with regard to the functions it can execute, those skilled in the art will appreciate that the core could be arranged to execute a different set of functions. Likewise, while an unsigned magnitude comparator is the comparator of choice, other types of comparators may be utilized. Further, while the comparator is described as continually comparing the values in the registers, it will be appreciated that the term &#34;continually&#34; is intended to mean that the comparison is conducted so very often that up-to-date results will be available without waiting for the comparison. Further yet, while particular elements of the PALU have been disclosed, additional elements can be provided such as additional input registers, an accumulator at the output of the PALU, and additional comparators for comparing the additional input registers. In addition, the elements can be connected differently such as a comparator which compares an input register with a shifted value, or a direct connection of the arithmetic-logic core to the data bus. With such a data bus connection, immediate data PALU instructions or RAM data for a specific PALU operation can be supported. Therefore, it will be apparent to those skilled in the art that other changes and modifications may be made to the invention as described in the specification without departing from the spirit and scope of the invention as so claimed. 
     CONCLUSION 
     It will be appreciated that the RAM section 60, the MIS 20, the PALU 40 and the Serial Arithmetic Processor 70 together provide a powerful and flexible tool for implementing complex algorithms in a single DSP device. For example, the ADPCM algorithm may be implemented in the single DSP device 10. Indeed, (copyrighted) microcode for implementing the 32 Kbit CCITT ADPCM recommendations as well as other ADPCM rates and algorithms is seen appended hereto as APPENDIX A. While the microcode of Appendix A provides a working code for accomplishing the ADPCM algorithm with the provided DSP, it will be appreciated by those skilled in the art, that a different programmer would provide different code which likewise could be used with the DSP of the invention. It will also be recognized that the DSP invention is flexible in that changes to the ADPCM algorithm would not severly hamper the functioning of the DSP device as changes to the relatively short MIS microcode could be made to handle the same. Further, it will be recognized that the DSP device as provided could also be used for the fast implementation of other algorithms. 
     There has been described and illustrated herein a digital signal processor capable of implementing mathematically complex algorithms, and in particular capable of implementing a series of ADPCM algorithms. While the particular elements of the digital signal processor invention have been set forth in great detail, those skilled in the art will appreciate that particular details of, for example, the serial arithmetic processor section or the PALU may be changed without affecting the overall functioning of the DSP. For example, the PALU might contain no comparator if appropriate commands could be executed by the MIS to accomplish the function of the comparator in another manner. Indeed, the particular aspects of the PALU, the MIS, and the serial arithmetic processor which are themselves subjects of the patent applications previously incorporated by reference herein, permit the DSP to be extremely effective in executing numerous algorithms with a VLSI of limited size. However, if some of those aspects were not included, the DSP could still effectively function due to its powerful and flexible architecture. Therefore, it will be apparent to those skilled in the art that other changes and modifications may be made to the invention as described in the specification without departing from the spirit and scope of the invention as so claimed. 
     
                                           TABLE 1a                                
__________________________________________________________________________
FIELD 0                                                                   
__________________________________________________________________________
Arithmetic and Logical Commands                                           
ADD   &lt;sh,dd&gt;                                                             
            Add reg A with shift to reg B                                 
SUB   &lt;sh,dd&gt;                                                             
            Subtract reg B from reg A with shift                          
SBB   &lt;sh,dd&gt;                                                             
            Subtract reg A with shift from reg B                          
CVT   &lt;dd&gt;  perform on reg B a Two&#39;s Compliment to Signed Magnitude       
            conversion, or Signed Magnitude to Two&#39;s Compliment           
            conversion.                                                   
ABS   &lt;dd&gt;  Find the absolute value of reg B                              
NEG   &lt;dd&gt;  Negate reg B                                                  
INC   &lt;dd&gt;  Increment reg B                                               
DEC   &lt;dd&gt;  Decrement reg B                                               
AND   &lt;sh,dd&gt;                                                             
            AND reg A with shift with reg B                               
ORR   &lt;sh,dd&gt;                                                             
            OR reg A with shift with reg B                                
XOR   &lt;sh,dd&gt;                                                             
            Exclusive-OR reg A with shift with reg B                      
NOP1        One cyle No-operation                                         
189 Data Move commands:                                                   
MVA   &lt;sh,dd&gt;                                                             
            Move reg A with shift                                         
MVNA  &lt;sh,dd&gt;                                                             
            Move compliment of reg A with shift                           
MVB   &lt;dd&gt;  Move reg B                                                    
MVNB  &lt;dd&gt;  Move compliment of reg B                                      
MVC   &lt;dd&gt;  Move reg C                                                    
MVE   &lt;dd&gt;  Move reg E                                                    
MVP1  &lt;dd&gt;  Move data port 1                                              
MVP2  &lt;dd&gt;  Move data port 2                                              
LDM   &lt;dd,mm&gt;                                                             
            Move data memory location direct                              
LDMB  &lt;dd&gt;  Move data memory location bus direct                          
__________________________________________________________________________
 
    
     
                                           TABLE 1b                                
__________________________________________________________________________
FIELD 0                                                                   
Mnemonic                                                                  
      Cycles                                                              
          28 27 26 25 24 23                                               
                    22 21 20 19                                           
                          18 17 16 15                                     
                                 14                                       
                                   13                                     
                                     12                                   
                                       11                                 
                                         10                               
                                           9 8 7 6 5 4 3 2 1 0            
__________________________________________________________________________
Arithmetic and Logical Commands                                           
SUB sh,dd                                                                 
      1   0 0 0 0 0 0                                                     
                    sh    dd     . . 0 0 . . . . . . . . . . .            
SBB sh,dd                                                                 
      1   0 0 0 0 0 1                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
ADD sh,dd                                                                 
      1   0 0 0 0 1 0                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
CVT dd                                                                    
      1   0 0 0 1 0 0                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
ABS dd                                                                    
      1   0 0 0 1 0 1                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
NEG dd                                                                    
      1   0 0 0 1 1 0                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
INC dd                                                                    
      1   0 0 0 1 1 1                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
DEC   1   0 0 1 0 0 0                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
XOR sh,dd                                                                 
      1   0 0 1 0 0 1                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
ORR sh,dd                                                                 
      1   0 0 1 0 1 0                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
AND sh,dd                                                                 
      1   0 0 1 0 1 1                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
NOP1  1   0 0 1 1 1 1                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
Data Move Commands                                                        
MVA sh,dd                                                                 
      1   0 0 1 1 0 0                                                     
                    sh    dd     . . 0 0 . . . . . . . . . . .            
MVNA sh,dd                                                                
      1   0 0 1 1 1 0                                                     
                    sh    dd     . . 0 0 . . . . . . . . . .  .           
MVB dd                                                                    
      1   0 0 1 1 0 1                                                     
                    0 1 0 0                                               
                          dd     . . 0 0 . . . . . . . . . .  .           
MVNB dd                                                                   
      1   0 0 1 1 1 1                                                     
                    0 1 0 0                                               
                          dd     . . 0 0 . . . . . . . . . .  .           
MVC dd                                                                    
      1   0 0 1 1 1 1                                                     
                    0 1 0 0                                               
                          dd     0 0 1 0 . . . . . . . . . .  .           
MVE dd                                                                    
      1   0 0 1 1 1 1                                                     
                    0 1 0 0                                               
                          dd     . . 1 1 . . . . . . . . . .  .           
MVP1 dd                                                                   
      1   0 0 1 1 1 1                                                     
                    0 1 0 0                                               
                          dd     1 0 1 0 see table 5a, 5b                 
MVP2 dd                                                                   
      1   0 0 1 1 1 1                                                     
                    0 1 0 0                                               
                          dd     0 1 1 0 see table 5a, 5b                 
LDM dd,mm                                                                 
      1   0 0 1 1 1 1                                                     
                    0 1 0 0                                               
                          dd     1 1 1 0 table 5a, 5b                     
                                                   M5 M4 M3 M2 M1 M0      
LDMB dd                                                                   
      1   0 0 1 1 1 1                                                     
                    0 1 0 0                                               
                          dd     1 1 1 0 0 1 1 1 0 X X X X X X            
__________________________________________________________________________
                          R4                                              
                            0 0 1 1                                       
                                  0                                       
                                  0 1 0 0                                 
                                      L4                                  
                                        1 0 0 0                           
                                            L8                            
                                              1 1 0 0                     
                                                  REG A                   
                                                       X X X 0            
                          R3                                              
                            0 0 1 0                                       
                                L1                                        
                                  0 1 0 1                                 
                                      L5                                  
                                        1 0 0 1   REG B                   
                                                       X X 0 X            
                          R2                                              
                            0 0 0 1                                       
                                L2                                        
                                  0 1 1 0                                 
                                      L6                                  
                                        1 0 1 0   REG C                   
                                                       X 0 X X            
                          R0                                              
                            0 0 0 0                                       
                                L3                                        
                                  0 1 1 1                                 
                                      L7                                  
                                        1 0 1 1   REG D                   
                                                       0 X X X            
__________________________________________________________________________
 &#34;.&#34; see table 5a, 5b, and 5c                                             
 &#34;X&#34; denotes don&#39;t care                                                   
 &#34;sh&#34; Shift Values (R = right shift, L = left shift)                      
 &#34;dd&#34; Destination Code                                                    
 
    
     
                       TABLE 2a                                                    
______________________________________                                    
 FIELD 1                                                                  
______________________________________                                    
Unconditional branch Commands:                                            
JUMP    &lt;n&gt;          Jump direct                                          
JUMP    &lt;*&gt;          Jump bus direct                                      
CALL    &lt;n&gt;          Call direct                                          
CALL    &lt;*&gt;          Call bus direct                                      
RETN                 Return from call                                     
RTEI                 Return from encode interrupt                         
RTDI                 Return from decode interrupt                         
CLRE                 Clear encode flag                                    
CLRD                 Clear decode flag                                    
REST                 Reset program counter                                
Conditional branch Commands:                                              
iPSA[N] &lt;n&gt; or &lt;*&gt;   If reg A is positive                                 
iNGA[N] &lt;n&gt; or &lt;*&gt;   If reg A is negative                                 
iPSB[N] &lt;n&gt; or &lt;*&gt;   If reg B is positive                                 
iNGB[N] &lt;n&gt; or &lt;*&gt;   If reg B is negative                                 
iGTT[N] &lt;n&gt; or &lt;*&gt;   If reg A is greater than reg B                       
iLST[N] &lt;n&gt; or &lt;*&gt;   If reg A is less than reg B                          
iGTE[N&gt; &lt;n&gt; or &lt;*&gt;   lf reg A is greater than or equal to                 
                     reg B                                                
iLTE[N] &lt;n&gt; or &lt;*&gt;   If reg A is less than or equal to reg B              
iEQU[N] &lt;n&gt; or &lt;*&gt;   If reg A is equal to reg B                           
iMLW[N] &lt;n&gt; or &lt;*&gt;   If Mu-law flag is set                                
iALW[N] &lt;n&gt; or &lt;*&gt;   If A-law flag is set                                 
iCYF[N] &lt;n&gt; or &lt;*&gt;   If PALU Carry flag is set                            
iOVF[N] &lt;n&gt; or &lt;*&gt;   If PALU Overflow flag is set                         
iECF[N] &lt;n&gt; or &lt;*&gt;   If Encode flag is set                                
iDCF[N] &lt;n&gt; or &lt;*&gt;   If Decode flag is set                                
iPTH[N] &lt;n&gt; or &lt;*&gt;   If PCM pass-through flag is set                      
iNAMC[N]                                                                  
        &lt;n&gt; or &lt;*&gt;   If North American flag is set                        
iEXT[N] &lt;n&gt; or &lt;*&gt;   If External flag is set                              
______________________________________                                    
 
    
     
                                           TABLE 2b                                
__________________________________________________________________________
 FIELD 1                                                                  
__________________________________________________________________________
Unconditional Branch Commands                                             
Mnemonic                                                                  
      Cycles                                                              
          28 27 26 25                                                     
                24 23 22 21 20 19 18 17 16 15                             
                               14 13 12 11                                
                                     10 9 8  7 6 5 4 3 2 1                
__________________________________________________________________________
                                             0                            
REST  1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               X X X X                                    
                                     0  0 0  1 1 1 1 1 1 0 0              
JUMP n                                                                    
      1   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     1  1 0  1 1 1 1 1 0 0 1              
JUMP *                                                                    
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     1  1 0  1 1 1 1 0 0 0 1              
CALL n                                                                    
      1   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     1  1 0  1 1 1 1 1 1 0 1              
CALL *                                                                    
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     1  1 0  1 1 1 1 0 1 0 1              
RETN  1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               X X X X                                    
                                     1  0 0  1 1 1 1 1 1 0 1              
RTEI  1   0 1 0 1                                                         
                X X X X X X X X X X                                       
                               X X X X                                    
                                     1  0 0  1 1 1 1 1 1 0 1              
RTDI  1   0 1 0 0                                                         
                X X X X X X X X X X                                       
                               X X X X                                    
                                     1  0 0  1 1 1 1 1 1 0 1              
Encode and Decode Flag Clear Commands                                     
Mnemonic                                                                  
      Cycles                                                              
          28 27 26 25                                                     
                24 23 22 21 20 19 18 17 16 15                             
                               14 13 12 11                                
                                     10 9 8  7 6 5 4 3 2 1                
__________________________________________________________________________
                                             0                            
CLRE  1   0 1 0 1                                                         
                X X X X X X X X X X                                       
                               X X X X                                    
                                     0  1 0  1 1 1 1 1 1 0 1              
CLRD  1   0 1 0 0                                                         
                X X X X X X X X X X                                       
                               X X X X                                    
                                     0  1 0  1 1 1 1 1 1 0 1              
Conditional Direct Branch Commands                                        
Mnemonic                                                                  
      Cycles                                                              
          28 27 26 25                                                     
                24 23 22 21 20 19 18 17 16 15                             
                               14 13 12 11                                
                                     10 9 8  7 6 5 4 3 2 1                
__________________________________________________________________________
                                             0                            
iPSA[N]n                                                                  
      2   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N#1                             
                                             1 0 1 0 1 p 1 1              
iNGA[N]n                                                                  
      2   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N#0                             
                                             1 0 1 0 1 p 1 1              
iPSB[N]n                                                                  
      2   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N#1                             
                                             1 0 0 1 1 p 1 1              
iNGB[N]n                                                                  
      2   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N#0                             
                                             1 0 0 1 1 p 1 1              
iGTT[N]n                                                                  
      2   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N  0 1 1 1 1 p 1 1              
iLST[N]n                                                                  
      2   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N  0 0 1 1 1 p 1 1              
iGTE[N]n                                                                  
      2   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N  0 1 1 0 1 p 1 1              
iLTE[N]n                                                                  
      2   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N  0 1 0 0 1 p 1 1              
iEQU[N]n                                                                  
      2   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N  0 1 0 1 1 p 1 1              
iMLW[N]n                                                                  
      1   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N#0                             
                                             1 0 0 0 1 p 0 1              
iALW[N]n                                                                  
      1   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N#1                             
                                             1 0 0 0 1 p 0 1              
iCYF[N]n                                                                  
      2   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N  0 0 0 0 1 p 1 1              
iDCF[N]n                                                                  
      1   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N  0 0 0 1 1 p 0 1              
iPTH[N]n                                                                  
      1   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N  1 0 1 1 1 p 0 1              
iNAM[N]n                                                                  
      1   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N  1 1 0 0 1 p 0 1              
iEXT[N]n                                                                  
      1   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N  1 1 0 1 1 p 0 1              
iOVF[N]n                                                                  
      2   0 1 1 1                                                         
                n9 n8 n7 n6 n5 n4 n3 n2 n1 n0                             
                               X X X X                                    
                                     i    N  1 1 1 0 1 p 1 1              
Conditional Bus Direct Branch Commands                                    
Mnemonic                                                                  
      Cycles                                                              
          28 27 26 25                                                     
                24 23 22 21 20 19 18 17 16 15                             
                               14 13 12 11                                
                                     10 9 8  7 6 5 4 3 2 1                
__________________________________________________________________________
                                             0                            
iPSA[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N#1                             
                                             1 0 1 0 0 p 0 1              
iNGA[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N#0                             
                                             1 0 1 0 0 p 0 1              
iPSB[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N#1                             
                                             1 0 0 1 0 p 0 1              
iNGB[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N#0                             
                                             1 0 0 1 0 p 0 1              
iGTT[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  0 1 1 1 0 p 0 1              
iLST[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  0 0 1 1 0 p 0 1              
iGTE[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  0 1 1 0 0 p 0 1              
iLTE[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  0 1 0 0 0 p 0 1              
iEQU[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  0 1 0 1 0 p 0 1              
iMLW[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N#0                             
                                             1 0 0 0 0 p 0 1              
iALW[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N#1                             
                                             1 0 0 0 0 p 0 1              
iCYF[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  0 0 0 0 0 p 0 1              
iECF[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  0 0 1 0 0 p 0 1              
iDCF[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  0 0 0 1 0 p 0 1              
iPTH[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  1 0 1 1 0 p 0 1              
iNAM[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  1 1 0 0 0 p 0 1              
iEXT[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  1 1 0 1 0 p 0 1              
iOVF[N]*                                                                  
      1   0 1 1 1                                                         
                X X X X X X X X X X                                       
                               0 0 1 0                                    
                                     i    N  1 1 1 0 0 p 0                
__________________________________________________________________________
                                             1                            
 &#34;i&#34; = 1 1 (Jump or a Call, 1 0 (Return)                                  
 &#34;p&#34; = 0 (Jump), 1 (call or Return)                                       
 &#34;#&#34; = Exclusive OR                                                       
 &#34;X&#34; denotes don&#39;t care                                                   
 
    
     
                       TABLE 3a                                                    
______________________________________                                    
FIELD 2                                                                   
______________________________________                                    
        Immediate Data Command:                                           
        LDD          &lt;dd,b&gt;                                               
______________________________________                                    
 
    
     
                                           TABLE 3b                                
__________________________________________________________________________
FIELD 2                                                                   
__________________________________________________________________________
Immediate Data Command                                                    
Mnemonic                                                                  
      Cycles                                                              
           28 27 26 25 24 23 22 21 20 19 18 17 16 15                      
__________________________________________________________________________
LDD dd,b                                                                  
      1    1  0  b15                                                      
                    b14                                                   
                       b13                                                
                          b12                                             
                             b11                                          
                                b10                                       
                                   b9 b8 -- -- dd --                      
__________________________________________________________________________
Mnemonic                                                                  
      Cycles                                                              
           14 13 12 11 10 9  8  7  6  5  4  3  2  1  0                    
__________________________________________________________________________
LDD dd,b                                                                  
      b7   b6 0  1  -- -- -- -- -- b5 b4 b3 b2 b1 b0                      
__________________________________________________________________________
 
    
     
                                           TABLE 4a                                
__________________________________________________________________________
 FIELD 3                                                                  
Conditional Arithmetic Logical, and Data Move Commands:                   
__________________________________________________________________________
APSA[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If reg A is positive execute &lt;a1&gt;                           
              else execute &lt;a2&gt;                                           
ANGA[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If reg A is negative execute &lt;a1&gt;                           
              else execute &lt;a2&gt;                                           
APSB[N]                                                                   
      &lt;dd&gt;&lt;(a1,a2&gt;                                                        
              If reg B is positive execute &lt;a1&gt;                           
              else execute &lt;a2&gt;                                           
ANGB[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If reg B is negative execute &lt;a1&gt;                           
              else execute &lt;a2&gt;                                           
AGTT[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If reg A is greater than reg B execute &lt;a1&gt;                 
              else execute &lt;a2&gt;                                           
ALST[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If reg A is less than reg B execute &lt;a1&gt;                    
              else execute &lt;a2&gt;                                           
AGTE[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If reg A is greater than or equal to reg B                  
              execute &lt;a1&gt; else execute &lt;a2&gt;                              
ALTE[ N]                                                                  
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If reg A is less than or equal to reg B                     
              execute &lt;a1&gt; else execute &lt;a2&gt;                              
AEQU[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If reg A is equal to reg B execute &lt;a1&gt;                     
              else execute &lt;a2&gt;                                           
AMLW[N ]                                                                  
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If Mu-law flag is set execute &lt;a1&gt;                          
              else execute &lt;a2&gt;                                           
AALW[N]                                                                   
      &lt;dd&gt;&lt;(a1,a2&gt;                                                        
              If A-law flag is set execute &lt;a1&gt;                           
              else execute &lt;a2&gt;                                           
ACYF[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If PALU Carry flag is set execute &lt;a1&gt;                      
              else execute &lt;a2&gt;                                           
AOVF[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If PLU Overflow flag is set execute &lt;a1&gt;                    
              else execute &lt;a2&gt;                                           
AECF[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If Encode flag is set execute &lt;a1&gt;                          
              else execute &lt;a2&gt;                                           
ADCF[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If Decode flag is set execute &lt;a1&gt;                          
              else execute &lt;a2&gt;                                           
APTH[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If PCM pass-through flag is set execute &lt;a1&gt;                
              else execute &lt;a2&gt;                                           
ANAM[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If North American flag is set execute &lt;a1&gt;                  
              else execute &lt;a2&gt;                                           
AEXT[N]                                                                   
      &lt;dd&gt;&lt;a1,a2&gt;                                                         
              If External flag is set execute &lt;a1&gt;                        
              else execute &lt;a2&gt;                                           
__________________________________________________________________________
 
    
     
                                           TABLE 4b                                
__________________________________________________________________________
FIELD 3                                                                   
Conditional Arithmetic, Logical, and Data Move Commands                   
Mnemonic                                                                  
        Cycles                                                            
            28 27                                                         
               26 25 24 23                                                
                     22 21 20 19                                          
                           18 17 16 15                                    
                                 14 13                                    
                                     12 11                                
                                        10 9                              
                                            8  7 6 5 4                    
                                                   3 2 1                  
__________________________________________________________________________
                                                   0                      
APSA[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N #1                          
                                               1 0 1 0                    
                                                   alu 2                  
ANGA[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N#0                           
                                               1 0 1 0                    
                                                   alu 2                  
APSB[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N#1                           
                                               1 0 0 1                    
                                                   alu 2                  
ANGB[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N#0                           
                                               1 0 0 1                    
                                                   alu 2                  
AGT[N]                                                                    
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  0 1 1 1                    
                                                   alu 2                  
ALT[9]                                                                    
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  0 0 1 1                    
                                                   alu 2                  
AGTE[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  0 1 1 0                    
                                                   alu 2                  
ALTE[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  0 1 0 0                    
                                                   alu 2                  
AEQU[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  0 1 0 1                    
                                                   alu 2                  
AMLW[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N#0                           
                                               1 0 0 0                    
                                                   alu 2                  
AALW[9]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N#1                           
                                               1 0 0 0                    
                                                   alu 2                  
ACYF[9]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  0 0 0 0                    
                                                   alu 2                  
AECF[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  0 0 1 0                    
                                                   alu 2                  
ADCF[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  0 0 0 1                    
                                                   alu 2                  
APTH[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  1 0 1 1                    
                                                   alu 2                  
ANAM[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  1 1 0 0                    
                                                   alu 2                  
AEXT[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  1 1 0 1                    
                                                   alu 2                  
AOVF[N]                                                                   
      dd                                                                  
        2   1 1                                                           
               alu 1 sh1   dd    sh2msb                                   
                                     0 0                                  
                                        sh2lsb                            
                                            N  1 1 1 0                    
                                                   alu 2                  
__________________________________________________________________________
 Possible codes values for &#34;alu1&#34; and &#34;alu2&#34; are defined in bit positions 
 26 through 23 of table 2, and for &#34;sh1&#34; &#34;sh2&#34; in bit positions 22 through
 19 of table 2. &#34;sh2msb&#34; represents the most significant two bits of the  
 shift code while &#34;sh2lsb&#34; represents the least significant two bits of th
 shift code.                                                              
 
    
     
                       TABLE 5a                                                    
______________________________________                                    
 Secondary Field                                                          
______________________________________                                    
Control Commands:                                                         
LOG   Initiate signed magnitude to logarithm conversion                   
ALOG  Initiate logarithm to signed magnitude conversion                   
FLP   Initiate signed magnitude to floating point conversion              
LML   Initiate an 8 by 16 bit linear signed magnitude multipli-           
      cation                                                              
FML   Initiate a 4e, 6m by 4e, 6m floating point multiplication           
      with conversion from floating point to signed magnitude             
      conversion.                                                         
PAG0  Select data memory page 0                                           
PAG1  Select data memory page 1                                           
AOK   Set AOK flag high                                                   
ROK   Set ROK flag high                                                   
SOK   Set SOK flag high                                                   
Data I/O Commands:                                                        
PT3   Load data output port 3                                             
PT4   Load data output port 4                                             
Data Memory Store Commands:                                               
STC   &lt;mm&gt;     Direct memory store of reg C                               
STCB           Bus direct memory store of reg C                           
______________________________________                                    
 
    
     
                                           TABLE 5b                                
__________________________________________________________________________
Secondary Field                                                           
Mnemonic                                                                  
       14                                                                 
         13                                                               
           12                                                             
             11                                                           
               10                                                         
                 9 8 7 6 5 4 3 2 1 0                                      
__________________________________________________________________________
Control Commands                                                          
LOG    X X . . 1 0 1 0 1 X X X X X X                                      
ALOG   X X . . 1 0 1 0 0 X X X X X X                                      
FLP    X X . . 1 0 0 1 1 X X X X X X                                      
FML    X X . . 1 0 0 0 1 X X X X X X                                      
LML    X X . . 1 0 0 0 0 X X X X X X                                      
LML16  X X . . 1 1 1 0 1 X X X X X X                                      
PAG0   X X . . 0 1 0 1 1 X X X X X X                                      
PAG1   X X . . 1 1 0 1 1 X X X X X X                                      
AOK    X X . . 1 1 0 0 1 X X X X X X                                      
SOK    X X . . 1 1 0 1 0 X X X X X X                                      
ROK    X X . . 1 1 0 0 0 X X X X X X                                      
Data Port Output Commands                                                 
PT3    X X . . 1 0 1 1 1 X X X X X X                                      
PT4    X X . . 1 0 1 1 0 X X X X X X                                      
Memory Store Commands                                                     
STC m  0 0 . . 1 0 0 1 0 m5                                               
                           m4                                             
                             m3                                           
                               m2                                         
                                 m1                                       
                                   m0                                     
ST m   0 0 . . 1 1 1 0 0 m5                                               
                           m4                                             
                             m3                                           
                               m2                                         
                                 m1                                       
                                   m0                                     
STCB   0 0 . . 0 0 0 1 0 X X X X X X                                      
STBD   0 0 . . 0 1 1 0 0 X X X X X X                                      
__________________________________________________________________________
 &#34;.&#34; denotes bits defined in the referencing table                        
 &#34;X&#34; denotes don&#39;t care                                                   
 ##SPC1##