Abstract:
An operating circuit carrying out a conditional branch to judge a value level of a calculated result output from an arithmetic logic unit (ALU) during one machine cycle, using an address unit, realizes shorter processing time and low power consumption. The operating circuit sequentially carries out calculations according to command codes in a command ROM and includes a result register for storing and outputting the calculated result of the ALU; a value level judgement mechanism for judging a value level of an output of the result register; a latch for storing a current value of a program counter; an adder for calculating a next value of a program counter by adding a value level judgement result from the value level judgement mechanism and a current value of the program counter stored in the latch; and a first selector for selecting an added result and for deciding a next command address in the command ROM, a conditional branch being carried out to a command address corresponding to a value level obtained for the calculated result from the ALU.

Description:
BACKGROUND OF THE INVENTION 
     1. Field of Invention 
     The invention relates to an operating circuit (processor for signal processing) for an ADPCM (Adaptive Differential Pulse Code Modulation) apparatus, more specifically, to an operating circuit in an address unit portion which carries out address setting in a few clock cycles for reading out commands from a command ROM (Read Only Memory) where commands are stored. 
     2. Description of Prior Art 
     In digital communication, sound data etc. is compressed before transmission and compressed data is decompressed in a reception side to improve communication efficiency. An ADPCM system defined in G. 726 of the ITU recommendation is an example used to compress sound data. This invention relates to an operating circuit used for signal processing in an ADPCM system. This operating circuit includes hardware exclusively made for an address unit portion which carries out address settings for reading out commands from a command ROM where commands are stored. Being constructed as mentioned above, the operating circuit is able to carry out an operation for reading commands in a few clock cycles at a high-speed and low power consumption. 
     FIG. 12 shows an ordinary construction of an operating circuit used for an ADPCM apparatus. In FIG. 12, various kinds of command codes are stored in command ROM 28. When a value of program counter 16 which is output data from address unit 29 is inputted in command ROM 28 as address data, this command ROM 28 outputs command codes stored in the corresponding address of command ROM 28 to signal line 30. Command decoder 31 decodes the command codes read out from command ROM 28 and outputs them to signal line 11 to control address unit 29, register file 32 or ALU (Arithmetic Logical Unit) 33 according to types of command codes. 
     According to an output signal from command decoder 31, register file 32 comprises a plurality of registers (for example, X register, Y register, Z register) for storing a processed result on output signal line 3 of ALU 33. The register file 32 outputs two respective data signals to signal lines 34 and 35. ALU 33 has two inputted data signals 34 and 35 and carries out processing in accordance with decoded command codes on signal line 11 which are outputted from command decoder 31, and then outputs the results to signal line 3. Address unit 29 outputs a value of program counter based on both an output of ALU 33 outputted on signal line 3 and a value of command codes on signal line 11. 
     FIG. 13 shows an ordinary, conventional construction of address unit 29 shown in FIG. 12. FIG. 14 shows a format of conventional command codes. In FIG. 14, each command format of command codes which carry out a conditional branch or an immediate load is shown, respectively. 
     In FIG. 14, bits 23, 22 represent kinds of commands (type). When bits 23, 22 are &#34;00&#34;, they represent a conditional branch command, while they represent an immediate load command in case of &#34;01&#34;. When bits 23, 22 are &#34;00&#34;, in other words, at a conditional branch command, bits 21, 20 represent a conditional branch code (br --  code) such as &#34;call&#34;, &#34;jmp&#34;, and &#34;return&#34;, and bits 19-16 represent a condition (condition) such as &#34;zro&#34;, &#34;one&#34;, &#34;neg&#34;, &#34;pos&#34;, and &#34;uncondition&#34;. Bits 10-0 represent jump destination address (jmp address), when bits 19-16 are &#34;01&#34;, that is, at a conditional jump command or at an unconditional command. When bits 23, 22 are &#34;01&#34;, in other words at an immediate load command, bits 21-6 represent immediate data (imm-data) and bits 5-0 represent a destination address (dst) where immediate data is transferred. 
     In FIG. 13, result register 1 stores input data on signal line 3 inputted from ALU 33 in response to clock CLKB on signal line 2, and simultaneously outputs a stored value to signal line 4 for FLAG judgement. FLAG judgement circuit 20 carries out FLAG judgement according to kinds (types) of commands included in result data on signal line 4 and command codes on signal line 11, and a conditional branch code (br --  code) and a condition (condition), and then outputs a judgement result to signal line 22. For example, when a command kind (type) is &#34;00 (conditional branch)&#34; and a result of ALU matches the condition of the conditional branch, this circuit 20 outputs a command signal to signal line 22 so that selector 23 indicates jmp address to its output line 25, for carrying out a conditional branch indicated by conditional branch code (br --  code). 
     Latch 15 stores a current value of program counter (PC) in response to clock CLKB on signal line 2 and simultaneously outputs the stored value to signal line 17. Adder 18 adds data on signal line 10 and data on signal line 17 and outputs a result to signal line 19. Selector 23 outputs either data on signal line 19 or a jump destination address (jmp address) contained in a command code on signal line 11 to signal line 25, according to FLAG judgement result of an output of FLAG judgement circuit 20. Program counter 26 stores data on signal line 25 and simultaneously outputs a stored value to signal line 16 according to clock CLKC on signal line 27. 
     The following is a detailed explanation on an operation of address unit 29 shown in FIG. 12 with reference to FIG. 13. FIG. 6 shows timing relationship between machine cycle and clocks (CKLB and CKLC). When clock CLKB on signal line 2 became &#34;H&#34;, result registor 1 stores a processed result on signal line 3 which is outputted from ALU and simultaneously outputs the stored value to signal line 4. 
     FLAG judgement circuit 20 judges whether a condition represented by bits 19˜16 (condition) matches the result data on signal line 4, when conditional branch code (br --  code) in a conditional branch command shown in FIG. 14 is &#34;01&#34; in the command code on signal line 11, namely at a conditional jump command. Program counter 26 stores a current value of program counter and simultaneously outputs the stored value to signal line 16. Adder 18 adds an output from latch 15 which stores a value of program counter (PC) in every machine cycle, and a fixed value &#34;1&#34; to output the result to signal line 19. Selector 23 selects either the data on signal line 19, namely a value of program counter (PC) of machine cycle plus 1, or a jump destination address (jmp address) on signal line 11 according to the FLAG judgement result on signal line 22. A jump destination address (jmp address) is selected only when a result data on signal line 4 matches with a condition (condition). Otherwise, the data on signal line 19, i.e. value of program counter plus 1 is selected and outputted to signal line 25. 
     As shown in FIG. 6, when clock CLKB on signal line 2 becomes &#34;H&#34;, program counter 26, which stores program counter values, outputs a value stored according to clock CLKC on signal line 27, namely a revised value of program counter to signal line 16. 
     In a conventional circuit, three processes are needed for carrying out one numeric value judgement, namely, loading a threshold value, subtracting the threshold value from an inputted numerical value, and conditionally branching based on the result of subtraction. Since each process needs one machine cycle, three machine cycles are necessary for carrying out just one numeric value judgement. 
     FIG. 15 shows steps for judging which value level an inputted numerical value X falls in. FIG. 4 shows relationship between the inputted numerical value X (output of result register) and judgement result n. FIGS. 16A, B show command codes stored in command ROM 28. These command codes are properly referred to for carrying out various processes to judge a value level where an inputted numerical value falls in. In FIGS. 16A, B, the term &#34;address&#34; refers to an address of command ROM 28 which corresponds to a value of the program counter. Each capital X, Y, and Z represents a register, or more particularly X denotes a register to store an inputted numerical value, and Y and Z denote registers for calculations. A command code read out from command ROM 28 is outputted to signal line 11. 
     With reference to FIG. 15, a conventional process of value level judgement is explained briefly as follows. First, it is judged whether an inputted numerical value X is equal to or more than 128 (X≧128). If X is equal to or more than 128, it is judged whether X is equal to or more than 2048 (X≧2048). If X is equal to or more than 2048, it is farther judged whether X is equal to or more than 8192 (X≧8192). If X is equal to or more than 8192, it is further judged whether X is equal to or more than 16384 (X≧16384). If X is equal to or more than 16384, it is finally judged that X belongs to a value level where X is equal to or more than 16384. In this manner, the above processes are repeated many times depending on how large X is, and then the final value level is decided. 
     For example, in case that numerical value X is 2048, a plurality of steps are carried out as explained below to judge which value level an inputted numerical value X falls in. This process is carried out by sequential execution of command codes in command ROM 28 which correspond to addresses outputted from address unit 29. 
     Address: command code 
     0000000H: substituting 128 for Y 
     0000001H: calculating 2048-128 and then substituting the result 1920 for Z 
     0000010H: jumping to 0101000H, since Z≧0 
     0101000H: substituting 2048 for Y 
     0101001H: calculating 2048-2048 and then substituting the result 0 for Z 
     0101010H: jumping to 0111100H, since Z≧0 
     0111100H: substituting 8192 for Y 
     0111101H: calculating 2048-8192 and then substituting the result -6146 for Z 
     0111110H: no jumping since Z is less than zero 
     0111111H: substituting 4096 for Y 
     1000000H: calculating 2048-4096 and then substituting -2048 for Z 
     1000001H: no jumping since Z is less than zero 
     100001H: executing the processing for case of 4095≧X≧2048 
     0000011H: unconditional jumping to next command address 1001100H 
     In case of conventional value level judgement which uses command codes shown in FIGS. 16A, B, regardless of an inputted numerical value X, twelve machine cycles in total are necessary, that is, 4 calculations for loading a threshold value, 4 calculations for subtracting a threshold value from an inputted numerical value, and 4 conditional branch determinations by judgement of the subtraction result. Furthermore, a process after a conditional branch and a jumping step to the next command each requires one machine cycle, respectively, and therefore the total of necessary machine cycles becomes 14. 
     Referring to FIGS. 12 and 13, an operation, where the input numerical value is 2048, is explained where different processing is carried out, respectively, in accordance with value levels decided as a result of the value level judgement process according to FIG. 16. A, B. It is assumed that the inputted numerical value 2048 has been pre-loaded in the X register of register file 32. 
     At the first machine cycle, an immediate value command code &#34;substitute 128 for Y&#34;, which is stored in start address &#34;0000000&#34; of command ROM 28 is outputted to signal line 30. Command decoder 31 decodes the command code and outputs it to signal line 11. A threshold value level 128 stored in bits 21˜6 in the immediate value command code on signal line 11 is downloaded to the Y register of register file 32, which is represented by bits 5˜0. Register file 32 outputs the inputted numerical value X (=2048) to signal line 34 and the threshold value Y (=128) to another signal line 35. 
     At a second machine cycle, address unit 29 outputs a value of program counter incremented by one, namely &#34;0000001&#34; to command ROM 28. Command ROM 28 recognizes this value as address and executes the command code for subtraction shown in FIG. 16A to calculate 2048-128. Command ROM 28 then outputs subtraction result 1920 to signal line 11. While this same subtraction result 1920 is substituted for Z register in register file 32. 
     At a third machine cycle, since Z is more than zero, a pointer jumps to address &#34;0101000H&#34; in address unit 29 as shown in FIG. 16B. At a fourth machine cycle, the command code &#34;substituting 2048 for Y&#34; stored in address &#34;0101001H&#34; of command ROM 28 is executed. At fifth machine cycle, the command code &#34;substituting X-Y for Z&#34; stored in &#34;0101001H&#34; of command ROM 28 is executed, where 2048-2048 is calculated and its result &#34;0&#34; is substituted for Z. At a sixth machine cycle, the command code in address &#34;0101010H&#34; of command ROM 28 is executed. In this case, since Z is more than zero, the pointer to jump to address &#34;0111100H&#34; in address unit 29. 
     At seventh machine cycle, by the command code in address &#34;0111100H&#34; of command ROM 28, 8192 is substituted for Y. At eighth machine cycle, by the command code in address &#34;011101H&#34; of command ROM 28, 2048-8192 is calculated and the subtraction result (-6144) is substituted for Z. At a ninth machine cycle, the command code in address &#34;0111110H&#34; of command ROM 28 is executed, where, since Z is less than zero, the pointer stops further jumping and moves to a command code in the next address &#34;0111111H&#34;. 
     At tenth machine cycle, by the command code in address &#34;0111111H&#34; of command ROM 28, 4096 is substituted for Y. At eleventh machine cycle, by the command code of address &#34;1000000H&#34; of command ROM 28, 2048-4096 is calculated and the result (-2048) is substituted for Z. At twelfth machine cycle, the command code in address &#34;1000001H&#34; of command ROM 28 is executed, and since Z is less than zero, the pointer stops jumping and moves to a command code in the next address &#34;1000010H&#34;. 
     At a thirteenth machine cycle, by the command code in address &#34;1000010H&#34; of command ROM 28, a value level of X is determined as 4095≧X≧2048. At fourteenth machine cycle, by the command code of address &#34;100011H&#34; of command ROM 28, unconditional jump to the next command address &#34;1001100H&#34; is executed. 
     As explained above, it is concluded that in this conventional value level judgement, a value level corresponding to an inputted numerical value is determined at the fourteenth machine cycle. 
     FIG. 17 shows a plurality of processing steps to detect which value judgement value shown in FIG. 9 an inputted numerical value falls in. The corresponding command codes are shown in FIGS. 18A, B. 
     In FIG. 17, conventional processing of value judgement is briefly explained as follows. First of all, it is judged whether an inputted numerical value X is equal to or more than 8. In case of X≧8, it is further judged whether X is equal to or more than 12. In case of X≧12, it is further judged whether X is equal to or more than 14. In case of X≧14, it is further judged whether X is equal to or more than 15. In case of X≧15, X is finally decided that X has avalue of &#34;15&#34;, that is (X=15). In such a manner, the above processes are repeated many times depending on how large X is, and then the final value level is decided. 
     If an inputted numerical value mentioned above is 10, a value judgement is carried out according to FIGS. 18A, B. Command codes of this case is executed by the next sequence. 
     Address: command code 
     0000000H: substituting 8 for Y 
     0000001H: substituting X-Y for Z 
     0101010H: jumping to 0101000H if Z≧0 
     0101000H: substituting 12 for Y 
     0101001H: substituting X-Y for Z 
     0101010H :jumping to 0111100H if Z≧0 
     0101011H: substituting 10 for Y 
     0101100H: substituting X-Y for Z 
     0101101H: jumping to 0110101H if Z≧0 
     0110101H: substituting 11 for Y 
     0110110H: substituting X-Y for Z 
     0110111H: jumping to 0111010H if Z≧0 
     0111000H: processing in case of X=10 
     0111001H: unconditional jumping to 1001100H 
     Referring to circuits shown in FIG. 12 and 13, an operation when an inputted numerical value is 10 is explained concretely as follows. It is assumed that an inputted numerical value 10 has been pre-loaded in X register in register file 32. 
     At a first machine cycle, an immediate value command code &#34;substitute 8 for Y&#34;, which is stored in start address &#34;0000000&#34; of command ROM 28 is outputted to signal line 30. Command decoder 31 decodes command code to output to signal line 11. A threshold value 8 stored in bits 21˜6 of the immediate value command code on signal line 11 is downloaded to Y register of register file 32, which is represented by bits 5˜0. 
     At a second machine cycle, address unit 29 outputs a value of program counter incremented just one, namely &#34;0000001&#34; to command ROM 28. Command ROM 28 recognizes this value as address and outputs a command code for subtraction shown in FIG. 18A to command decoder 31. Command decoder 31 decodes the command code to output to signal line 11. By the command code on signal line 11, the command code &#34;substituting X-Y for Z&#34; in address &#34;0000001H&#34; of command ROM 28 is executed in ALU 33, where the result &#34;10-8=2&#34; is stored in the Z register. 
     At a third machine cycle, the command code &#34;jump to 0101000H if Z is equal to or more than zero&#34; in address 0101010H of command ROM 28 is executed. In this case, since Z=2, this condition is satisfied to cause jump to address &#34;0101010H&#34;. At a fourth machine cycle, the command code &#34;substituting 12 for Y&#34; in address 0101000H of command ROM 28 is executed and the result &#34;12&#34; is stored in the Y register. At a fifth machine cycle, the command code &#34;substitute X-Y for Z&#34; in address 0101001H of command ROM 28 is executed and the subtraction result Z=10-12=-2 is stored in the Z register. At a sixth machine cycle, the command code &#34;jumping to 0111100H if Z is equal to or more than zero&#34; in address 0101010H of command ROM 28 is executed. In this case the condition is not satisfied since Z=-2. Accordingly the process moves to the next address &#34;0101011H&#34;. 
     At a seventh machine cycle, the command code &#34;substitute 10 for Y&#34; in address 01010111H of command ROM 28 is executed to put 10 in the Y register. At an eighth machine cycle, the command code &#34;substitute X-Y for Z&#34; in address &#34;0101100H&#34; of command ROM 28 is executed to store Z=10-10=0 in the Z register. At a ninth machine cycle, the command code &#34;jump to address 0110101H if Z is equal to or more than zero&#34; in address &#34;0011101H&#34; of command ROM 28 is executed. In this case the condition is satisfied since Z=0, address &#34;0110101H&#34; of command ROM 28 is transferred to command ROM 28. 
     At a tenth machine cycle, the command code &#34;substitute 11 for Y&#34; in address &#34;0110101H&#34; of command ROM 28 is executed to store 11 in the Y register. At an eleventh machine cycle, the command code &#34;substitute X-Y for Z&#34; in address &#34;0110110H&#34; of command ROM 28 is executed to store Z=10-11=-1 in the Z register. At a twelfth machine cycle, the command code &#34;jumping to &#34;0111010H&#34; if Z is equal to or more than zero&#34; in address 0110111H of command ROM 28, is executed. In this case since Z=-1 does not satisfy the condition, the pointer moves to the next address &#34;0111000H&#34;. 
     At a thirteenth machine cycle, the command code &#34;processing in case of X=10&#34; in address &#34;0111000H&#34; of command ROM 28, and a value is finally decided at this stage. At a fourteenth machine cycle, the command code &#34;unconditional jumping to 1001100H&#34; in address 0111001H of command ROM 28 is executed, where a whole process comes to an end. As described above, it is concluded that in this conventional value judgement circuit, 14 machine cycles are necessary to determine a value of an inputted numerical value. 
     In a conventional technology, judgement of value level or value are decided by subtracting a threshold value from an inputted numerical value. Therefore, many subtraction and judgement steps are necessary which consume excessive amounts of processing time. Still another problem has been caused in that many processing cycles increase power consumption. The ADPCM system defined by ITU recommendation G. 726 requires many processing steps for value level judgement or value judgement. 
     Therefore, it is an object of the present invention to provide an operating circuit for carrying out the processing in fewer steps at a high-speed and with low power consumption. 
     SUMMARY OF THE INVENTION 
     According to one aspect of the invention, an operating circuit comprising a command ROM (read only memory) for storing a content of a program, a program counter for appointing an address to said command ROM, a command decoder for decoding a content of said command ROM appointed by said program counter, an arithmetic logical unit (ALU) for calculating contents of a register file according to a decoded result from said command decoder, and an address unit for calculating a next address value in said command ROM according to the calculated results from ALU, the operating circuit sequentially carries out calculations according to the command codes in a command ROM, comprises a result register for storing and outputting an outputted result of ALU; a value level judgement means for judging which value level an output of said result register is included in; a latch means for storing a current value of program counter; an adder means for calculating a next value of program counter by adding a value level judgement result from said value level judgement means and a current value of program counter stored in said latch means; and a first selector means for selecting an added result and for deciding a next command address in said command ROM, where, conditional branch is carried out to a command address which is corresponding to a value level obtained by the calculated result from ALU. 
     According to another aspect of the invention, an operating circuit comprising a command ROM (read only memory) for storing a content of a program, a program counter for appointing an address to said command ROM, a command decoder for decoding a content of said command ROM appointed by said program counter, an arithmetic logical unit (ALU) for calculating contents of a register file according to a decoded result from said command decoder, and an address unit for calculating a next address value in said command ROM according to the calculated results from ALU, the operating circuit sequentially carries out calculations according to the command codes in a command ROM, comprises a result register for storing and outputting an outputted result of ALU; a value judgement means for incrementing an output of said result register by one; a latch means for storing a current value of program counter; an adder means for calculating a next value of program counter by adding a value judgement result from said value judgement means and a current value of program counter stored in said latch means; and a first selector means for selecting an added result and for deciding a next command address in said command ROM, where, conditional branch is carried out to a command address which is corresponding to a value obtained by the calculated result from ALU. 
     According to still another aspect of the invention, an operating circuit further comprises a FLAG judgement circuit for decoding kinds of commands (types) from a command decoder, a conditional branch code (br --  code) and a condition (condition), depending on an output from said result register, and for outputting a result to said first selector. 
     According to still another aspect of the invention, an operating circuit further comprises a second selector for selecting a fixed value &#34;1&#34;, an output from the decoder, or a value of an address displacement (disp) in the command decoder, according to kinds of commands (types) contained in the output from the command decoder, a conditional branch code (br --  code) and a condition (condition). 
     According to still another aspect of the invention, an operating circuit further comprises a means for appointing a displacement from the current program count value to next program count value and then for allowing program counter value to displace by a displacement value at the same time when the calculation is carried out, in addition to normal operating commands, as a command codes at a destination address where conditional branch is carried out according to value level judgement or value judgement, and where, the operating circuit carries out a branching process after ALU has carried out value level judgement or value judgement. 
     According to further aspect of the invention, an operating method for sequentially carrying out calculations according to the command codes in a command ROM, using operating circuit which comprises a command ROM (read only memory) for storing a content of a program, a program counter for appointing an address to said command ROM, a command decoder for decoding a content of said command ROM appointed by said program counter, an arithmetic logical unit (ALU) for calculating contents of a register file according to a decoded result from said command decoder, and an address unit for calculating a next address value in said command ROM according to the calculated results from ALU, comprises the steps of: storing and outputting an outputted result of ALU; judging which value level said output is included in; storing a current value of program counter; calculating a next value of program counter by adding a value level judgement result and a current value of program counter; and selecting an added result and for deciding a next command address in said command ROM, where, conditional branch is carried out to a command address which is corresponding to a obtained by the calculated result from ALU. 
     According to still further aspect of the invention, an operating method for sequentially carrying out calculations according to the command codes in a command ROM, using operating circuit which comprises a command ROM (read only memory) for storing a content of a program, a program counter for appointing an address to said command ROM, a command decoder for decoding a content of said command ROM appointed by said program counter, an arithmetic logical unit (ALU) for calculating contents of a register file according to a decoded result from said command decoder, and an address unit for calculating a next address value in said command ROM according to the calculated results from ALU, comprises the steps of: storing and outputting an outputted result of ALU; incrementing an output of said result register by one; storing a current value of program counter; calculating a next value of program counter by adding said incremented result and said current value of program counter; and selecting an added result and for deciding a next command address in said command ROM, where, conditional branch is carried out to a command address which is corresponding to a value obtained from the calculated result from ALU. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 shows a construction of an address unit of a first embodiment of the present invention. 
     FIG. 2 shows a construction of an address unit of a second embodiment of present invention. 
     FIG. 3 shows a format of command code used in the embodiments of the present invention. 
     FIG. 4 shows a judgement range in case of value level judgement. 
     FIG. 5 shows value level judgement circuit used in an embodiment of the present invention. 
     FIG. 6 shows a machine cycle and a clock timing. 
     FIG. 7 shows a correspondence between value level judgement range of the first embodiment of the present invention and a result of value level judgement. 
     FIG. 8 shows briefly an operation of the first embodiment of the present invention. 
     FIG. 9 shows a correspondence between a value judgement value of the second embodiment of the present invention and a result of value judgement. 
     FIG. 10 shows briefly an operation of the embodiments of the present invention. 
     FIG. 11 shows briefly an operation of the embodiments of the present invention. 
     FIG. 12 shows a brief operation of a main portion of ADPCM apparatus where the present invention is used. 
     FIG. 13 shows a construction of a conventional address unit. 
     FIG. 14 shows a conventional command format. 
     FIG. 15 shows steps of a conventional value level judgement. 
     FIG. 16A shows steps for carrying out a conventional value level judgement stored in command ROM 28 (part 1). 
     FIG. 16B shows steps for carrying out a conventional value level judgement stored in command ROM 28 (part 2). 
     FIG. 17 shows steps of a conventional value level judgement. 
     FIG. 18A shows steps for carrying out a conventional value judgement stored in command ROM 28 (part 1). 
     FIG. 18B shows steps for carrying out a conventional value judgement stored in command ROM 28 (part 2). 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     Embodiment 1 
     FIG. 1 is a block diagram of a circuit which carries out value level judgement of an embodiment of the present invention. This block diagram shows an address unit 29 in FIG. 12 of the present invention. The system configuration of the present invention is the same as that depicted in FIG. 12. The present invention includes a specific feature in the hardware construction of address unit 29 which carries out conditional branch operations in fewer machine cycles than the prior art systems. 
     First, the conditional branch operation according to value level judgement is explained. Aformat of command codes on signal line 11 of FIG. 1 and FIG. 12 is explained with reference to FIG. 3. In FIG. 3, bits 28 and 27 designate different kinds of commands. When bits 28 and 27 are &#34;00&#34;, they indicate a conditional branch command, while they indicate an immediate load command in case of &#34;01&#34;. Bits 26 and 25 represent conditional branch codes (br --  code). Value &#34;00&#34; corresponds to &#34;call&#34;, &#34;01&#34; to &#34;jimp&#34;, &#34;10&#34; to &#34;return&#34;, and &#34;11&#34; to &#34;sw&#34; which means &#34;switch&#34;. Bits 24˜21 represent conditions. Value &#34;0000&#34; corresponds to &#34;zro&#34;, &#34;0001&#34; to &#34;one&#34;, &#34;0010&#34; to &#34;neg&#34;, &#34;0011&#34; to &#34;pos&#34;, &#34;0100&#34; to &#34;mag&#34;, &#34;0101&#34; to &#34;result&#34;, and &#34;0110&#34; to &#34;uncondition&#34;. Bits 10˜0 represent jump destination addresses (jmp address) when a jump command is executed. Bits 20˜11 may have an arbitrary value. 
     For example, when bits 28, 27 (type) are &#34;00&#34; and bits 26, 25 (conditional branch code (br code)) are &#34;11&#34; (sw), and bits 24˜21 are &#34;0100&#34;, it represents conditional branch &#34;mag&#34; by a value level judgement. When bits 28, 27 are &#34;00&#34;, bits 26, 25 are &#34;11&#34;, and bits 24˜21 are &#34;0101&#34;, it represents conditional branch by value level judgement, namely `result`. In case of conditional branch by value level judgement, namely &#34;SW command&#34;, the next address is decided by &#34;present address&#34;+&#34;condition&#34;. Accordingly, it is not necessary to appoint an absolute address of a jump destination. Therefore, a jump destination address for bits 10˜0 may be any arbitrary values. 
     In FIG. 1, a result register 1 stores a processed result received from ALU 33 according to a clock CLKB on signal line 2, and then outputs a stored value to signal line 4 for FLAG judgement. This register 1 also outputs only an immediate value to signal line 5, among values stored for value level judgement. Value level judgement circuit 7 judges where an input data value X is included among value level judgement ranges shown in FIG. 4, and outputs a judgement result to decoder 40. Decoder 40 in FIG. 5 outputs judgement result to selector 9 via signal line 8. Selector 9 selects either one of an input data 8 (value level judgement result), a fixed value &#34;1&#34; on signal line 10 for incrementing a value of program counter by &#34;1&#34;, or an address displacement (disp) on signal line 12, according to kinds of commands (type), conditional branch code (br --  code), and conditions (condition) on signal line 11, and then outputs a result to signal line 14. Adder 18 adds a program counter PC which is an output from latch 15, and an output result from selector 9. Explanations for numerals 15˜27 is omitted here since it is the same as that of in FIG. 13. One example of this value level judgement circuit is shown in FIG. 5. 
     With reference to FIG. 1, an operation is explained as to how conditional branch according to value level judgement is carried out effectively and in a high-speed. In FIG. 3, we assume that the command codes on signal line 11 comprises bits 28, 27 (type), bits 26, 25 (br --  code) and bits 24˜21 (condition) in a conditional branch command according to value level judgement, and those bits are &#34;00 (conditional branch)&#34;, &#34;11 (sw)&#34;, &#34;0100 (mag)&#34;, respectively. 
     As shown in FIG. 6, when clock CLKB on signal line 2 became &#34;H&#34;, result register 1 stores a processing result X of ALU 33 in FIG. 12, and then outputs only a calculated result (except an overflow flag from ALU 33 and carrier flag etc.) among values stored to signal line 5 for value level judgement. A value level judgement circuit 7 outputs a value level judgement result to decoder 40 in response to input data (X) on signal line 5 in a manner shown in FIG. 7. This decoder 40 outputs a decoded result to signal line 8. Selector 9 selects input data on signal line 8 which is a result of value level judgement, and outputs it to signal line 14, only when bits 28, 27 are &#34;00&#34;, bits 26, 25 are &#34;11&#34;, and bits 24˜21 are &#34;0100&#34; in a command code on signal line 11, namely when the conditional branch command is executed according to value level judgement. 
     On the other hand, latch 15 stores a current value of program counter on signal line 16, and the outputs stored value to signal line 17. Adder 18 adds an output from latch 15 (value of program counter) and a value level judgement result on signal line 14 for every machine cycle, and outputs the result to signal line 19. Selector 23 selects a data on signal line 19 and a command code (jmp address) on signal line 11 to output it to signal line 25. In other words, selector 23 outputs a &#34;value of program counter&#34;+&#34;a value level judgement result&#34; to signal line 25. 
     The operation when clock CLKB on signal line 2 in FIG. 6 became &#34;L&#34; is similar to that of prior art. That is, program counter 26, which stores program counter value, outputs the stored value in response to clock CLKC on signal line 27, namely an updated value of program counter, to signal line 16. 
     As described above, in this embodiment, value level judgement circuit 7 carries out value level judgement for inputted numerical values, and adds a value of program counter and a value level judgement result as shown in FIG. 8, executes conditional branch in command ROM 28 according to a counting value of the added result. This process is explained in detail below. First, since a program counter PC is at a position of X=X, an output from ALU 33 becomes X. Next, program counter PC is incremented by one for a usual calculation process of the ALU to point SW (mag). In this occasion, since the SW command is carried out by using the preceding ALU calculation result, if a value level judgement result of X is n, the next program counter PC value becomes the current &#34;PC value&#34;+&#34;n&#34;. FIG. 8 shows an operation in case of n=7, and a program counter moves to processing 7. 
     Accordingly, this embodiment advantageously carries out conditional branch using value level judgement within one machine cycle, without three processing necessary for prior art, namely loading threshold value, subtracting threshold value from inputted numerical values, and conditionally branching according to judgement of subtraction result. Here, a command &#34;X=X&#34; means that ALU command is outputted by through-state, that is, ALU reads out X from the register file, and outputs X as it is, and the register file again holds X. In other words, a result of X register becomes X again. Command &#34;SW (mag)&#34; is a conditional branch command, which changes the current program counting value of program counter by &#34;preceding calculated result of ALU&#34;+&#34;1&#34;. 
     Embodiment 2 
     FIG. 2 is a block diagram showing another embodiment of a conditional branch operation according to a value judgement of the invention. A format of command codes on signal line 11 of FIG. 2 and FIG. 12 is similar to that of the first embodiment as shown in FIG. 3. 
     With reference to FIG. 2, an operation is explained as to how conditional branching according to value judgement is carried out effectively and at a high-speed. In this case, we assume that bits 28, 27 (type) is 00&#34; (conditional branch), bits 26, 25 (br --  code) is 11 (SW)&#34;, and bits 24-21 are 0101 (result)&#34;. Since a jump destination address is unnecessary for a conditional branch command according to value judgement, jump destination address of bits 10˜0 may be any arbitrary values. 
     As shown in FIG. 6, when clock CLKB on signal line 2 became &#34;H&#34;, result register 1 stores a processing result (X) of ALU 33 in FIG. 12, and then outputs only lower 4 bits of an immediate value among stored value to signal line 6 for value judgement. A value judgement circuit 36 adds &#34;1&#34; to an input data on signal line 6 and outputs a result as value judgement result to signal line 37. As shown in FIG. 9, a value judgement result becomes &#34;lower 4 bits of input data of the immediate value on signal line 6&#34;+&#34;1&#34;. Selector 9 selects a value judgement result 37 and outputs it to signal line 14, only when bits 28, 27 of a command code on signal line 11 are &#34;00&#34;, bits 26, 25 are &#34;11&#34; and bits 24-21 are &#34;0101&#34;, namely only when the conditional branch command is executed according to value judgement. 
     Latch 15 stores a current value of program counter on signal line 16, then outputs a stored value to signal line 17. Adder 18 adds an output on signal line 17 from latch 15 (value of program counter) and a value level judgement result on signal line 14 from selector 19 in every machine cycle, and outputs a result to signal line 19. Selector 23 selects a data on signal line 19 to output to signal line 25. In other words, selector 23 outputs &#34;value of program counter&#34;+&#34;value level judgement result&#34; to signal line 25. 
     The operation when clock CLKB on signal line 2 in FIG. 6 became &#34;L&#34; is similar to that of prior art. That is, program counter 26, which stores program counter values, outputs the stored value, namely an updated value of program counter, to signal line 16, in response to clock CLKC on signal line 27. 
     In other words, as shown in FIG. 10, this embodiment carries out the conditional branch operation according to a value judgement by simply adding the value judgement result to a value of program counter. 
     For example, a program counter PC is at the position of X=X, an output of ALU 33 becomes X. Next, program counter PC is incremented by one for a usual calculation of ALU to indicate SW (mag). Since SW command is executed using preceding ALU calculation result, if a value level judgement result of X is n, then the next program counter PC value becomes &#34;current PC value&#34;+&#34;n&#34;. FIG. 10 shows a calculation process in case of n=7, and a program counter moves to process 7. Accordingly, this embodiment can carry out conditional branch by value judgement in one machine cycle. 
     Embodiment 3 
     FIG. 11 is a block diagram which carries out an immediate loading according to an embodiment of the present invention. In FIG. 11, the process to move to PC+n is the same as that explained in FIG. 10. The difference is that contents of PC+n is immediate load commands in case of FIG. 11. Immediate load command executes an immediate value, and then appoints a displacement. Here, a command &#34;X=X&#34; means that ALU command is outputted by thorough-state, that is, ALU reads out X from the register file, and outputs X as it is, and the register file again holds X. In other words, a result of X register becomes X again. Command &#34;SW (result)&#34; is a conditional branch command, which deviates the current value of program counter by &#34;preceding calculated result of ALU&#34;+&#34;1&#34;. 
     In FIG. 11, since displacement (disp) is 10, the next value of program counter becomes equal to &#34;current value of program counter&#34;+&#34;10&#34;. Even if n is a number other than 10, a sequential processes of immediate load and branching is executed by 2 steps, by appointing displacement values (disp) in advance into a ROM address and by executing the command on the address &#34;PC+n&#34;. 
     A format of command codes on signal line 11 of FIG. 1 and FIG. 12 is explained in case when immediate load is executed using FIG. 3. Bits 28, 27 in FIG. 3 represents kinds (types) of commands and when bits 28, 27 are &#34;01&#34;, they represent an immediate load command. When bits 28, 27 are &#34;01&#34;, that is, in case of immediate load command, bits 26˜11 represent immediate data (imm-data), while bits 10˜6 represent both an immediate load and an address displacement (disp) for address displacement, and bits 5˜0 represent a data transfer destination address (dst). 
     With reference to FIG. 1, and other figures, it is explained below how immediate load and unconditional jump after conditional branch according to value level judgement or value judgement is carried out efficiently and at a high-speed. 
     As shown in FIG. 6, when clock CLKB on signal line 2 became &#34;H&#34;, selector 9 selects an address displacement (disp) data for bits 10˜6 in a command code on signal line 11 from signal line 12, and outputs it to signal line 14 when bits 28, 27 of command code on signal line 11 is &#34;01&#34;, namely only for an immediate load command. Latch 15 stores a current value of program counter and then outputs a stored value to signal line 17. Adder 18 adds an address displacement (disp) and a program counter output on signal line 17 from latch 15 where a value of program counter is stored for every machine cycle, and outputs a result to signal line 19. Selector 23 selects a data on signal line 19 and outputs it to signal line 25. Accordingly, in this case, selector 23 outputs &#34;value of program counter&#34;+&#34;value of an address displacement&#34; to signal line 25. 
     The operation when clock CLKB on signal line 2 in FIG. 6 became &#34;L&#34; is similar to that of that previously discussed prior art. That is, program counter 26, which stores program counter values, outputs the stored value in response to clock CLKC on signal line 27, namely an updated value of program counter, to signal line 16. 
     In other words, in this embodiment, a value of the program counter is updated by adding an address displacement value to the value of program counter, when an immediate load is outputted. Therefore, this embodiment can execute the processing in one machine cycle, while the conventional processing has been executed in 2 machine cycles. By combining this third embodiment with the first or second embodiment, the conventional processing executed in 14 machine cycles can be abandoned in favor of the processing described in the above embodiments executed in 2 machine cycles.