JPH0581038A - Compiler - Google Patents

Abstract

PURPOSE:To eliminate a machine word which calls and terminates a function so as to reduce the capacity of the machine word and to improve execution speed by previously detecting that there is a sentence terminating the function immediately after the sentence of the called function where there is no argument. CONSTITUTION:When there is no argument of the sentence for calling the function, a judgement processing for judging whether a sentence next to the sentence which previously calls the function is that which terminates the function or not is executed S106. When it is not the sentence which terminates the function, the generation processing of a call instruction is executed S110. When the next sentence is that which terminates the function, the generation processing of the machine word returning a stack used as the work area of an automatic variable to the beginning is executed S107, and the generation processing of a jump instruction is executed. Then, a processing for jumping the sentence terminating the function is executed S109. Then, a system returns to a syntax analysis processing S101 at every line again, and the generation of the machine word is continued.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a compiler, and more particularly to a compiler relating to an optimization method in machine language generation when a function is called.

[0002]

2. Description of the Related Art In a conventional compiler of this kind, a machine language for setting an argument to a stack is generated in translation of a statement of a function call, and a machine language to call a function for setting a return address to the stack is generated. It is general to generate a machine language that generates and restores the stack used as an argument after calling a function.

An example of a flowchart for translating a description language into a machine language in a conventional compiler is shown in FIG. In FIG. 3, the sentence is interpreted in the line-by-line syntax interpretation process (step 101), and it is determined whether the file ends (step 102). If it is not the end of the file in step 102, it is judged whether or not it is the first of the function for checking whether or not it is the statement of the function definition (step 10).
3) If it is the first of the function, a process of generating a machine language that secures a stack as a work area of an automatic variable used in the function at the beginning of the function is performed (step 131). If it is not the first of the function in step 103, the actual description language is translated and the process proceeds to step 104 to determine whether or not it is a function call statement.

In step 104, if the sentence to be translated is a function call sentence, it is judged whether or not there is an argument (step 105). If there is no argument, the return address is set in the stack. A process for generating a machine language for calling a function (hereinafter, called a call instruction) is performed (step 110). Then, the process returns to the line-by-line parsing process (step 101), and the machine language generation is continued. If there is an argument in step 105, a process for generating a machine language for setting the contents of the argument in the stack (step 120) and a machine language for restoring the stack used as the argument are generated. Processing (step 12)
2) process for generating the call instruction (step 12)
It is executed before and after 1). Then, the process returns to the line-by-line syntactic analysis process (step 101), and the machine language generation is continued.

In step 104, if the sentence is not a function call sentence, it is judged whether or not it is a return sentence from the function (step 130), and if it is a sentence for ending the function, it is currently translated. Within the function, a process for generating a machine language that secures the stack used as the work area of the automatic variable described above (step 131), and a process for generating a machine language that restores the secured stack (step 132) Then, a process for generating a machine language for returning from the function (hereinafter referred to as a return instruction) is performed (step 133). Then, the process returns to the line-by-line parsing process (step 101), and the machine language generation is continued. If the statement does not terminate the function in step 130, other processing (step 140) is performed, the process returns to the line-by-line syntax analysis processing (step 101), and machine language generation is continued. Note that the other processing in step 140 is outside the scope of the present invention, and therefore description thereof is omitted. If the file ends, the machine language generation ends.

Next, an example of a machine language generated by the above-mentioned conventional compiler is shown in FIGS. 4 (a) and 4 (b). FIG. 4A is a translation of a program having a general structure, and is expressed by focusing on the first processing of a function, the calling processing of the function, and the last processing of the function. Figure 4
(B) is an example of a case where a function having no argument is called at the end of the function by the program described above.

4A and 4B, a machine language 301 is a machine language generated in the processing (step 131) in FIG. 3, and a machine language 302 is a machine language generated in the processing (step 140). , Machine language 303 is
The machine language and machine language 304 generated in the process (step 120) are the machine language and machine language 305 generated in the process (step 121), and the process (step 122).
The machine language and the machine language 306 generated in the above are the machine language and the machine language 30 generated in the processing (step 140).
7 is a machine language generated in the process (step 132), and machine language 308 is a machine language generated in the process (step 133).

As is apparent from FIGS. 4 (a) and 4 (b), in the case of the compiler of the prior art, when calling a function that does not have the last argument of the function, the function returned from the called function is returned. After that, there is nothing that should be executed originally, so if it is possible to directly return to the parent function of this called function without returning to the calling function from the called function, it will lead to a reduction in execution time. it is conceivable that. From the idea, it is judged that the above-mentioned program of FIG. 4 (b) is insufficiently optimized.

[0009]

In the conventional compiler described above, when a machine language of a statement that does not use an argument is generated when a function is called, even if there is a statement that ends the function immediately after the statement of the function call. A processing procedure of generating a machine language similar to the normal function call processing and then generating a machine language for ending the function again is used. For this reason, as described above, when calling a function having no argument at the end of the function, there is a drawback that the optimization of the machine language is insufficient.

[0010]

The compiler of the present invention is
At least in the machine language generation process of the function call part of the compiler that uses the stack as the argument passing area at the time of function call, the return address setting area after the function call, and the work area of the automatic variable defined in the function, The processing procedure to detect the presence or absence of arguments, the processing procedure to detect the presence or absence of the statement that terminates the function immediately after the statement of the function call, and the machine language that branches directly to the calling function without setting the return address in the stack And a processing procedure to generate.

[0011]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Next, the present invention will be described with reference to the drawings.

FIG. 1 is a flow chart of a machine language generation method according to an embodiment of the present invention.

As is apparent from FIG. 1, the process of determining whether or not the next statement is a statement for terminating the function (step 106) and the stack used as the definition area of the automatic variable are restored. Processing for generating a machine language (step 10)
7) and a process of generating an instruction (hereinafter referred to as a jumb instruction) which is directly branched to the function to be called (step 108)
And a process of skipping a statement that ends the function (step 10
9) is added to the flow chart according to the present invention.
This is a difference from the flowchart of the conventional compiler shown in FIG.

In FIG. 1, a syntax interpretation process is performed for each line (step 101), and a process for determining whether or not the end of the file is performed (step 102). It is determined whether or not it is the beginning of the function for confirming whether or not it is (step 103), and if it is not the beginning of the function, it is determined whether or not it is a function call sentence (step 104), and the translation target sentence is the function call sentence. If it is a sentence, a process of determining whether or not there is an argument (step 105)
The same applies to the above-described conventional technique.

The cause of the difference from the prior art of the present invention is that there is no argument of the function call statement. If this argument is not present, first, a process is executed to determine whether the sentence next to the sentence that calls the function is a sentence that ends the function in advance (step 106). If it is not the statement that terminates the function in step 106, the conventional process of generating a call instruction is executed (step 110). However, if the next statement is a statement that terminates the function, processing for generating a machine language that restores the stack used as the work area of the automatic variable is performed (step 107), and then
A process for generating a jump instruction is performed (step 10
8) Then, the process of skipping the sentence that ends the function is executed (step 109). Then, the process returns to the line-by-line parsing process (step 101) again, and the machine language generation is continued.

FIG. 2 shows an example of the machine language generated by the compiler of this embodiment, which is shown in FIG.
Similar to the case of (b), it is a machine language generation example in the case where the program has a statement that terminates the function immediately after the statement that calls the function that does not use the argument. As is clear from comparison with the machine language of FIG. 4A, the machine language 309 of the jump instruction for the function is generated instead of the machine language 304 of the call instruction for the function in FIG. The word 309 has been moved after the machine word 307 that restores the stack used as the working area for the automatic variables. Further, the machine language 308 of the return instruction in the conventional example is omitted. In this way, by changing and deleting the machine language, the capacity of the program is reduced by the return instruction, and the return from the called function is
It automatically returns directly to the parent function that called this function, and the execution time is also reduced by one return instruction.

[0017]

As described above, according to the present invention, when a statement of a function to be called has no arguments, it is detected in advance that there is a statement to end the function immediately after the statement of the function to be called. There is an effect that it is possible to reduce the capacity of the machine language and improve the execution speed by deleting the unnecessary machine language of once returning the control from the function and ending the function again.

[Brief description of drawings]

FIG. 1 is a flowchart showing a machine language generation method according to an embodiment of the present invention.

FIG. 2 is a diagram showing an example of machine language of a program generated according to the present embodiment.

FIG. 3 is a flowchart showing a conventional machine language generation method.

FIG. 4 is a diagram showing an example of machine language of a program generated by a conventional example.

[Explanation of symbols]

101 line-by-line parsing process 102 process for determining whether the file ends 103 process for determining whether it is the beginning of a function 104 process for determining whether it is a function call statement 105 whether there is an argument Process 106 to determine whether the statement immediately after the function call statement is a statement to end the function 107 process to generate a machine language to restore the stack used as the work area of the automatic variable for ending the function 108 Process for generating jump command 109 Process for skipping statement that terminates function 110, 121 Process for generating call command 120 Process for generating machine language for setting argument to stack 122 Based on stack used as argument Process for generating machine language to be returned 130 Process for determining whether function is terminated 131 Process used as work area of automatic variable A process for generating a machine language that secures a memory 132 A process for generating a machine language that restores the stack used as a work area for automatic variables 133 A process for generating a return instruction 140 Other processes 301 Automatic variables used in a function A machine language that secures a stack to be used as a work area for 302 A set of machine languages generated by other processing 303 Machine language that sets arguments in advance to call a function that uses arguments 304 Calls a function Machine language (call instruction) 305 Machine language used to return the stack used as an argument after returning from the calling function 306 A set of machine language generated by other processing 307 Used as a work area for automatic variables in a function Machine language to restore the stack 308 Machine language to return from a function (return instruction) 309 Up instruction

Claims (1)

[Claims] 1. A machine language generation of a function call part of a compiler that uses a stack as an argument passing area when a function is called, a return address setting area after the function is called, and a work area of an automatic variable defined in the function. In the processing, at least the processing procedure to detect the presence or absence of arguments, the processing procedure to detect the presence or absence of the statement that terminates the function immediately after the statement of the function call, and the return address are not set in the stack and directly A processing procedure for generating a branching machine language, and a compiler.