JPH0414144A - Compilation processing method - Google Patents

Abstract

PURPOSE:To improve the developing efficiency of a compiler by using a 2-step skelton to separate an architecture reliance part from the procedure of a meaning analysis processing of the compiler and transforming the architecture reliance part into a table. CONSTITUTION:The meaning analysis/optimization processing is carried out with the input of a source program 11 and a general-purpose intermediate language 15 is generated. Then an intermediate language 16 reliant on the computer architecture is generated from the language 15 in the architecture reliance processing 22 based on an intermediate language skelton table 12. The language 16 is optimized in the intermediate language optimization processing 23 for output of an optimized intermediate language 17. Then an object program 18 is generated in the code generation processing 24 with use of a code generating skelton table 13. Thus an architecture reliance part is separated from a procedure by means of a 2-step skelton and the compiler developing efficiency is improved.

Description

[Detailed Description of the Invention] [Summary] Regarding the compilation processing method in a data processing device such as a COBOL compiler or F]RTRAN compiler, by separating architecture-dependent parts from the semantic analysis processing procedure in the compiler and creating a table, The aim is to improve the development efficiency of compilers by performing general-purpose semantic analysis that does not depend on computer architecture, and to create a general-purpose intermediate language from a source program. It uses a skeleton table for intermediate language that stores correspondence information with .

It is equipped with an architecture-dependent processing process that converts a general-purpose intermediate language into an intermediate type that depends on the computer architecture, and is configured to perform skeleton expansion using tables in both semantic analysis and code generation.

[Industrial application field]

The present invention relates to a compilation processing method in a data processing device such as a COBOL compiler or a FORTRAN compiler.

[Conventional technology]

FIG. 6 shows an example of the prior art.

In FIG. 6, 11 is a source program to be compiled, 13 is a code generation skeleton table used for architecture-dependent code generation, 16 is an intermediate type that is an intermediate text of the semantic analysis result, and 17 is an optimal intermediate type, 18 is the target program of the compilation result,
60 represents a semantic analysis process, 61 represents an optimization process, and 62 represents a code generation process.

The prior art will be explained using an example of translating a COBOL source program 11.

In the semantic analysis process 60, the source program 11 is input,
The semantic analysis is performed and an intermediate type 16 is output. Here, variables B and C defined in external decimal are converted into internal decimal
An intermediate type 16 is generated which is converted to decimal and added to it using an internal decimal add instruction.

In the optimization process 61, the intermediate type 16 is optimized by changing the execution logic, deleting unnecessary procedures, etc. 5 and outputs the result as the optimized intermediate type 17.

In the code generation process 62, a process of generating the target program 18 from the optimization intermediate mold 17 using the code generation skeleton table 13 is performed. The code generation skeleton table 13 has a code format depending on the target computer architecture as a table. In the code generation process 62, a code generation skeleton table 1 is created based on the intermediate type of the optimization intermediate type 17.
3, the code to be output is determined.

The PACK instruction in the target program 18 is an instruction to convert external decimal (zone format) to internal decimal (punk format), and the AP instruction is an instruction to add internal decimal, UNP
The K instruction is an instruction to convert internal decimal to external decimal. The temporary area T3 in the intermediate type 16 is overlapped with the temporary area T2 in the target program 18.

In the conventional technology, the code generation skeleton table 13 is used in the code generation process 62 to perform architecture-dependent code generation, but in the semantic analysis process 60, the code generation skeleton table 13 is used to process architecture-dependent parts. These procedures were mixed into the semantic analysis process.

[Problem to be solved by the invention]

In the conventional technology 1, for example, as shown in FIG. 6, the semantic analysis processing 60 of the compiler outputs an intermediate type 16 that depends on the computer architecture, and the code generation processing 62 outputs the intermediate type 16 or the optimized intermediate type. 17 and the code generation skeleton table 13, the code to be generated is determined.

This is because the computer architecture had to be taken into consideration in the semantic analysis processing 60, which is the output source of the binary intermediate language 16, in order to generate a high-performance object in the target architecture. However, if architecture-dependent processing is mixed in the semantic analysis processing 60 part, the semantic analysis procedure will need to be changed every time the target architecture changes, resulting in a problem that development efficiency will be reduced.

The present invention aims to solve the above-mentioned problems and improve the efficiency of compiler development by separating architecture-dependent parts from the semantic analysis process in the compiler and creating a table.

[Means to solve the problem]

FIG. 1 is a diagram explaining the principle of the present invention.

In FIG. 1, 10 is a data processing device consisting of a CPU and memory, 11 is a source program to be compiled, 12 is an intermediate language skeleton table used to generate architecture-dependent intermediate types, and 13 is an architecture-dependent intermediate language skeleton table. A skeleton table for code generation used for dependent code generation, 14 is a general-purpose intermediate type of the semantic analysis result that does not depend on the architecture, 15 is an optimized general-purpose intermediate type that is an optimized intermediate type, and 16 is a general-purpose intermediate type that is an optimized intermediate type, 16 is a general-purpose intermediate type that is an optimized intermediate type. intermediate type, 17 is an optimized intermediate type,
Reference numeral 18 represents a target program of the compilation result, 20 represents a semantic analysis process, 21 represents a general-purpose intermediate language optimization process, 22 represents an architecture-dependent process, 23 represents an intermediate language optimization process, and 24 represents a code generation process.

In the semantic analysis process 20, the source program 11 is input and semantic analysis is performed according to a predetermined grammar.

An architecture-independent general-purpose intermediate type 14 is output. In the general-purpose intermediate statement optimization process 21, changes are made to the general-purpose intermediate type 14 for optimization as necessary, and the results are output as an optimized general-purpose intermediate type 15.

The architecture-dependent processing 22 is a part that performs architecture-dependent processing related to conventional semantic analysis, and by using the skeleton table 12 for intermediate language, the optimization general-purpose intermediate type 15 is changed to an intermediate type depending on the computer architecture. Generate 16.

In the intermediate statement optimization process 23, optimization is performed such as changing the execution logic of the intermediate type 16 and deleting unnecessary procedures.
The optimized intermediate type 17 is output.

In the code generation process 24, the code generation skeleton table 13 is used to generate an object program 18 consisting of a machine language instruction sequence from the optimization intermediate type 17.

The code generation skeleton table 13 is a table that has been conventionally used to generate object code that matches the architecture based on the architecture-dependent intermediate type 16 or the optimized intermediate type 17.

In the present invention, an intermediate language skeleton table 12 is further provided that separates an architecture-dependent intermediate type 16 from the general-purpose intermediate type 14 or the optimization general-purpose intermediate type 15. The dependent processing 22 is separated.

Because it depends on the architecture, it needs to be changed every time the architecture changes, but since the architecture-dependent parts are not included in the procedure part, the semantic analysis process 20 can be shared by each architecture. Therefore, efficient development of the compiler becomes possible and maintainability is improved.

[Effect]

Create a table that absorbs differences between architectures and separate them from semantic analysis. Then, semantic analysis processing 20
Now, we will concentrate on semantic analysis and output general-purpose intermediate types for each architecture.

In the architecture dependent processing 22, the semantic analysis processing 20.
Based on the general-purpose intermediate type 14 or the optimized general-purpose intermediate type 15 output by the general-purpose intermediate expression optimization process 21, the general-purpose intermediate type 14 is created by referring to the intermediate language skeleton table 12.
Alternatively, processing is performed to convert the optimized general-purpose intermediate type 15 into an intermediate type 16 that depends on the conventional architecture.

The intermediate language skeleton table 12 is an architecture (embodiment). The second section shows an example of development according to an embodiment of the present invention, and FIGS. 3 to 5 show the structure of the intermediate language skeleton table used in an embodiment of the present invention. Give an example.

An example of a COBOL compiler will be described below, but the present invention can be similarly applied to other computer languages.

In the semantic analysis process, when the source program 11 shown in FIG. 2 is input, its meaning is analyzed and a general-purpose intermediate type 14 is output. Here, r#ADD AB, CJ are variables B
This is an intermediate type that indicates that the result of addition of and variable C is assigned to variable A. At this stage, the data attributes of variables A, B, and C have not yet been determined.

In the source program 11, variables A, B, and C are external
Although it is defined in decimal, internally it does not necessarily have to be externally in decimal. Which data attributes should be used to create a high-speed object depends on the target computer architecture. Therefore.

1, e.g. variable A, by architecture-dependent optimization.

When it is decided that the attributes of B and C should be internal decimal, the general-purpose intermediate type 14 is skeleton-developed into the intermediate type 16 according to the condition.

rADDP-L A, B, and Cj are intermediate types 16 that indicate adding internal decimal variables B and C and assigning the result to internal decimal variable A.

The object program 18 shown in FIG. 2 is the object code finally output based on the intermediate type 16, and rAP A, B, CJ is the sum of B and C, and A
This is an internal decimal addition instruction that executes the process of assigning to . Since the attribute of variable A has been changed to internal decimal, the procedure is completed with only one AP command.

Next, the configuration of the intermediate language skeleton table 12 shown in FIG. 1 will be explained using an example in which two types of architectures, a computer architecture X and a computer architecture Y are supported.

For example, regarding the general-purpose intermediate mold 14 shown in FIG. 3(a),
An architecture-dependent intermediate type shall be generated. It is assumed that the attributes of the variables are defined as A in external decimal, B in internal decimal, and C in binary.

For example, in the case of
and for X architecture, the third
It is created as shown in Figure (c).

The intermediate types in this table body have the following meanings.

(a) CVBP Convert internal decimal to binary.

(b) ADDB Add binary numbers together.

(C)CVZB Convert binary to external decimal.

(d)CVPB Converts binary to internal decimal.

(e) ADDP Add internal decimal numbers.

(f) CVZP Convert internal decimal to external decimal.

(6) ADDZ Add external decimals.

In addition to the skeleton table itself, in the case of the
The extraction bit table shown in b) is prepared. On the other hand, in the case of the X architecture, a condition identification table shown in FIG. 5(a) and an extraction bit table shown in FIG. 5(b) are prepared.

In each condition identification table, BIN is the condition for the operation to be in binary mode, PACK is the condition for the operation to be in the internal decimal mode, and ZONE is the condition for the operation to be in the external decimal mode. , the conditions of the calculation mote determined according to the architecture are described.

The extraction bit table describes information on which intermediate type should be extracted from the two-skeleton full body for the operation mode determined by the two-condition identification table. If the value in the extraction bit table is "0", it means that the extraction is to be performed, and if the value is "°1°", the extraction is to be performed.

The numbers shown in the upper column of the extraction bit table.

The numbers shown on the left side of the skeleton table correspond to each other.

The architecture-dependent processing procedure is common to each architecture and is as follows.

(1) Refer to the condition identification table and determine which calculation mode is appropriate for processing.

(2) Thereafter, referring to the take-out focus table for the determined calculation mode, take out the intermediate mold to be output from the skeleton table main body shown in FIG. 3 (b) or (c).

In this example, the X architecture has external decimal machine language instructions, the X architecture has no external decimal machine language instructions, the contents of the condition identification table differ between the X architecture and the This is because the external decimal arithmetic mode is never selected in the architecture.

There is no condition for the mode (ZONE) to be external decimal. Therefore, the ZONE mode table of the extraction bit table has the value "0" as shown in Figure 5 (b).
” will not be set.

In the case of the
Outputs an intermediate type like the following:

(a) When the calculation mode is binary (BIN) Figure 3 (
Output intermediate molds from No. 1 to No. 3 shown in b).

[Yes]) When the operation mode is internal decimal (PACK), intermediate numbers 4 to 6 shown in FIG. 3 (b) are output.

(C) If the operation mode is external decimal (ZONE), intermediate types from No. 7 to No. 9 shown in FIG. 3 (B) are output.

On the other hand, in the case of Y architecture, condition determination is performed using the condition identification table shown in Part 5 (a) for the general-purpose intermediate type 14 as shown in Figure 3 (a), and the primary Outputs an intermediate type like .

(a) When the calculation mode is binary (BIN) Figure 3 (
Output intermediate molds No. 1 to No. 4 shown in c).

0) When the calculation mode is internal decimal (PACK), intermediate types from No. 5 to No. 7 shown in FIG. 3 (C) are output.

In the X architecture, unlike the X architecture,
Since there is no instruction to directly convert binary to external decimal, -
Processing via internal decimal (CVPB, CVZP)
As mentioned above, the intermediate type of the semantic analysis result will actually be different for each architecture, but the intermediate 8 skeleton table can absorb these differences. It should be noted that the processes of the intermediate position optimization process 23 and the code generation process 24 after generating the intermediate type 16 shown in FIG. 1 may be the same as those in the conventional art, and detailed explanation thereof will be omitted.

〔Effect of the invention〕

As explained above, according to the present invention, by using a two-stage skeleton, architecture-dependent parts can be separated from procedures.

In particular, development efficiency for a large number of architectures is improved. Furthermore, by creating tables for architecture-dependent parts, maintainability is improved and reliability is increased.

Figures 3 to 5 show an intermediate 8 used in one embodiment of the present invention.
FIG. 6 shows an example of the prior art.

In the figure, 10 is a data processing device, 11 is a source program,
12 is a skeleton table for intermediate 8, 13 is a code generation skeleton table, 14 is a general-purpose intermediate type, 15 is an optimization general-purpose intermediate type, 16 is an intermediate type, 17 is an optimization intermediate type, 1
8 is a target program 20 is a semantic analysis process, 21 is a general-purpose intermediate optimization process, 22 is an architecture-dependent process, 23
24 represents an intermediate position optimization process, and 24 represents a code generation process.

Claims (1)

[Claims] From the intermediate language (16) as a result of semantic analysis and optimization processing of the source program (11), the target program (1
8) A code generation skeleton table (13) prepared in advance according to the target computer architecture.
) is used to perform a general-purpose semantic analysis independent of computer architecture in a compilation processing method in a data processing device (10) equipped with a code generation processing step (24) that determines the code to be output, from a source program. A semantic analysis process (20) that generates a general-purpose intermediate language, and an intermediate language skeleton table (1) that stores correspondence information between the general-purpose intermediate language and the intermediate language according to the computer architecture.
2) to convert a general-purpose intermediate language into an intermediate language that depends on the computer architecture (
22) A compilation processing method, characterized in that skeleton expansion using tables is performed in both semantic analysis and code generation.