JPH0689187A - Inline expansion optimizing method - Google Patents

Abstract

PURPOSE:To improve the execution performance of a function by reducing a temporary variable generating and copy instruction for transfer of parameters and return values based on analysis information of the function at the time of inline expansion of the function. CONSTITUTION:A syntax analysis part 103 reads in a source program 101 and performs the syntax analysis to generate an intermediate code 104 on a storage device 121. The reduction (inline expansion optimization) of the temporary variable generating and copy instruction for parameters and return values is integrated in the processing of an inline expansion optimizing part 105, and the intermediate code 104 on the storage device 121 is changed with an intermediate code of the expansion result. An optimizing part 110 takes the intermediate code 104 as the input and optimizes various codes of function units to change the intermediate code 104. An object program generating part 111 takes the intermediate code 104 as the input and assigns storages and registers to various data in the intermediate code to generate a machine instruction string, thereby outputting an object program 112 to the storage device 121.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a compiler which compiles a source program written in a programming language such as C language in which function parameters and return values are passed by value, and in particular, inline expansion of functions. Regarding the optimization method of.

[0002]

2. Description of the Related Art Conventionally, in a compiler, inline expansion such as that described in Ikuo Nakata, "Compiler", page 220, has been used as a method of reducing the overhead at the time of calling a subroutine or a function. It was being done. This is a method of expanding the main body of the called function to the calling location, and it is possible to reduce the overhead related to dynamic storage allocation, register save / recovery, and return address maintenance when the function is called.

As an example of applying this method to C language,
W. W. Hwu, P. P. Chang, "Inline Function
Expansion for Compiling C Programs ", Processedi
ngsof the SIGPLAN '89 Conference on Pro
The graming Language Design and Implementation etc. have been reported. In this paper, inline expansion further enhances general optimizations such as constant propagation and dead code elimination. However, the reduction of temporary variable generation and copy instructions that occur when a large number of parameters and return values are called at the time of function call as in the C language and these are value-passed have not been reported. That is, for a parameter passed by value and a return value, a temporary variable is generated without exception and a copy instruction for the temporary variable is executed.

[0004]

As described above, the conventional compiler has a large number of parameters and return values at the time of function call, and the temporary variable generation and copy instructions generated when these are passed by value. No consideration is given to reduction.

As an example, consider the case of compiling the C language source program shown in FIG. Figure 7 shows this C
The pseudo C code showing the operation of the target program when the language source program is processed by the conventional compiler is shown.

As shown in FIG. 7, conventionally, temporary variables a'and b'are generated for the parameters a and b by the inline expansion of the function g, and the argument a is preceded by a before the inline expansion part of the function g. It is necessary to copy the argument b into b'into 'and replace the parameter reference with a'and b'in the inline expansion. Also, regarding the return value, the temporary variable t
Must be generated, the return value must be set to t, and t must be copied to c at the end of the inline expansion.

However, in the inline expansion,
If there is no side effect on the parameter in the called function, it is not necessary to create and copy a temporary variable for the parameter. Also, if the return value is assigned to another variable by the assignment operation at the caller. Replaces this variable with a temporary variable, which eliminates the need for temporary variable generation and copying for the return value.

An object of the present invention is to provide an inline expansion optimizing method for improving the execution performance of a function by deleting unnecessary temporary variable generation and copy instructions for passing values such as parameters and return values. To do.

[0009]

SUMMARY OF THE INVENTION The present invention targets a source program in C language or the like in which function parameters and return values are passed by value, and in a compiler that performs inline expansion of functions, the functions to be inline expanded are analyzed in advance. By collecting the information for determining the necessity of the temporary variable generation and copy instruction for passing the parameter or the return value of the value, and based on this information, the parameter or the return value of the parameter or the return value is expanded when the function is inline expanded. The main idea is to create temporary variables for passing by value and reduce the number of copy commands.

[0010]

According to the present invention, based on the analysis information of the function, the same processing as in the past, that is, a temporary variable is assigned to the parameter for which the temporary variable is determined to be necessary, and the parameter value of the temporary variable is assigned. The process of inserting the copy code and replacing the reference of the parameter with the reference of the temporary variable when copying the code of the function body to the caller will be performed, but for the parameter judged that the temporary variable is unnecessary On the other hand, such processing is omitted.

Further, as in the conventional case, a temporary variable is assigned to a return value that is determined to require a temporary variable based on the analysis information, and the evaluation value of the return expression is assigned to this temporary variable at the time of inline expansion of the function body. Replace with the code to substitute,
However, for the return value that is judged to be unnecessary for the temporary variable, it is said that when the inline expansion of the function body is performed, the evaluation result of the return expression is replaced with the code that directly assigns it to the calling variable. Only processing is possible.

[0012]

FIG. 1 shows an embodiment of the present invention.
Reference numerals 120 and 121 are a central processing unit (CPU) and a storage device of the computer. Here, it is shown that the compiler 102, the source program 101 that is the input thereof, and the target program 112 that is the output thereof are all placed on the storage device 121.

The compiler 102 uses the source program 1
01 is read and compiled to generate the target program 112 on the storage device 121. Functionally, the syntax analysis unit 103 and the inline expansion optimization unit 1
05, the optimization unit 110, and the target program generation unit 111.

The syntactic analysis unit 103 uses the source program 1
01 is read, the parsing is performed, and the intermediate code 10
4 is generated on the storage device 121. An inline expansion optimization unit 105 takes in the intermediate code 104 and analyzes it to create a call graph 107. A call graph creation unit 106, and an inline for determining whether inline expansion is possible by using this call graph 107 as an input. The expansion selection unit 108 and the inline expansion selection unit 108 include an inline expansion unit 109 that expands a function called at a call point of a function determined to be inline expandable. The temporary variable generation and the reduction of copy commands (inline expansion optimization) for the parameters and the return value of the present invention are integrated into the processing of the inline expansion optimization unit 105, and the intermediate code of the expansion result is stored in the storage device 121. Intermediate code 10
Change 4. The optimization unit 110 inputs the intermediate code 104, performs various code optimizations for each function, and changes the intermediate code 104. The target program generation unit 111 inputs the intermediate code 104, allocates storage areas and registers for various data in the intermediate code, and generates a machine instruction sequence to store the target program 112 in the storage device 1.
21 output on. Here, the inline expansion optimization process will be described more specifically. The call graph creating unit 106 scans all the intermediate codes 104 obtained by the syntax analysis of the source program 101 to be compiled to create a call graph 107, which is called at the call graph creating stage. Information on the original format and the usage pattern of the callee parameter is also collected and stored in the call graph 107. Based on the call graph 107, the inline expansion selection unit 108 determines which function call is to be expanded inline.

The inline expansion unit 109 copies the code of the body of the function to the caller of the selected function. At this time, the format of the caller stored in the call graph 107 and the call By referring to the information on the usage form of the parameter, it is determined whether or not the temporary variable generation and copying for the parameter are necessary and the temporary variable generation for the return value is necessary.

Then, for the required parameter of the temporary variable, the temporary variable is assigned prior to the inline expansion,
Insert the copy code of the parameter value into the temporary variable and replace the parameter reference with the temporary variable reference when the function body is inline expanded. These processes are not performed for unnecessary parameters of temporary variables. Also, for the required return value of a temporary variable, a temporary variable is assigned prior to inline expansion, and when the function body is inline expanded, the result of evaluating the return expression is replaced with the code that assigns to this temporary variable. As for the unnecessary return value of the temporary variable, the evaluation result of the return expression is simply replaced with the code that is directly assigned to the calling variable when the function body is inline expanded.

With respect to inline expansion optimization, the call graph 107 is of the form:

G = (N, A) N: A node indicating each function in the source program to be compiled. A: An arc corresponding to each function call in the source program to be compiled. Create for each call.

N = (FA, PU) FA: Attribute of function N. PU: A flag string indicating the usage status of each parameter in the function N. If the parameter is reference only in the function, it is "reference only", and if the value may change, it may be changed.
And

A = (S, T, AA, AU) S: Node corresponding to the calling function. T: A node corresponding to the called function. AA: Attribute of calling point. AU: A flag string indicating the form of the argument and the return value. When each argument can be accessed by one machine instruction or less in the target architecture, it is "simple", and when it can be two or more instructions, it is "complex". The return value is "simple" when it is used as the assignment source in the call source, and "complex" when it is not used as the assignment source.

The elements of the call graph relating to the inline expansion optimization are PU and AU. The processing added to the call graph creation unit 106 in relation to the information collection of PU and AU is shown in FIG. 5 as a PAD diagram. The contents of each step are as follows.

Step 1: Steps 2 to 7 for each function f in the source program to be compiled
Repeat the process up to.

Step 2: Function f still in the call graph
If the node for F is not created, the node for the function f is created and the FA and PU information is initialized. PU
For initialization, the flag arrays corresponding to the number of parameters of the function f are allocated and set to “reference only”. Function f in the call graph
When the node for is created, only the FA and PU information is initialized.

Step 3: Steps 4 to 7 are repeated for all operations in the function f.

Step 4: If the value of the parameter may change if the operation references the parameter, then
The corresponding PU information is changed to "changeable".

Step 5: When the calculation is the call of the function g, the processing from step 6 to step 7 is performed.

Step 6: If the node for the called function g is not created, the node for the function f is created.

Step 7: Create an arc from the function f to the function g and set the AA and AU information. The AU information is set to "simple" when each argument can be accessed with one machine instruction or less in the target architecture, and is set to "complex" when there are two or more instructions. For the return value, the function g
If the result of is used as the substitution source of the substitution operation, it is set as "simple", and if it is not used as the substitution source, it is set as "complex".

FIG. 3 is a PAD diagram showing the processing of the inline expansion unit 109 for expanding the function to be called at the function call point determined by the inline expansion selection unit 108 to be inline expandable. The contents of each step are as follows.

Step 11: The AU information of the arc A corresponding to the function call and the PU information of the node corresponding to the T function are taken out.

Step 12: Steps 13 to 14 are performed for each parameter.

Step 13: If the AU information is "simple" and the PU information is "reference only", nothing is done.
If not, step 14 is performed.

Step 14: Allocate a temporary variable for the parameter and insert a code for copying the argument into this variable. Also, a replacement pair record is created in order to replace the operation that refers to the parameter with the temporary variable reference.

Step 15: If the AU information for the return value is "simple", then step 16 is carried out. If not, step 17 is carried out.

Step 16: The assignment destination of the assignment operation of the calling source is set in the return value assignment destination record indicating the assignment destination of the evaluation result of the return expression.

Step 17: A temporary variable is assigned to the return value, and this temporary variable is set in the return value assignment destination record so that it becomes a temporary variable indicating the assignment destination of the evaluation result of the return expression.

Step 18: Repeat steps 19 to 21 for all the operations in the callee function.

Step 19: If the operation refers to the replacement source of the replacement pair record, it is changed to the replacement destination and inserted into the caller.

Step 20: If the operation is a Ritan expression, the operation is changed to an operation for assigning a record to which a return value is assigned and is inserted into the caller.

Step 21: For other calculations,
Insert it as it is in the caller.

Step 22: When the AU information for the return value is "complex", the caller's operation is replaced with the return value substitution destination record (in this case, a temporary variable) and inserted.

When the C language source program of FIG. 4 is processed by the compiler 102 of the present invention, the call graph 10 having the contents shown in FIG.
7 is created. In the case of this example, since the parameters a and b are accessed only as a reference in the function g,
The PU information corresponding to the function g is "reference only" for both a and b, and the AU information of the arc corresponding to the call of the function f from the function f is "simple" for all the arguments a, b and the return value. .

When the inline expansion selection unit 108 determines that this function call is inline enabled, the inline expansion unit 109 determines that the PU information corresponding to the function g is “reference only” for both a and b, and the function f The AU information of the arc corresponding to the call of the function g is "argument a and b".
Since it is "simple", the temporary variable is not assigned to the parameter and the argument is not copied to the temporary variable. Regarding the return value, the AU information of the arc corresponding to the call from the function f to the function g is also applied to the return value. Since it is "simple", the temporary variable is not allocated and the evaluation result of the Ritan expression is directly assigned to the caller variable.

Therefore, the target program for the C language source program of FIG. 4 is executed as shown by the pseudo C code in FIG. As can be seen from this example, according to the present invention, it is possible to improve the execution performance of a function optimized by inline expansion.
In addition, this optimization can be executed uniformly in the inline expansion optimization process, and as a result, the load of the general in-function optimization process (optimization unit 110) thereafter can be reduced and its effect can be obtained. Can be increased.

[0045]

As described in detail above, according to the present invention, in the compiler, based on the analysis information of the function,
Execution performance of a function can be improved by reducing the number of temporary variables and copying instructions for passing a parameter or a return value when inlining a function.

The same effect may be expected in some cases by performing copy propagation after applying the conventional technique. However, as the number of temporary variables increases, the overhead of optimization processing such as copy propagation increases, which may result in being out of the optimization target. If it is out of the optimization target, copying to a temporary variable involves memory access, and in the load store architecture, the performance is particularly large. According to the present invention, since no code is newly generated by optimization, such performance deterioration does not occur.

[Brief description of drawings]

FIG. 1 shows the configuration of an embodiment of the present invention.

FIG. 2 is a PAD of additional processing of the call graph creation unit 106.
It is a figure.

FIG. 3 is a PAD diagram of processing of an inline expansion unit 109.

FIG. 4 shows an example of a C language source program.

5 is a pseudo C code showing the operation of the object program when the source program of FIG. 4 is processed in this embodiment.

6 shows the contents of a call graph generated from the source program of FIG.

FIG. 7 is a pseudo C code showing the operation of the target program when the source program of FIG. 4 is processed by the conventional technique.

[Explanation of symbols]

 Reference numeral 101 source program 102 compiler 103 syntactic analysis unit 105 inline expansion optimization unit 106 call graph creation unit 107 call graph 108 inline expansion selection unit 109 inline expansion unit 110 optimization unit 111 target program generation unit 112 target program 120 central processing unit 121 storage apparatus

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Kiyoshi Takahashi 6-81 Onoue-cho, Naka-ku, Yokohama-shi, Kanagawa Hitachi Software Engineering Co., Ltd. In-house

Claims (3)

[Claims] 1. A compiler that performs inline expansion of a function determines whether or not a temporary variable generation and copy instruction for passing a parameter and a return value of the function is necessary by performing an analysis in advance for the function to be inline expanded. A method for optimizing inline expansion, which is characterized by collecting temporary information and performing temporary expansion and temporary reduction of temporary variables for passing parameters and return values at the time of inline expansion of a function based on this information. 2. Information for determining whether or not a temporary variable generation and copy instruction for passing a value of a parameter is necessary by analyzing in advance the function to be inlined in a compiler that performs inline expansion of a function. And an inline expansion optimizing method characterized by generating temporary variables for passing parameter values and reducing copy instructions based on this information. 3. A compiler for performing inline expansion of a function, for analyzing the function to be inline expanded in advance to determine whether or not a temporary variable generation and copy instruction for passing the return value is necessary. An inline expansion optimizing method characterized by collecting information, and based on this information, generating a temporary variable for passing a return value by value and reducing copy instructions when the function is inline expanded.