JP2909185B2 - Assembler processing method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION [Summary] Regarding an assembler processing method in an information processing apparatus, an assembler processing that allows mixed use of signed and unsigned constants in a source program without significantly increasing the processing load of the assembler In order to provide a method, as a description format of constants, a source program written using an assembler language that expresses a numerical value with a sign symbol and a numerical value without a sign symbol by using predetermined specific characters As an object, at the time of assembler processing of the source program, it is determined whether or not the description format of the constant in the source program includes a numerical expression accompanied by a sign, and an instruction using the constant is converted to a machine that handles a signed numerical value. It is configured to convert to a language instruction and a machine language instruction that handles unsigned numeric values.

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an assembler processing method in an information processing apparatus, and more particularly to an assembler processing method in which both signed and unsigned constant expressions can be mixedly used in a source program.

[Conventional technology]

In a conventional assembler language program, when describing a constant, the absolute value expression without a sign is used. The upper one bit is a sign bit, and the negative number is represented by a two's complement. The way was being taken. When translating an instruction in a source program, the assembler interprets the constants used by the instruction as being in one of the predetermined description formats, and puts them into a specific machine language instruction that handles the description format of the constant. Had been converted. This is because if both description formats are allowed in the source program, the management of the signature of each constant becomes complicated in long arithmetic expressions and the like, and the separation of machine language instructions becomes troublesome.

[Problems to be solved by the invention]

In conventional assemblers, in order to reduce the burden of assembler processing, the description format of constants is defined to operate either as an absolute value expression without a sign or with a sign bit expressing a negative number as a 2's complement number. And did not allow both constant expressions to be mixed in the source program. Therefore, there is a problem that free programming is hindered and the program becomes redundant.

SUMMARY OF THE INVENTION It is an object of the present invention to provide an assembler processing method that allows mixed use of signed and unsigned constants in a source program without significantly increasing the processing load of the assembler.

[Means for solving the problem]

According to the present invention, as a description format of a constant, a sign symbol using a specific character can be added to the head of a numerical expression without a sign, and a signed numerical value is determined by whether or not the sign symbol is added to the numerical value. The assembler discriminates between an unsigned numerical value and an unsigned numerical value, and separates the instruction into an instruction for performing signed processing and an instruction for performing unsigned processing, and converts the instruction into a machine language instruction.

FIG. 1 is a diagram illustrating the principle of the present invention. In the illustrated example, 'S' is used as a sign symbol added to the numerical value of the constant.

In the figure, 1 is a source program, and the instruction MOVE1 AX, AREA1 / SX'FFFE 'in the program is a constant obtained by dividing the value of the area of label AREA1 by a signed numeric value (hexadecimal) SX'FFFE' Is an instruction for performing a process of storing in the area of the label AX.

The next instruction MOVE1 AX, AREA1 / X'FFFE 'is an unsigned numerical value X'FFF
This instruction stores the result of dividing the value of AREA1 by E 'in AX.

Reference numeral 2 denotes an assembler process which sequentially reads and analyzes a character string of each instruction of the source program 1 and translates it into a machine language program. At this time, if a constant is detected, it is determined whether or not a sign symbol S is added at the beginning, and a machine language instruction to be used is selected based on the result.

[Action]

The operation of the present invention will be described with reference to FIG.

In assembler processing 2, the sign symbol 'S' is used in the first instruction MOVE1 AX, AREA1 / SX'FFFE 'in the source program 1.
When a numerical value SX'FFFE 'with a prefix is detected, it is recognized as a negative number' -2 'in a two's complement expression, and a process of dividing the value of AREA1 (assumed to be 100) by' -2 'is performed. Value -50 (X'FFC
E '). Then, the value “−50” is converted into a machine language instruction to be stored in AX.

Further, in assembler processing 2, the sign MOVE1 AX, AREA1 / X'FFFE 'in the source program 1 uses the sign symbol' S '.
When a numerical value X'FFFE 'having no sign is detected, it is recognized as an unsigned numerical value' 65534 ', and the value of AREA1 (1
00) is divided, and the resulting value is 0 (X'0000 ')
Get. Then, the value “0” is converted into a machine language instruction to be stored in AX.

In this way, the assembler 2 executes the source program 1
Is distinguished between signed and unsigned numbers depending on whether or not the value of the constant described in this instruction has the sign symbol 'S', and is converted into a machine language instruction that handles each type of numerical value.

In the example shown in the figure, the assembler 1 itself also performs constant operations of AREA1 / SX'FFFE 'and AREA1 / X'FFFE', and executes division to obtain the values '50' and '0', respectively. The type of division instruction at that time is also selected according to the presence or absence of the sign symbol 'S'.

〔Example〕

FIG. 2 shows an embodiment of the assembler. In the figure, 1 is a source program, 2 is assembler processing, 3 is pass 1 processing, 4 is pass 2 processing, 5 is a pseudo-instruction table, 6 is a machine language instruction table, 7 is a location counter, 8 is a symbol table, and 9 is a symbol table. Literal table 10 is a machine language program.

The basic functions of the assembler process 2 are the same as those conventionally known. In the pass 1 process 3, the lines of the source program 1 are sequentially read, and the pseudo instruction table 5 and the machine instruction table 6 are read.
To detect pseudo-instructions and machine instructions in the program. For pseudo-instructions, control of assembler processing and processing for setting the execution environment, such as base registers, are performed. For machine instructions, the location counter 7 is advanced based on the instruction size obtained from the machine instruction table to advance the machine instructions. Determine position (pseudo-instruction positions are not counted). Also, the position of the label attached to the instruction is set in the symbol table 8, and if the instruction includes a literal requesting the reservation of a constant area, the processing is performed, and the literal and its position are set in the literal table 9.

Subsequently, pass 2 processing 4 is executed, and the source program 1 is again executed.
Are sequentially read, and the machine language instructions are sequentially generated while updating the location counter 7 with reference to the symbol table 8 and the literal table 9.

The present invention is applied in the generation processing of the machine language instruction. That is, the corresponding machine language code and instruction format are known by referring to the machine language instruction table 6 based on the input symbol code of the source program instruction, and each field of the operand is determined. When referring to the machine language instruction table 6, the function of the machine language instruction is selected depending on whether the instruction uses a constant with a sign.

〔The invention's effect〕

According to the present invention, a user can simply use a simple specification of whether or not to add a sign symbol to a constant description in an assembler language program, and can easily use a mixture of signed and unsigned values. Also, during assembler processing, the assembler can easily recognize the description format of constants by detecting the presence or absence of a sign symbol in constants, and can separate the corresponding assembler processing, thereby improving the efficiency of programming and assembler processing. And speeding up.

[Brief description of the drawings]

FIG. 1 is an explanatory diagram of the principle of the present invention, and FIG. 2 is an explanatory diagram of assembler processing according to an embodiment of the present invention. In Fig. 1, 1: Source program 2: Assembler processing

──────────────────────────────────────────────────続 き Continued on front page (58) Field surveyed (Int.Cl. ⁶ , DB name) G06F 9/45

Claims (1)

(57) [Claims] 1. An assembler processing method for translating a source program described in an assembler language into a machine language program, wherein a constant description format includes a numerical value with a sign symbol and a numerical value without a sign symbol in a predetermined specific character. For a source program described using an assembler language expressed by using, when assembling the source program, it is determined whether or not there is a numerical expression with a sign in the description format of the constants in the source program. An assembler processing method comprising: judging and converting an instruction using the constant into one corresponding to one of a machine language instruction handling a signed numeric value and a machine language instruction handling an unsigned numeric value.