JP2015210740A - Compilation method, compilation device, and compilation program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To shorten a compilation time of a source program.SOLUTION: A compilation device 100 extracts duplicate method candidates from a method group in an intermediate language I code obtained through syntax analysis and meaning analysis on a source program sc. The compilation device 100 generates information 110 on correspondence relation between methods of the extracted duplicate method candidates based upon processing logic specified with respective intermediate language I codes of the extracted duplicate method candidates. The compilation device 100 determines whether the methods of the duplicate method candidates have redundancy in terms of execution based upon the generated correspondence relation information 110, and performs merging processing on duplicate method candidates having the redundancy between methods in terms of execution.

Description

  The present invention relates to a compiling method, a compiling device, and a compiling program.

  Conventionally, software development in the field of computational science, especially in the world of High Performance Computing (HPC), has been mainly coded by Fortran. However, in recent years, in the field of computational science, not only C language but also software coded in object-oriented languages such as C ++ and Java (registered trademark) has been increasing from the viewpoint of high productivity and reusability. Yes.

  Prior art includes, for example, a technique for encapsulating a reference to a method in an object-based programming system and ensuring that the reference is safe. In addition, there is a technique that enables grouped description when the same method is described for a plurality of objects in a script language processing apparatus that executes an object-oriented program by an interpreter.

JP-T-2002-517815 JP-A-10-171656

  However, according to the prior art, a source program coded in an object-oriented language often includes a large number of methods due to the linguistic features of the object-oriented language, which increases the compilation time of the source program. is there.

  In one aspect, an object of the present invention is to provide a compiling method, a compiling device, and a compiling program for shortening the compiling time of a source program.

  According to one aspect of the present invention, a plurality of merge candidate methods are extracted from a plurality of methods in an intermediate language code obtained by syntax analysis and semantic analysis of a source program, based on at least an inheritance relationship or a name, Based on the processing logic specified by the intermediate language code of each of the plurality of merge candidate methods, a plurality of mergeable methods that can be merged are extracted from the plurality of merge candidate methods, and the plurality of mergeable methods are merged. A compiling method, a compiling device, and a compiling program are proposed.

  According to one aspect of the present invention, there is an effect that it is possible to shorten the compile time of the source program.

FIG. 1 is an explanatory diagram of an example of the compiling method according to the embodiment. FIG. 2 is a block diagram illustrating a hardware configuration example of the compiling device 100. FIG. 3 is an explanatory diagram showing a specific example of the source program sc. FIG. 4 is an explanatory diagram showing a specific example of the intermediate language I code. FIG. 5 is a block diagram illustrating a functional configuration example of the compiling device 100. FIG. 6 is an explanatory diagram (part 1) of a comparative example of data between methods of duplicate method candidates. FIG. 7 is an explanatory diagram (part 2) illustrating a comparative example of data between methods of duplicate method candidates. FIG. 8 is an explanatory diagram (part 3) of a comparative example of data between methods of duplicate method candidates. FIG. 9 is an explanatory diagram (part 4) illustrating a comparative example of data between methods of duplicate method candidates. FIG. 10 is an explanatory diagram showing merge processing of the SetColor method. FIG. 11 is an explanatory diagram showing an example of the intermediate language I code of the method body obtained by merging the SetColor method. FIG. 12 is an explanatory diagram of an example of a source program that does not merge duplicate method candidates. FIG. 13 is a flowchart illustrating an example of a compile processing procedure of the compile device 100. FIG. 14 is a flowchart illustrating an example of a specific processing procedure of the duplicate method candidate extraction processing. FIG. 15 is a flowchart illustrating an example of a specific processing procedure of the correspondence relationship information generation processing. FIG. 16 is a flowchart illustrating an example of a specific processing procedure of the merge processing.

  Exemplary embodiments of a compiling method, a compiling device, and a compiling program according to the present invention will be described below in detail with reference to the drawings.

(One example of compiling method)
FIG. 1 is an explanatory diagram of an example of the compiling method according to the embodiment. In FIG. 1, a compiling device 100 is a computer that compiles a source program sc. The source program sc includes source code coded in an object-oriented language. Examples of object-oriented languages include Java and C ++.

  The compiler compilation process is roughly divided into a syntax / semantic analysis section, an optimization section, and a code generation section. In the syntax / semantic analysis section, the source program sc is input, and the source program sc is subjected to syntax analysis and semantic analysis, and an intermediate language I code that is an interface in the syntax / semantic analysis section is generated.

  Methods (functions) in the source program sc are expressed in the intermediate language I code. A method is a group of instructions for realizing a certain process. Further, in the syntax / semantic analysis section, an intermediate language II code which is an interface in the compiler is generated with the intermediate language I code as an input.

  In the optimization section, the intermediate language II code is input and the intermediate language II code is optimized. In the optimization process, for example, a method deemed unnecessary from the intermediate language II code is deleted. Examples of methods that are considered unnecessary include methods that are not used in static methods limited to translation units.

  In the code generation area, the object file f is generated with the intermediate language II code as an input. The object file f is a file including an object code in which instructions and data are expressed in machine language. The object file f is transferred to, for example, a program called a linker, and finally an execution program is generated.

  Here, the object-oriented language is a programming language that can obtain high productivity and reusability as compared to the Fortran or C language. On the other hand, in an object-oriented language, many methods that summarize data operations and processing logic for each data type are created from the concept of encapsulation, override, and overload, which are linguistic features of the object-oriented language.

  Further, in the template function of the object-oriented language, a plurality of methods having the same processing logic are created by the compiler depending on the type and value of the template argument. Encapsulation is to unify data and procedures (methods) for manipulating data, defining them as “objects”, and hiding the detailed specifications and structures in the objects from the outside. It can be said that the methods in a class are described in the concept of encapsulation. A class defines a template of an object and describes what fields (variables) / methods the object has.

  Overriding means redefining a method defined in the base class in a derived class (subclass) inherited from the base class (super class). Overloading means overloading methods and operators with the same name that have different types, numbers, and order of arguments.

  When the number of methods included in the source program sc increases, the compilation time of the source program sc increases and the data size of the generated object file f increases. That is, in the object-oriented language, an increase in the compilation time of the source program sc and an increase in the data size of the object file f are problematic in exchange for high productivity and reusability.

  In order to shorten the compile time of the source program sc and reduce the data size of the object file f, it is effective to reduce the absolute number of methods. In the conventional compiler, methods that are considered unnecessary are deleted in the optimization processing of the optimization section.

  However, in the conventional compiler, unless the methods in the source program sc are not considered unnecessary, all the methods are translated into the object file f as a compilation target. As described above, since a large number of methods are created in an object-oriented language, the absolute number of methods does not change significantly only by deleting unnecessary methods, and the reduction of compile time cannot be expected much.

  Here, it is possible to reduce the absolute number of methods by merging a plurality of methods having the same data and processing logic, that is, redundancy in terms of execution, into one method. For example, methods that are overridden or overloaded are highly likely to have redundancy in terms of execution, and can be methods to be merged.

  For this reason, in the optimization process of the optimization section, methods deemed unnecessary are deleted, and a plurality of methods having redundancy in terms of execution are judged from the linguistic features of the object-oriented language and merged into one method. It is possible. However, in the optimized section, language-independent processing that is basically independent of languages such as Fortran, C language, C ++, and the like is performed. For this reason, the information specific to the object-oriented language is scarce in the optimization section, and it is difficult to perform optimization processing specific to the object-oriented language.

  In other words, because the information specific to the object-oriented language is scarce in the optimization section, it is determined which of the large number of methods is a redundant method in terms of execution with the linguistic features of the object-oriented language. It is difficult to judge. Therefore, even when trying to merge a plurality of methods in the optimization process of the optimization section, it is not possible to effectively reduce the number of methods within a realistic finite time.

  In the object-oriented language, code redundancy at the time of execution does not always appear in the source program sc. For example, a compiler may generate code that is redundant in terms of execution. Furthermore, the determination of encapsulation, overriding, and overload cannot be determined only by the face of the source program sc, and cannot be determined accurately unless syntax / semantic analysis is performed.

  Further, much of the compile time of the source program sc depends on the optimization process in the optimization section. If the number of methods is not reduced at the time of input of the optimization section, the compile time cannot be shortened. From these facts, in order to shorten the compilation time and the data size of the object file f, in the syntax / semantic analysis section that can determine the linguistic features of the object-oriented language as well as optimization processing in the optimization section There is a need for optimization at the source program level (closer to the source program sc).

  Therefore, in this embodiment, in the syntax / semantic analysis section that can determine the linguistic characteristics of the object-oriented language, a plurality of methods having redundancy in terms of execution are determined from the linguistic characteristics of the object-oriented language, and one method is determined. Explain how to compile to reduce the absolute number of methods by merging with methods. Hereinafter, a compile processing example of the compile device 100 will be described.

  (1) The compiling device 100 performs syntax analysis and semantic analysis of the source program sc in the syntax / semantic analysis section. Here, the syntax analysis is to check whether a sentence or a structure described in the source program sc conforms to the language specification. Semantic analysis is to check whether the variable type and sentence described in the source program sc are semantically correct.

  By performing syntax analysis and semantic analysis of the source program sc, an intermediate language I code that is an interface in the syntax and semantic analysis section can be obtained. Methods in the source program sc are expressed in the intermediate language I code. Further, in the intermediate language I code, there is information ((e) in FIG. 1) representing the characteristics of the object-oriented language for the methods having the characteristics of the object-oriented language.

  (2) In the syntax / semantic analysis section, the compiling device 100 has a plurality of methods based on at least an inheritance relationship or a name from a plurality of methods in the intermediate language I code obtained by syntax analysis and semantic analysis of the source program sc. Extract merge candidate methods. Here, the plurality of merge candidate methods are a plurality of methods that may have redundancy in terms of execution.

  In the following description, a plurality of merge candidate methods may be collectively referred to as “duplicate method candidates”. Duplicate method candidates include, for example, overridden methods and overloaded methods.

  Specifically, for example, the compiling device 100 refers to the intermediate language I code of the source program sc, and extracts a plurality of methods having the same name between classes having a parent-child relationship as duplicate method candidates. Thereby, the overridden method can be extracted as a duplicate method candidate.

  (3) In the syntax / semantic analysis section, the compiling device 100 generates correspondence information 110 between methods of duplicate method candidates based on the processing logic specified by the intermediate language I code of each extracted duplicate method candidate. . Here, the correspondence relationship information 110 is information for determining whether there is redundancy in terms of execution between methods of duplicate method candidates.

  Specifically, for example, the compiling device 100 extracts an intermediate language I code corresponding to each duplicate method candidate from the intermediate language I code of the source program sc. Next, the compiling device 100 compares data between methods for each data of declaration, sentence, and expression in the extracted intermediate language I code.

  Then, the compiling device 100, based on the comparison result for each data, in the intermediate language I code corresponding to each duplicate method candidate, a portion that is semantically identical between methods and a portion that is semantically different between methods Information for identifying (a part unique to each method) is generated as correspondence information 110.

  (4) In the syntax / semantic analysis section, the compiling device 100 determines whether or not there is redundancy in terms of execution between methods of duplicate method candidates based on the generated correspondence relationship information 110. Specifically, for example, the compiling apparatus 100 performs redundancy in terms of execution between duplicate method candidate methods when at least one of the data of declarations, statements, and expressions is semantically identical. You may determine with having. Duplicate method candidates having execution redundancy between methods are a plurality of mergeable methods that can be merged.

  (5) When the compiling device 100 determines that there is redundancy in terms of execution between methods of duplicate method candidates in the syntax / semantic analysis section, the merge method of duplicate method candidates based on the correspondence information 110 I do. That is, the compiling device 100 extracts a plurality of mergeable methods that can be merged from the duplicate method candidates, and performs a merge process for the plurality of mergeable methods. Here, the merging process is to combine a plurality of methods that are duplicate method candidates as one method that can be called from any caller of the duplicate method candidates.

  For example, it is assumed that there are three methods, method A, method B, and method C, as methods having redundancy among methods. By merging these three methods into one as, for example, method ABC, the number of methods can be reduced to 1/3. For method-specific parts that cannot be shared, method-specific processing can be separated by passing method-specific information to the merged method as an argument.

  Specifically, for example, the compiling device 100 generates an intermediate language I code for processing that is common among methods of duplicate method candidates, and also generates an intermediate language I code for processing unique to each method of the duplicate method candidates. . Then, the compiling device 100 generates the intermediate language I code of the method body in which the duplicate method candidates are merged by merging the generated intermediate language I code.

  (6) The compiling device 100 generates intermediate language II code that is an interface in the compiler based on the merged intermediate language I code of the method body in the syntax / semantic analysis section. Specifically, for example, the compiling device 100 converts a method expressed by an intermediate language I code (a merged method body and an unmerged method) into an intermediate language II code format. The generated intermediate language II code is input to the optimization section.

  In FIG. 1, the dotted frame in the intermediate language II code input to the optimization section indicates a method that has been deleted because it has been merged. In the example of FIG. 1, there are 12 methods in the intermediate language I code stage of the source program sc, and there are 5 methods in the intermediate language II code stage. The absolute number has been greatly reduced.

  (7) The compiling device 100 performs an optimization process of the intermediate language II code of the source program sc in the optimization section. In the optimization process, for example, a method deemed unnecessary from the intermediate language II code is deleted. In the example of FIG. 1, one method deemed unnecessary is deleted from the intermediate language II code. The intermediate language II code subjected to the optimization process is input to the code generation area.

  (8) The compiling device 100 generates the object file f in the code generation section based on the intermediate language II code on which the optimization process has been performed. The generated object file f is transferred to, for example, a linker, and an execution program is finally generated.

  As described above, according to the compiling device 100 according to the embodiment, in the syntax / semantic analysis section, it is possible to reduce the absolute number of methods by performing effective optimization that matches the characteristics specific to the object-oriented language. . Thereby, since the absolute number of methods can be reduced at the time of input of the optimization section, the processing time required for the optimization process is reduced, and as a result, the compilation time of the source program sc can be shortened. Further, the data size of the object file f can be reduced by reducing the absolute number of methods.

(Example of hardware configuration of compiling device 100)
FIG. 2 is a block diagram illustrating a hardware configuration example of the compiling device 100. 2, the compiling device 100 includes a CPU (Central Processing Unit) 201, a memory 202, a disk drive 203, a disk 204, an I / F (Interface) 205, a display 206, a keyboard 207, and a mouse 208. And having. Each component is connected by a bus 200.

  Here, the CPU 201 governs overall control of the compiling device 100. The memory 202 includes, for example, a ROM (Read Only Memory), a RAM (Random Access Memory), and a flash ROM. Specifically, for example, a flash ROM or ROM stores various programs (for example, a compiled program), and a RAM is used as a work area of the CPU 201. The program stored in the memory 202 is loaded on the CPU 201 to cause the CPU 201 to execute the coded process.

  The disk drive 203 controls reading / writing of data with respect to the disk 204 according to the control of the CPU 201. The disk 204 stores data written under the control of the disk drive 203. Examples of the disk 204 include a magnetic disk and an optical disk.

  The I / F 205 is connected to the network 210 via a communication line, and is connected to another computer via the network 210. The I / F 205 controls an internal interface with the network 210 and controls input / output of data from other computers. For example, a modem or a LAN adapter may be employed as the I / F 205.

  A display 206 displays data such as a document, an image, and function information as well as a cursor, an icon, or a tool box. As the display 206, for example, a CRT (Cathode Ray Tube), a TFT (Thin Film Transistor) liquid crystal display, a plasma display, or the like can be adopted.

  The keyboard 207 includes keys for inputting characters, numbers, various instructions, and the like, and inputs data. The keyboard 207 may be a touch panel type input pad or a numeric keypad. The mouse 208 performs cursor movement, range selection, window movement, size change, and the like.

(Specific example of source program sc)
FIG. 3 is an explanatory diagram showing a specific example of the source program sc. In FIG. 3, a source program 300 is an example of an object-oriented program coded in an object-oriented language.

  In the source program 300, color basic data and processing logic are defined in the base class COLOR on the third line. In line 10, the SetColor method of the base class COLOR is defined. The derived class RED on the 22nd line is a class that inherits the base class COLOR. On the 24th line, as a method of the RED class, it is defined by overriding the SetColor method of the base class COLOR.

(Specific example of intermediate language I code)
FIG. 4 is an explanatory diagram showing a specific example of the intermediate language I code. In FIG. 4, intermediate language I codes 410 and 420 schematically show intermediate language I codes obtained by syntax analysis and semantic analysis of the source program 300 (FIG. 3).

  Specifically, the intermediate language I code 410 is an intermediate language I code that expresses the SetColor method defined on the 10th line in the source program 300. The intermediate language I code 420 is an intermediate language I code that represents the SetColor method defined on the 24th line in the source program 300.

  Here, the intermediate language I code 410 includes data 411 to 414. The data 411 represents the syntax and meaning of the declaration information of the SetColor method of the base class COLOR described in the source program 300. Data 412 to 414 represent the syntax and meaning of sentence information of the SetColor method of the base class COLOR, and include data 415 to 417, respectively. Data 415 to 417 represent the syntax and meaning of the expression information of the SetColor method of the base class COLOR, respectively.

  Further, the intermediate language I code 420 includes data 421 to 424. Data 421 represents the syntax and meaning of the declaration information of the SetColor method of the derived class RED described in the source program 300. Data 422 to 424 represent the syntax and meaning of sentence information of the SetColor method of the derived class RED, and include data 425 to 427, respectively. Data 425 to 427 represent the syntax and meaning of the expression information of the SetColor method of the derived class RED.

  The SetColor method uses an override (redefinition) of an object-oriented language, and the SetColor method of the derived class RED overrides the SetColor method of the base class COLOR. Therefore, the two SetColor methods can be said to be methods that may have redundancy in terms of execution between methods.

(Functional configuration example of the compiling device 100)
FIG. 5 is a block diagram illustrating a functional configuration example of the compiling device 100. 5, the compiling apparatus 100 includes an acquisition unit 501, an analysis unit 502, an extraction unit 503, a generation unit 504, a determination unit 505, a merge processing unit 506, an optimization unit 507, and a code generation unit 508. And an output unit 509. The acquisition unit 501 to the output unit 509 are functions serving as a control unit. Specifically, for example, by causing the CPU 201 to execute a program stored in a storage device such as the memory 202 and the disk 204 illustrated in FIG. Alternatively, the function is realized by the I / F 205. The processing result of each functional unit is stored in a storage device such as the memory 202 and the disk 204, for example.

  The acquisition unit 501 acquires the source program sc. The source program sc includes source code coded in an object-oriented language such as Java or C ++. For example, the source program sc may include source code coded in Fortran or C language.

  Specifically, for example, the acquisition unit 501 acquires the source program sc (for example, the source program 300) by a user operation input using the keyboard 207 or the mouse 208. For example, the acquisition unit 501 may acquire the source program sc from an external computer by the I / F 205.

  The analysis unit 502 performs syntax analysis and semantic analysis of the source program sc. Specifically, for example, the analysis unit 502 first performs lexical analysis of the source program sc. Lexical analysis is the conversion of a sequence of characters that make up the source program sc, for example, a sequence of tokens such as keywords, variables, and operators.

  Then, the analysis unit 502 performs syntax analysis and semantic analysis of the source program sc by analyzing the relationship between tokens with respect to the token sequence obtained by the lexical analysis. Thereby, for example, an intermediate language I code which is an interface in the syntax / semantic analysis section as shown in FIG. 4 can be obtained.

  In the intermediate language I code, for example, the base class and the derived class are expressed like a tree structure, and the parent-child relationship between classes can be specified. In addition, each class and the methods belonging to each class are also expressed in a tree structure, and it is a structure that can specify which method belongs to which class.

  The extraction unit 503 extracts duplicate method candidates from a plurality of methods in the intermediate language I code obtained by syntax analysis and semantic analysis of the source program sc. Here, as described above, the duplicate method candidates are a plurality of merge candidate methods that are candidates for execution redundancy between methods, and are, for example, methods that are overridden or overloaded.

  Specifically, for example, the extraction unit 503 refers to the generated intermediate language I code and extracts a combination of methods having the same name between classes having a parent-child relationship as duplicate method candidates. Thereby, the overridden method can be extracted as a duplicate method candidate.

  Taking the source program 300 shown in FIG. 3 as an example, the base class COLOR and the derived class RED are classes having a parent-child relationship. For this reason, the extraction unit 503 refers to the intermediate language I code of the source program 300 (intermediate language I code including the intermediate language I codes 410 and 420 shown in FIG. 4), and determines the base class COLOR and the derived class RED. The SetColor method having the same method name is extracted as a duplicate method candidate.

  In addition, the extraction unit 503 refers to the generated intermediate language I code, for example, duplicates a combination of methods having the same name among methods in the same class or methods not belonging to any class. You may decide to extract as a candidate. As a result, the overloaded method can be extracted as a duplicate method candidate.

  Further, the extraction unit 503 refers to the generated intermediate language I code, for example, and combines the operators of the same name among the operators in the same class or the operators not belonging to any class May be extracted as a duplicate method candidate. Thereby, an overloaded operator (overloaded operator) can be extracted as a duplicate method candidate.

  The overloaded operator (overloaded operator) is an operator having the same name (method name) and different at least one of argument type, number, and arrangement order.

  The generation unit 504 generates correspondence information 110 between methods of duplicate method candidates based on the processing logic specified by the intermediate language I code of each of the extracted duplicate method candidates. Specifically, for example, the generation unit 504 extracts an intermediate language I code corresponding to each duplicate method candidate from the intermediate language I code of the source program sc.

  Next, the generation unit 504 compares data between methods for each data of declaration, sentence, and expression in the extracted intermediate language I code. The intermediate language I code has a declaration / sentence / expression structure formed in the order described in the source program sc. Therefore, the generation unit 504 sequentially compares data between methods according to the structure of the intermediate language I code.

  Note that the expression data in the intermediate language I is included in the sentence data. For this reason, when comparing the sentence data including the expression data, the expression data included in the sentence data is compared. If the expression data is different, the sentence data is also different. .

  Then, based on the comparison result for each data, the generation unit 504 generates a portion that is semantically identical between methods and a portion that is semantically different between methods (specific to each method). Information for identifying (part) is generated as correspondence information 110. Note that a comparative example of data between methods and a generation example of the correspondence information 110 will be described later with reference to FIGS.

  Based on the generated correspondence information 110, the determination unit 505 determines whether or not there is redundancy in terms of execution between methods of the duplicate method candidate. Specifically, for example, the determination unit 505 determines whether or not at least one of the declaration, sentence, and expression data in the intermediate language I code is semantically identical between duplicate method candidate methods. It may be determined that there is redundancy in terms of execution.

  Further, for example, the determination unit 505 executes between duplicate method candidate methods when data of a predetermined number X or more among the data of declarations, sentences, and expressions in the intermediate language I code is semantically identical. It may be determined that there is redundancy in terms. Here, the predetermined number X may be arbitrarily set in advance and stored in a storage device such as the memory 202 or the disk 204, for example.

  Further, as the predetermined number X, a value obtained by multiplying the total number of data of declarations / sentences / expressions in the intermediate language I code corresponding to any one of the duplicate method candidates by the ratio r may be set. The ratio r is a value of 1 or less. The larger the ratio r, the stricter the criteria for determining redundancy in terms of execution between methods.

  The merge processing unit 506 performs merge processing of duplicate method candidates determined to have redundancy in terms of execution among methods based on the correspondence relationship information 110. Specifically, for example, the merge processing unit 506 scans the duplicate method while scanning the intermediate language I code of each method of duplicate method candidates having redundancy in terms of execution among the methods based on the correspondence relationship information 110. An intermediate language I code of the method body in which candidates are merged is generated.

  More specifically, for example, the merge processing unit 506 generates an intermediate language I code for processing that is common among duplicate method candidate methods based on the correspondence relationship information 110. A process common among methods is specified from, for example, data of a portion that is semantically identical between methods.

  Further, the merge processing unit 506 generates an intermediate language I code for processing unique to each method of the duplicate method candidate based on the correspondence relationship information 110. The processing unique to each method is specified, for example, from data of portions that are semantically different between methods. Then, the merge processing unit 506 generates an intermediate language I code of a method body obtained by merging duplicate method candidates by merging the generated intermediate language I code.

  The intermediate language I code of the method body obtained by merging duplicate method candidates can specify the class to which each method of the merge source belongs in order to specify the method to be called by the call source. An example of the merge processing of duplicate method candidates will be described later with reference to FIGS.

  Further, the merge processing unit 506 generates an intermediate language II code of the source program sc that is an interface in the compiler (compile program), based on the intermediate language I code of the method body obtained by merging the duplicate method candidates. Specifically, for example, the merge processing unit 506 converts the method expressed in the intermediate language I code (the merged method body and the unmerged method) into the intermediate language II code format.

  Thus, it is possible to generate an intermediate language II code whose absolute number is reduced by the number of merged methods among a plurality of methods in the intermediate language I code of the source program sc. The intermediate language II code has a structure in which the merged method body can be referred from the caller of each merged method.

  The optimization unit 507 performs optimization processing on the intermediate language II code of the generated source program sc. Specifically, for example, the optimization unit 507 deletes a method that is not called from anywhere as an unnecessary method from the intermediate language II code of the source program. As a result, the method that is not used among a plurality of methods in the intermediate language II code can be deleted to reduce the absolute number of methods.

  The code generation unit 508 generates an object file f of the source program sc based on the intermediate language II code of the optimized source program sc. Specifically, for example, the code generation unit 508 generates the object file f of the source program sc by converting the optimized intermediate language II code into a sequence of machine language instructions.

  The output unit 509 outputs the generated object file f of the source program sc. Specifically, for example, the output unit 509 outputs the object file f of the source program sc to a program called a linker. Here, the linker is a program that analyzes the object file f, adds a necessary library, etc., and generates an execution file. Thereby, an execution file of the source program sc can be obtained.

  In the above description, a case where a combination of methods having the same method name is extracted as a duplicate method candidate has been described as an example. However, even if the method names are different, the methods have redundancy in terms of execution. There is a case. However, judging the redundancy of the execution surface for all the combinations of methods having different method names leads to an increase in processing time.

  For example, methods that have a parent-child relationship between classes tend to have more parts with common processing logic between methods than other methods. For this reason, when determining redundancy in terms of execution between methods having different method names, the extraction unit 503 may extract a combination of methods between classes having a parent-child relationship as a duplicate method candidate. .

(Example of data comparison between methods)
Next, taking the intermediate language I codes 410 and 420 shown in FIG. 4 as an example, a comparative example of data between methods of duplicate method candidates will be described.

  6 to 9 are explanatory diagrams illustrating comparative examples of data between methods of duplicate method candidates. In FIG. 6, the generation unit 504 first selects parameter data 411 from the intermediate language I code 410. Next, the generation unit 504 selects Parameter data 421 of the same type as the data 411 from the intermediate language I code 420.

  Then, the generation unit 504 compares the selected parameter data 411 and 421 with each other. Here, the types, number, and arrangement order of arguments (provisional arguments) are different between the data 411 and 421. For this reason, the generation unit 504 determines that the data 411 and 421 are semantically different, and generates information that identifies portions that are semantically different between methods as the correspondence information 110. In the example of FIG. 6, information for identifying a portion that is semantically different between methods is expressed by adding a check symbol. That is, the check symbol given in the intermediate language I code corresponds to the correspondence information 110.

  In FIG. 7, the generation unit 504 first selects Statement data 412 from the intermediate language I code 410. Next, the generation unit 504 selects, from the intermediate language I code 420, Statement data 422 of the same type as the data 412. Then, the generation unit 504 compares the data 415 and 425 of the operator (expression) included in the data 412 and 422 of the selected statement.

  Here, the expressions represented by the data 415 and 425 are the same. For this reason, the generation unit 504 determines that the data 412 and 422 are semantically identical, and generates information that identifies a portion that is semantically identical between methods as the correspondence information 110. In the example of FIG. 7, information for identifying a portion that is semantically identical between methods is expressed by not adding a check symbol.

  In FIG. 8, the generation unit 504 first selects Statement data 413 from the intermediate language I code 410. Next, the generation unit 504 selects the same type of Statement data 423 as the data 413 from the intermediate language I code 420. Then, the generation unit 504 compares the operator data 416 and 426 included in the selected statement data 413 and 423, respectively.

  Here, some of the expressions represented by the data 416 and 426 are different. For this reason, the generation unit 504 determines that the data 413 and 423 are semantically different, and generates information for identifying a portion that is semantically different between methods as the correspondence information 110. In the example of FIG. 8, information for identifying portions that are semantically different between methods is expressed by adding a check symbol.

  In FIG. 9, the generation unit 504 first selects Statement data 414 from the intermediate language I code 410. Next, the generation unit 504 selects, from the intermediate language I code 420, Statement data 424 of the same type as the data 414. Then, the generation unit 504 compares the operator data 417 and 427 included in the selected statement data 414 and 424, respectively.

  Here, the expressions represented by the data 417 and 427 are the same. For this reason, the generation unit 504 determines that the data 414 and 424 are semantically identical, and generates information that identifies a portion that is semantically identical between methods as the correspondence information 110. In the example of FIG. 9, information for identifying a portion that is semantically identical between methods is expressed by not adding a check symbol.

(Duplicate method candidate merge processing example)
Next, an example of merge processing of duplicate method candidates will be described with the SetColor method having the same method name between the base class COLOR and the derived class RED in the source program 300 as a duplicate method candidate. First, an image of the merge process of the SetColor method will be described using the source program 300. FIG.

  FIG. 10 is an explanatory diagram showing merge processing of the SetColor method. In FIG. 10, a code 1001 on the 10th to 14th lines in the source program 300 is a description related to the SetColor method of the base class COLOR. Further, the code 1002 on the 24th to 29th lines in the source program 300 is a description related to the SetColor method of the derived class RED.

  The merge processing unit 506 merges the intermediate language I code corresponding to the code 1001 and the intermediate language I code corresponding to the code 1002 to generate an intermediate language I code as shown by the image 1010. Here, when comparing the code 1001 and the code 1002, the arguments on the 10th and 24th lines and the expressions on the 12th and 26th lines are unique to each SetColor method.

  For this reason, the merge processing unit 506, like codes 1011 to 1015 in the image 1010, processes intermediate language I code common to the SetColor methods of the base class COLOR and the derived class RED, and processes unique to each SetColor method Intermediate language I code is generated.

  The code 1011 is for selecting which of the base class COLOR and the derived class RED performs processing according to the SetColor method, and information given as a first argument from the caller is defined. Code 1012 represents an argument of the SetColor method.

  Codes 1013 and 1015 correspond to an intermediate language I code of processing common between the SetColor method of the base class COLOR and the derived class RED. On the other hand, the code 1014 corresponds to an intermediate language I code of processing unique to each SetColor method of the base class COLOR and the derived class RED. The code 1014 includes a determination statement (if) for determining which SetColor method of the base class COLOR and the derived class RED.

  The 36th line in the source program 300 is a description for calling the SetColor method of the base class COLOR. The 37th line in the source program 300 is a description for calling the SetColor method of the derived class RED. Therefore, the merge processing unit 506 generates an intermediate language I code such as the image 1020 in order to call the SetColor method of the base class COLOR or the derived class RED.

  Here, the intermediate language I code corresponding to the image 1010 will be described.

  FIG. 11 is an explanatory diagram showing an example of the intermediate language I code of the method body obtained by merging the SetColor method. In FIG. 11, the intermediate language I code 1100 schematically shows the intermediate language I code of the method body obtained by merging the SetColor method of the base class COLOR and the SetColor method of the derived class RED, as shown in FIG. Corresponds to image 1010.

  In the intermediate language I code 1100, the data 1101 is an intermediate language I code for selecting which of the base class COLOR and the derived class RED should be processed according to the SetColor method. Data 1101 corresponds to the code 1011 in the image 1010 shown in FIG.

  Data 1102 is an intermediate language I code representing an argument of the SetColor method. Data 1102 corresponds to code 1012 in image 1010. Data 1103 is an intermediate language I code of processing common between the SetColor method of the base class COLOR and the derived class RED. Data 1103 corresponds to the code 1013 in the image 1010.

  Data 1104 is an intermediate language I code of processing unique to each SetColor method. Data 1104 corresponds to code 1014 in image 1010. Data 1105 is an intermediate language I code for processing common to the SetColor methods. Data 1105 corresponds to code 1015 in image 1010.

(Example source program that does not merge duplicate method candidates)
Next, the source program sc in the case where duplicate method candidates are not merged will be described. Here, a case where an overloaded method is extracted as a duplicate method candidate will be described as an example.

  FIG. 12 is an explanatory diagram of an example of a source program that does not merge duplicate method candidates. In FIG. 12, a source program 1200 is an example of an object-oriented program coded in an object-oriented language.

  In the fourth line of the source program 1200, a print method is defined. Also, in the 9th line of the source program 1200, a print method having the same name as the print method in the 4th line is defined. That is, the print method is overloaded.

  The code 1201 from the 4th line to the 6th line in the source program 1200 describes the print method on the 4th line. Also, the code 1202 from the 9th line to the 22nd line in the source program 1200 is a description relating to the print method in the 9th line. Here, when comparing the code 1201 and the code 1202, there is no portion that is semantically identical between methods other than the method name.

  In this way, when there are few parts that are semantically identical between methods and the execution redundancy between methods is low, even if the print method is merged to reduce the absolute number of methods, the source program The compile time of sc cannot be shortened. For this reason, the compiling apparatus 100 does not consider a method such as the print method in the source program 1200 as a merge target.

(Compile processing procedure of the compiling device 100)
Next, a compiling process procedure of the compiling apparatus 100 will be described.

  FIG. 13 is a flowchart illustrating an example of a compile processing procedure of the compile device 100. In the flowchart of FIG. 13, the compiling device 100 first reads the source program sc (step S1301).

  Next, the compiling device 100 performs lexical analysis of the source program sc (step S1302). Then, the compiling device 100 performs syntax analysis and semantic analysis of the source program sc by analyzing the relationship between tokens in the token sequence obtained by the lexical analysis (step S1303).

  Next, the compiling device 100 performs a duplicate method candidate extraction process for extracting duplicate method candidates from a plurality of methods in the intermediate language I code obtained by the syntax analysis and semantic analysis of the source program sc (step S1304). The specific processing content of the duplicate method candidate extraction processing will be described later with reference to FIG.

  Next, the compiling device 100 selects an unselected duplicate method candidate from the extracted duplicate method candidates (step S1305). Then, the compiling device 100 performs correspondence information generation processing for generating correspondence information 110 between methods of duplicate method candidates (step S1306). A specific processing procedure of the correspondence relationship information generation processing will be described later with reference to FIG.

  Next, the compiling device 100 determines whether or not there is redundancy in terms of execution between the methods of the duplicate method candidates based on the generated correspondence information of the duplicate method candidates (step S1307). If it is determined that there is no redundancy in terms of execution (step S1307: No), the compiling device 100 proceeds to step S1309.

  On the other hand, if it is determined that there is redundancy in terms of execution (step S1307: Yes), the compiling device 100 performs a merge process for generating an intermediate language I code of a method body in which duplicate method candidates are merged (step S1308). . A specific processing procedure of the merge processing will be described later with reference to FIG.

  Next, the compiling device 100 determines whether or not there is an unselected duplicate method candidate among the extracted duplicate method candidates (step S1309). If there is an unselected duplicate method candidate (step S1309: YES), the compiling device 100 returns to step S1305.

  On the other hand, if there is no unselected duplicate method candidate (step S1309: No), the compiling device 100 determines the intermediate language I code of the method body in which the duplicate method candidates are merged and the intermediate language I code of the method that has not been merged. Based on the above, an intermediate language II code of the source program sc is generated (step S1310).

  Then, the compiling device 100 performs an optimization process of the intermediate language II code of the generated source program sc (step S1311). Next, the compiling device 100 generates an object file f of the source program sc based on the intermediate language II code of the optimized source program sc (step S1312).

  Then, the compiling device 100 outputs the generated object file f of the source program sc (step S1313), and ends the series of processing according to this flowchart.

  As a result, in the syntax / semantic analysis section of the compiler, multiple methods with redundancy in terms of execution among methods can be merged into one method, and the absolute number of methods is reduced when the optimization section is input. can do.

<Duplicate method candidate extraction procedure>
Next, a specific processing procedure of the duplicate method candidate extraction process in step S1304 shown in FIG. 13 will be described.

  FIG. 14 is a flowchart illustrating an example of a specific processing procedure of the duplicate method candidate extraction processing. In the flowchart of FIG. 14, first, the compiling device 100 refers to the intermediate language I code of the source program sc and determines whether or not a method having the same name exists between classes having a parent-child relationship (step S1401). .

  If a method having the same name exists between classes having a parent-child relationship (step S1401: Yes), the compiling device 100 extracts a combination of methods having the same name between classes having a parent-child relationship as duplicate method candidates. (Step S1402). Then, the compiling device 100 returns to step S1401.

  On the other hand, when a method with the same name does not exist between classes having a parent-child relationship (step S1401: No), the compiling device 100 refers to the intermediate language I code of the source program sc, and the method or overloaded operation with the same name. It is determined whether or not a child exists (step S1403).

  If a method or overloaded operator with the same name exists (step S1403: Yes), the compiling apparatus 100 extracts a method or overloaded operator combination with the same name as a duplicate method candidate (step S1404). . Then, the compiling device 100 returns to step S1403.

  On the other hand, when there is no method or overloaded operator with the same name (step S1403: No), the compiling device 100 returns to the step that called the duplicate method candidate extraction process. Thereby, an overloaded method or an overloaded method can be extracted as a duplicate method candidate that is a candidate having redundancy in terms of execution among methods.

<Correspondence information generation processing procedure>
Next, a specific processing procedure of the correspondence relationship information generation processing in step S1306 shown in FIG. 13 will be described.

  FIG. 15 is a flowchart illustrating an example of a specific processing procedure of the correspondence relationship information generation processing. In the flowchart of FIG. 15, first, the compiling device 100 extracts intermediate language I code corresponding to each duplicate method candidate from the intermediate language I code of the source program sc (step S1501).

  Next, the compiling device 100 refers to the extracted intermediate language I code, and sequentially compares the data of the declaration / sentence / expression between the methods of the duplicate method candidate (step S1502). Then, the compiling device 100 determines whether or not there is a part that is semantically different between methods in the extracted intermediate language I code based on the comparison result (step S1503).

  Here, when there is a portion that is semantically different between methods (step S1503: Yes), the compiling device 100 marks a portion that is semantically different between methods in the extracted intermediate language I code (step S1504). . Then, the compiling device 100 returns to the step that called the correspondence information generation process. The marking corresponds to, for example, a check symbol as shown in FIG.

  On the other hand, if there is no semantically different portion between the methods (step S1503: No), the compiling device 100 returns to the step that called the correspondence relationship information generation process. Thus, the correspondence relationship information 110 for identifying a portion that is semantically identical between methods and a portion that is semantically different between methods in the intermediate language I code corresponding to each of the duplicate method candidates can be generated. it can.

<Merge processing procedure>
Next, a specific processing procedure of the merge processing in step S1308 shown in FIG. 13 will be described.

  FIG. 16 is a flowchart illustrating an example of a specific processing procedure of the merge processing. In the flowchart of FIG. 16, the compiling device 100 first selects declaration / sentence / expression data from the intermediate language I code of the duplicate method candidate (step S1601). At this time, if the selected data and the data compared in step S1502 shown in FIG. 15 exist, the compiling device 100 also selects the data.

  Next, the compiling device 100 determines whether or not the selected data has a marking (step S1602). Here, when there is marking (step S1602: Yes), the compiling device 100 generates an intermediate language I code for the process-specific processing of the duplicate method candidate based on the selected data (step S1603).

  The compiling device 100 determines whether there is unselected data that is not selected from the intermediate language I code of the duplicate method candidate (step S1604). If there is unselected data (step S1604: YES), the compiling device 100 returns to step S1601.

  If there is no marking in step S1602 (step S1602: No), the compiling device 100 generates an intermediate language I code for processing common to duplicate method candidates based on the selected data (step S1605). The process proceeds to step S1604.

  In step S1604, if there is no unselected data (step S1604: No), the compiling device 100 merges the generated intermediate language I codes of the respective processes, so that the intermediate method body into which the duplicate method candidates are merged is merged. A language I code is generated (step S1606), and the process returns to the step that called the merge process.

  As a result, it is possible to generate an intermediate language I code of a method body obtained by merging duplicate method candidates having redundancy in terms of execution among methods. Note that the intermediate language I code of the method body into which the duplicate method candidates are merged includes data for selecting which of the merged methods is to be processed (for example, data 1101 shown in FIG. 11). . In step S1606, an intermediate language I code for calling one of the merged methods is also generated.

  As described above, according to the compiling apparatus 100 according to the embodiment, the redundancy in terms of execution among methods from a plurality of methods in the intermediate language I code obtained by the syntax analysis and semantic analysis of the source program sc. Can be extracted. As a result, in the syntax / semantic analysis section where the linguistic characteristics of the object-oriented language can be determined, a plurality of methods that may have the same data and processing logic can be extracted as duplicate method candidates.

  For example, the compiling apparatus 100 may extract a combination of methods having the same name between classes having a parent-child relationship from the method group in the intermediate language I code of the source program sc as a duplicate method candidate. As a result, overridden methods that may have redundancy in terms of execution among methods can be extracted as duplicate method candidates.

  For example, the compiling device 100 duplicates a combination of methods having the same name among methods in the same class or methods not belonging to any class from the method group in the intermediate language I code of the source program sc. You may extract as a candidate. As a result, overloaded methods that may have execution redundancy between methods can be extracted as duplicate method candidates.

  For example, the compiling device 100 selects a combination of operators having the same name among operators in the same class or operators not belonging to any class from the method group in the intermediate language I code of the source program sc. May be extracted as a duplicate method candidate. As a result, overloaded overloaded operators that may have execution redundancy between methods (operators) can be extracted as duplicate method candidates.

  Further, the compiling device 100 can generate correspondence information 110 between methods of duplicate method candidates based on the processing logic specified by the intermediate language I code of each extracted duplicate method candidate. Thereby, it is possible to generate the correspondence information 110 for determining whether or not there is redundancy in terms of execution between methods of duplicate method candidates.

  For example, the compiling device 100 compares data between methods for each data of declaration, sentence, and expression in the intermediate language I code of each duplicate method candidate. Then, the compiling device 100 identifies a portion that is semantically identical between the methods and a portion that is semantically different between the methods in the intermediate language I code of each of the duplicate method candidates based on the comparison result. The correspondence information 110 may be generated. This makes it possible to identify a portion that is semantically identical between duplicate method candidate methods and a portion that is semantically different between methods.

  Also, the compiling device 100 determines whether or not there is redundancy in terms of execution between methods of duplicate method candidates based on the generated correspondence relationship information 110, and redundancy in terms of execution between methods. It is possible to perform merge processing of duplicate method candidates having As a result, a plurality of methods having redundancy in terms of execution among methods can be merged into one method, and the absolute number of methods can be reduced at the stage of syntax / semantic analysis.

  For example, the compiling device 100 executes between methods when at least one of declaration, sentence, and expression data in the intermediate language I code of each duplicate method candidate is semantically identical between methods. It may be determined that there is redundancy in terms. As a result, duplicate method candidates that have portions that are semantically identical between methods can be merged, and effective merge processing can be performed.

  For example, the compiling device 100 executes the execution surface between methods when data of a predetermined number X or more among the data of declarations, sentences, and expressions in the intermediate language I code of each of the duplicate method candidates is semantically identical. It may be determined that there is redundancy in. As a result, duplicate method candidates that have many portions that are semantically identical between methods can be merged, and more effective merge processing can be performed.

  Thus, according to the compiling apparatus 100, the absolute number of methods can be reduced at the time of input of the optimization section, the compilation time of the source program sc can be shortened, and the data size of the object file f can be reduced. Can be reduced. Further, the compiling device 100 can narrow down duplicate method candidates that may have redundancy in terms of execution among methods from the linguistic characteristics of the object-oriented language, and therefore, a plurality of methods to be merged can be selected. The discrimination can be performed efficiently and effectively.

  Thereby, the development speed of software development can be improved. Further, by reducing the data size of the object file f, the load time of the program at the time of execution is shortened, and resource savings of the computer system (for example, CPU load, memory capacity, disk capacity, network load, etc.) are achieved. be able to.

  The compiling method described in the present embodiment can be realized by executing a program prepared in advance on a computer such as a personal computer or a workstation. The compile program is recorded on a computer-readable recording medium such as a hard disk, a flexible disk, a CD-ROM, an MO, and a DVD, and is executed by being read from the recording medium by the computer. Further, the compiled program may be distributed via a network such as the Internet.

  The following additional notes are disclosed with respect to the embodiment described above.

(Supplementary note 1)
Extracting multiple merge candidate methods based on at least the inheritance relationship or name from multiple methods in the intermediate language code obtained by parsing and semantic analysis of the source program,
Based on the processing logic specified by the intermediate language code of each of the plurality of merge candidate methods, extract a plurality of mergeable methods that can be merged from the plurality of merge candidate methods,
Performing a merge process of the plurality of mergeable methods,
A compiling method characterized by executing processing.

(Appendix 2) The computer
Based on the processing logic specified by the intermediate language code of each of the plurality of merge candidate methods, execute processing for generating correspondence information between methods of the plurality of merge candidate methods,
The process of extracting the plurality of mergeable methods includes:
The compiling method according to appendix 1, wherein a plurality of mergeable methods are extracted from the plurality of merge candidate methods based on the correspondence information.

(Supplementary Note 3) The process of extracting the plurality of merge candidate methods is as follows:
3. The compiling method according to appendix 1 or 2, wherein a combination of methods having the same name between classes having a parent-child relationship is extracted as the plurality of merge candidate methods from a plurality of methods in the intermediate language code.

(Supplementary Note 4) The process of extracting the plurality of merge candidate methods is as follows:
A combination of methods having the same name among methods in the same class or methods not belonging to any class is extracted as a plurality of merge candidate methods from a plurality of methods in the intermediate language code. The compiling method according to any one of appendices 1 to 3.

(Supplementary Note 5) The process of extracting the plurality of merge candidate methods is as follows:
From a plurality of methods in the intermediate language code, a combination of operators having the same name among operators in the same class or operators not belonging to any class is extracted as the plurality of merge candidate methods. The compiling method according to any one of appendices 1 to 4, characterized in that:

(Appendix 6) The computer
For each data of declaration, sentence, and expression in the intermediate language code of each of the plurality of merge candidate methods, execute processing for comparing data between the methods of the plurality of merge candidate methods,
The process to generate is
Corresponding to identifying a portion that is semantically identical between the methods and a portion that is semantically different between the methods, among the intermediate language codes of each of the plurality of merge candidate methods based on the comparison result for each data The compiling method according to appendix 2, wherein the relation information is generated.

(Supplementary Note 7) The process of extracting the plurality of mergeable methods is as follows:
With reference to the correspondence information, the plurality of merge candidates in which at least one of data of declaration, sentence, and expression in the intermediate language code of each of the plurality of merge candidate methods is semantically identical The compiling method according to appendix 6, wherein a method is extracted as the plurality of mergeable methods.

(Supplementary Note 8) The process of extracting the plurality of mergeable methods is as follows:
With reference to the correspondence information, the plurality of merge candidates in which a predetermined number or more of the data of declarations, sentences, and expressions in the intermediate language code of each of the plurality of merge candidate methods is semantically identical The compiling method according to appendix 6, wherein a method is extracted as the plurality of mergeable methods.

(Supplementary Note 9) The process of performing the merge process is as follows:
Based on the correspondence information, the intermediate language code of processing common among the methods of the plurality of mergeable methods and the intermediate language code of processing unique to each method of the plurality of mergeable methods are merged, The compiling method according to appendix 2, wherein merge processing of the plurality of mergeable methods is performed by generating an intermediate language code of a method body obtained by merging the plurality of mergeable methods.

(Supplementary note 10) The compiling method according to any one of supplementary notes 1 to 9, wherein the source program is a program coded in an object-oriented language.

(Supplementary Note 11) A plurality of merge candidate methods are extracted from a plurality of methods in an intermediate language code obtained by syntax analysis and semantic analysis of a source program based on at least an inheritance relationship or a name, and the plurality of merge candidate methods A control unit that extracts a plurality of mergeable methods that can be merged from the plurality of merge candidate methods based on the processing logic specified by each intermediate language code, and performs a merge process of the plurality of mergeable methods;
A compiling device characterized by comprising:

(Supplementary note 12)
Extracting multiple merge candidate methods based on at least the inheritance relationship or name from multiple methods in the intermediate language code obtained by parsing and semantic analysis of the source program,
Based on the processing logic specified by the intermediate language code of each of the plurality of merge candidate methods, extract a plurality of mergeable methods that can be merged from the plurality of merge candidate methods,
Performing a merge process of the plurality of mergeable methods,
A compiled program characterized by causing processing to be executed.

(Supplementary note 13)
Extracting multiple merge candidate methods based on at least the inheritance relationship or name from multiple methods in the intermediate language code obtained by parsing and semantic analysis of the source program,
Based on the processing logic specified by the intermediate language code of each of the plurality of merge candidate methods, extract a plurality of mergeable methods that can be merged from the plurality of merge candidate methods,
Performing a merge process of the plurality of mergeable methods,
A computer-readable recording medium in which a compilation program for executing processing is recorded.

DESCRIPTION OF SYMBOLS 100 Compile apparatus 501 Acquisition part 502 Analysis part 503 Extraction part 504 Generation part 505 Determination part 506 Merge processing part 507 Optimization part 508 Code generation part 509 Output part

Claims (10)

Computer
Extracting multiple merge candidate methods based on at least the inheritance relationship or name from multiple methods in the intermediate language code obtained by parsing and semantic analysis of the source program,
Based on the processing logic specified by the intermediate language code of each of the plurality of merge candidate methods, extract a plurality of mergeable methods that can be merged from the plurality of merge candidate methods,
Performing a merge process of the plurality of mergeable methods,
A compiling method characterized by executing processing. The computer is
Based on the processing logic specified by the intermediate language code of each of the plurality of merge candidate methods, execute processing for generating correspondence information between methods of the plurality of merge candidate methods,
The process of extracting the plurality of mergeable methods includes:
The compiling method according to claim 1, wherein a plurality of mergeable methods are extracted from the plurality of merge candidate methods based on the correspondence information. The process of extracting the plurality of merge candidate methods is as follows:
3. The compiling method according to claim 1, wherein a combination of methods having the same name between classes having a parent-child relationship is extracted as the plurality of merge candidate methods from a plurality of methods in the intermediate language code. The process of extracting the plurality of merge candidate methods is as follows:
A combination of methods having the same name among methods in the same class or methods not belonging to any class is extracted as a plurality of merge candidate methods from a plurality of methods in the intermediate language code. The compiling method according to any one of claims 1 to 3. The process of extracting the plurality of merge candidate methods is as follows:
From a plurality of methods in the intermediate language code, a combination of operators having the same name among operators in the same class or operators not belonging to any class is extracted as the plurality of merge candidate methods. The compiling method according to any one of claims 1 to 4. The computer is
For each data of declaration, sentence, and expression in the intermediate language code of each of the plurality of merge candidate methods, execute processing for comparing data between the methods of the plurality of merge candidate methods,
The process to generate is
Corresponding to identifying a portion that is semantically identical between the methods and a portion that is semantically different between the methods, among the intermediate language codes of each of the plurality of merge candidate methods based on the comparison result for each data The compiling method according to claim 2, wherein the relation information is generated. The process of extracting the plurality of mergeable methods includes:
With reference to the correspondence information, the plurality of merge candidates in which at least one of data of declaration, sentence, and expression in the intermediate language code of each of the plurality of merge candidate methods is semantically identical The compiling method according to claim 6, wherein a method is extracted as the plurality of mergeable methods.   The compiling method according to claim 1, wherein the source program is a program coded in an object-oriented language. A plurality of merge candidate methods are extracted from a plurality of methods in the intermediate language code obtained by the syntax analysis and semantic analysis of the source program based on at least the inheritance relationship or the name, and the intermediate languages of the plurality of merge candidate methods are extracted. Based on the processing logic specified by the code, a control unit that extracts a plurality of mergeable methods that can be merged from the plurality of merge candidate methods, and performs a merge process of the plurality of mergeable methods;
A compiling device characterized by comprising: On the computer,
Extracting multiple merge candidate methods based on at least the inheritance relationship or name from multiple methods in the intermediate language code obtained by parsing and semantic analysis of the source program,
Based on the processing logic specified by the intermediate language code of each of the plurality of merge candidate methods, extract a plurality of mergeable methods that can be merged from the plurality of merge candidate methods,
Performing a merge process of the plurality of mergeable methods,
A compiled program characterized by causing processing to be executed.

Images