JPH09218789A - Division compiling system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To reduce wasteful code generation in compiling. SOLUTION: Object information files 8 are given for respective compiled functions and an intermediate word obtained by converting a source code is recorded in the object information file 8 in compiling before the last time. The intermediate language is compared with the intermediate word obtained by converting a source code in compiling this time and a discrimination phase 5 discriminates a changed function. An object code is generated again in a code generation phase 6 on only the changed function. The function without the change is copied by the code generation phase 6 on the object code obtained in compiling before the last time.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program compiling method, and more particularly to a split compiling method.

[0002]

2. Description of the Related Art A computer program is compiled by analyzing a source program, decomposing it into basic elements, and converting it into an intermediate language. Furthermore, the intermediate language is subjected to optimization processing or the like to generate a code, and a target program equivalent to the source program is created. To do this, the compiler creates some tables during the parsing phase. These tables are used in the analysis phase and the code generation phase.

The conventional compiling method has been performed in units of source files. For example, f, g,
If h and multiple functions are included, the function f is modified, and even if the modification does not affect the functions g and h, not only the function f but also the functions g and h are unconditionally compiled. The code was generated again and the object file was generated.

[0004]

As described above, the conventional compilation method compiles in source file units. Therefore, if a function in a source file containing a plurality of functions is changed, it is changed. Since the function that does not change is recompiled, there is a problem that the same code is created twice for the function that has not changed.

Further, conventionally, since compilation is performed in units of source files, when different compilation options are specified for each function in a source file containing a plurality of functions, the pragm for specifying the options is specified in the source code.
It was realized by embedding a. However, pr
Since the agma specification depends on the compiler, even if the same source file is tried to be compiled by another compiler, it cannot be compiled. Thus, there is a problem that the source file is not portable.

Further, it was necessary to recompile even a change that did not affect the final object code, such as a change in comment, exchange of commutative operators, or simple addition of tabs and blank characters. Therefore, there is a problem that the same code is generated twice. Also, if there is a change in a function in a source file that contains multiple functions, it will be recompiled including the unchanged function. Therefore, if you link the object file, use the changed function. Even if you don't, you still have the problem of having to relink.

[0007]

In order to solve the above-mentioned problems, the present invention provides a separate compilation method in which a source program is divided into a plurality of parts, and a compile option is specified for each function to compile each function. The object information file is provided for each compiled function, and the intermediate language obtained by converting the source code during the previous compilation is recorded in this object information file. The intermediate code obtained by converting the source code in this compilation is compared to determine the changed function, the object code is regenerated only for the changed function, and the unchanged function is obtained in the previous compilation. The object code is copied.

[0008]

FIG. 1 is a block diagram showing an example of an embodiment of a split compilation system of the present invention. In addition,
In FIG. 1, a solid arrow indicates a program flow, and a broken arrow indicates an information flow. In the figure, 1 is a source program to be compiled, which is a series of characters described based on a certain rule.

Reference numeral 2 is a compiler for constructing the object program 3 from the source program 1. The configuration of this compiler will be described below. Reference numeral 4 is an analysis phase, which is composed of a function of analyzing the source program 1, decomposing the source program 1 into basic elements, and converting it into an intermediate language. Reference numeral 5 is a discriminating phase, which comprises a function for discriminating whether or not the function in the source program 1 is to be compiled. The details of this function will be described later.

A code generation phase 6 is a function 6a for generating a code in the case of a function to be compiled on the basis of the discrimination result in the discrimination phase 5, and a function 6a which does not need to be compiled is obtained at the time of the previous compilation. It is composed of a function 6b for copying the code. Further, the compiler 2 is provided with a table 7 of various kinds of information, and the analysis phase 4, the discrimination phase 5, and the code generation phase 6 perform analysis, discrimination, and code generation using the table 7.

Here, in order to compile each function, it is possible to specify a compile option for each function. Further, the object information file 8 is generated for each compiled function and provided for each function. The contents of this object information file are the date when the function was compiled, the options specified when the function was compiled, and the intermediate language of all functions included in the source file.

FIG. 2 is an explanatory diagram showing an example of the operation of the split compilation method of the present embodiment, and the operation of the compiler described in FIG. 1 will be described in detail. For example, the source file a. Assuming that the functions c, f, g, and h are included in c, analysis is performed in the analysis phase 4 described with reference to FIG. 1, and the source program is converted into an intermediate language. Next, determination phase 5
Determines whether the function name and option name are specified for each function. At this time, the function f is specified as a debug option, the function g is specified as an optimization option, and the function h is specified as no option.

Here, when it is judged in the judgment phase 5 that the function names f and g have the option names and the function h has the function names, the code of the function f is generated in the code generation phase 6. , The code of the function g and the code of the function h are generated, and the object file a. get o. At this time, the object information file a. Inf is also generated and given to each function. This object information file a. In the inf, the compilation time for each function, the option specified at the time of compilation, the source file a. The intermediate words of all the functions contained in c are recorded.

As described above, if the function f is modified after the first compilation, the intermediate words of the object information files are compared in the discrimination phase 5 when the second compilation is executed. It can be seen that the function f is a modified function. That is, in the determination in the determination phase 5, first, it is determined whether the function name and the option name are specified, and if they are specified, the intermediate comparison is not performed, and the code generation is performed as in the first compilation. Code is generated in phase 6. If it is not specified, before the previous time, here the intermediate language converted in the analysis of the first compilation and recorded in the object information file is compared with the intermediate language converted in the analysis of this compilation, and the changed function And generate code in the code generation phase 6 for the function and the affected functions and variables. A function that has not been changed, a function that does not affect the change, a function that does not have an option specified, and has no change does not generate a code, and copies the code generated before the previous time in the code generation phase 6.

As mentioned above, the source files a. When the function f of o is changed, the code is regenerated only for the function f,
For the functions g and h, the previously generated code is copied as it is and a new object file a. get o '.
Then, the previously generated object file a. o to delete the newly created object file a. o '
Object file a. Rewrite the name to o.

Here, even if the compile option is not specified at the time of recompilation, the contents of the compile option specification are recorded in the object information file. Therefore, by looking at the object information file, the compile option of the changed function I know what. In other words, in the second and subsequent compilations, the specification is not necessary unless the compile options are changed. For example, when recompiling the function f as described above, if the compile option is not changed, the compile option may not be specified.

Further, since a comment, a space, or the like that does not affect the execution code does not become an intermediate language, even if the comment or the like is changed, the intermediate language does not change. Therefore, by comparing the intermediate words, it is possible to prevent recompilation due to a change in the source program that does not affect the final target program. Next, a method for linking the object files obtained by the above-mentioned split compilation method to obtain the target program will be described.

FIG. 3 is an explanatory diagram showing an example of linking of object files obtained by the split compilation method of this embodiment. Source file a. c includes functions f, g, h, and source files b. c contains the functions i and j, and the source files a. c to compile the object file a. o is obtained and the source file b. Compile c into an object file b. o is obtained.
If neither function g nor h calls function f, function i calls function g, and function j calls function h, the object file a. o and the object file b. Executable file obtained by linking a. The function f is not used in out.

In this case, when the function f is changed, the source file a. Since the entire c is recompiled, the object file a. o and the object file b. had to relink o. On the contrary,
In the split compilation method of the present invention, when the function f is changed, only the function f is recompiled, so that relinking is unnecessary unless the function f is used.

As described above, according to the present invention, a compile option is specified for each function so that the function can be compiled for each function. Since it is decided to regenerate the code only for the functions that existed and to copy the code obtained by the previous compilation for the functions that have not changed, it is possible to prevent the same code from being regenerated.

Further, since the optimization option and the debug option can be set for each function, the compile time can be shortened. Furthermore, since the contents of the compile option specification are given to each function as an object information file, even if there is no option specification at the time of recompilation, the compile option of the changed function can be identified by looking at the object information file. It is not necessary to specify the compile option.

Also, since the presence or absence of code generation is determined by comparing the intermediate words recorded in the object information file, recompilation due to changes in the source program that do not affect the final target program, such as changes in comments, is prevented. be able to. Furthermore, by compiling for each function, if there is a change in a function that is not used in the linked object file, relinking is not necessary unless this function is used. Can be reduced.

[0023]

As described above, according to the present invention, when a source program is compiled to obtain a target program, the functions are compiled for each function, and a function is changed after the compilation and code generation once. , It was decided to regenerate the code only for the function that has changed and copy the code obtained by the previous compilation for the function that has not changed, so it is possible to prevent the same code from being regenerated and useless. Code generation can be reduced.

[Brief description of drawings]

FIG. 1 is a block diagram showing an example of an embodiment of a split compilation system of the present invention.

FIG. 2 is an explanatory diagram showing an example of the operation of the split compilation method of the present embodiment.

FIG. 3 is an explanatory diagram showing an example of a link.

[Explanation of symbols]

 1 Primitive program 2 Compiler 3 Object program 4 Analysis phase 5 Discrimination phase 6 Code generation phase

Claims (3)

[Claims] 1. A divided compilation method in which a source program is divided into a plurality of parts and compiled, wherein a compile option is specified for each function to perform compilation for each function. 2. The divided compilation method according to claim 1, wherein an object information file is provided for each compiled function, and an intermediate language obtained by converting the source code at the time of previous compilation is recorded in this object information file. The intermediate language obtained by converting the source code in this compilation and the intermediate language are compared to determine the changed function, the object code is regenerated only for the changed function, and the unchanged function is used. Is a separate compilation method that is characterized by copying the object code obtained during the previous compilation. 3. The divided compiling method according to claim 2, wherein the contents specified by the compile option are recorded in the object information file, and the object which is given to the corresponding function when the changed function is recompiled. A separate compilation method characterized by recompiling according to the specification of compilation options recorded in the information file.