JP2013210920A - Compilation device, compilation method, and compiler - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a compilation device in which a time spent for optimization is reduced.SOLUTION: A compilation device according to the present invention is a compilation device 9 for performing compilation by converting a first source code including a plurality of sentences each including a command and an operand written therein into an intermediate code, and further converting it into a second source code, which is a language lower than the first source code. The compilation device includes: a similar sentence detection part 91 which detects similar sentences, which are sentences that become the same as each other in command and operand in intermediate codes thereof; and a code conversion part 92 which, in the intermediate code, converts, when the intermediate code is converted to the second source code, a code corresponding to the similar sentence detected by the similar sentence detection part 91 as a code for calling a common function that executes a command in the similar sentence with an operand of the similar sentence employed as an argument.

Description

  The present invention relates to a compiling device, a compiling method, and a compiler, and more particularly to a technique for compiling by converting source code into source code in a language lower than that.

  When generating machine language code by translating source code, optimization is performed in order to minimize execution time, memory usage, and the like when executing the machine language code to be finally generated (for example, Patent Document 1).

  Here, if there are a plurality of similar codes in the source code written by the user, the code size of the source code will increase accordingly. When the code size is large, the amount of data to be optimized becomes large, and there is a problem that the time required for optimization increases.

JP 2010-49315 A

  As described above, when there are a plurality of codes similar to the source code and the code size is large, there is a problem that the time required for optimization increases.

  An object of the present invention is to provide a compiling device, a compiling method, and a compiler that can reduce the time required for optimization in order to solve the above-described problems.

  The compiling device according to the first aspect of the present invention converts a first source code including a plurality of sentences each including an instruction and an operand into intermediate code, and further converts the first source code from the first source code. A compiling device that compiles by converting to a second source code in a low-level language, and detects a similar sentence that is a sentence in which the instructions and the operands have the same format in the intermediate code When the detection unit converts the intermediate code into the second source code, the code corresponding to the similar sentence detected by the similar sentence detection unit in the intermediate code, with the operand of the similar sentence as an argument, A code conversion unit that converts the code to call a common function that executes the instruction of the similar sentence.

The compiling method according to the second aspect of the present invention includes converting a first source code including a plurality of sentences each including an instruction and an operand into intermediate code, and further converting the first source code from the first source code. A compiling method for compiling by converting to a second source code of a low-level language, the step of detecting a similar sentence in the intermediate code, which is a sentence having the same format of the instruction and the operand; When the intermediate code is converted into the second source code, the code corresponding to the detected similar sentence is executed in the intermediate code with the operand of the similar sentence as an argument, and the instruction of the similar sentence is executed. And a step of converting the code to call a common function.

  A compiler according to a third aspect of the present invention converts a first source code including a plurality of statements each including an instruction and an operand into intermediate code and further lower-order than the first source code. A compiler for compiling by converting to a second source code in a different language, wherein the intermediate code detects a similar sentence that is a sentence having the same format of the instruction and the operand; When the intermediate code is converted into the second source code, the code corresponding to the detected similar sentence is executed in the intermediate code with the operand of the similar sentence as an argument, and the instruction of the similar sentence is executed. The process of converting the code to call the common function is executed by a computer.

  According to each aspect described above, in order to solve the above-described problems, it is possible to provide a compiling device, a compiling method, and a compiler that can reduce the time required for optimization.

It is a block diagram which shows the structure of the compilation apparatus concerning embodiment of invention. It is a processing block diagram of CPU concerning embodiment of invention. It is a figure explaining the code sharing unit by the optimization part concerning embodiment of invention. It is a figure which shows the format of the intermediate code information table concerning an embodiment of an invention, a similar code table, and the optimized intermediate code. It is a flowchart which shows the process of the optimization part concerning embodiment of invention. It is a figure which shows an example of the intermediate code information table concerning embodiment of invention. It is a figure which shows an example of the similar code table concerning embodiment of invention. It is a figure which shows an example of the optimized intermediate code concerning embodiment of invention. It is a figure for demonstrating the effect concerning embodiment of invention. It is a block diagram which shows schematic structure of the compilation apparatus concerning embodiment of invention.

<Embodiment of the Invention>
First, the configuration of a compiling device 1 according to an embodiment of the invention will be described with reference to FIG. FIG. 1 is a block diagram showing a configuration of a compiling device 1 according to an embodiment of the invention.

  The compiling device 1 includes a CPU (Central Processing Unit) 10, a memory 11, and a storage unit 12.

  The CPU 10 executes a process of translating the source code (source program) 123 stored in the storage unit 12 into a machine language code (machine language program). Specifically, the CPU 10 loads the compiler 120 stored in the storage unit 12 into the memory 11 and executes it, thereby compiling the source program 123 and generating assembler code. The CPU 10 assembles the assembler code and generates an object code by loading the assembler 121 into the memory 11 and executing it. The CPU 10 loads the linker 122 stored in the storage unit 12 into the memory 11 and executes it, thereby linking the object code and generating a machine language code. The assembler code, object code, and machine language code generated by the CPU 10 are stored in the memory 11 or the storage unit 12.

  In addition, the CPU 10 functions as an expansion unit 100, a code generation unit 101, an optimization unit 102, and an addressing unit 103, as will be described later, by executing the compiler 120.

  The memory 11 stores a program (120 to 122) loaded by the CPU 10 and various data generated by the CPU 10 when the source code 122 is translated. The memory 11 is, for example, a RAM (Random Access Memory).

  The storage unit 12 stores a compiler 120, an assembler 121, a linker 122, and source code 123. The storage unit 12 includes at least one arbitrary storage device for storing these data 120 to 123. The storage device is, for example, a memory and a hard disk. Here, in the present embodiment, a case where the source code 123 is a COBOL source code is illustrated.

  Next, the processing configuration of the CPU 10 according to the embodiment of the invention will be described with reference to FIG. FIG. 2 is a processing configuration diagram of the CPU 10 according to the embodiment of the invention.

  The CPU 10 executes the compiler 120 to perform front-end processing (lexical analysis, syntax analysis, semantic analysis, etc.) and generate a parsed intermediate code from the source code 123.

  The CPU 10 executes the compiler 120 to function as the expansion unit 100, the code generation unit 101, the optimization unit 102, and the addressing unit 103 when processing the back end. The processing in each unit 100 to 103 is processing corresponding to each phase in the back end.

  The expansion unit 100 executes a part of optimization in compilation. As optimization here, for example, deletion of dead code, optimization of loops (combination of a plurality of loops), and the like are performed. The expansion unit 100 generates the object generation intermediate code 1 in which the parsed intermediate code is optimized. The code generation unit 101 generates an object generation intermediate code 2 obtained by converting the object generation intermediate code 1 into a platform-dependent format.

  The optimization unit 102 detects a sentence similar to another sentence by comparing the object generation intermediate code 2 in units of sentences. The optimization unit 102 detects sentences similar to other sentences by comparing the instruction and parameter format of each sentence. The optimization unit 102 detects a sentence similar to another sentence as a target to be replaced with a process for calling a common function that executes a process in the sentence. Then, the optimization unit 102 generates an optimized intermediate code in which information specifying a common function to be called so as to correspond to a sentence in the object generation intermediate code 2 is embedded.

  The addressing unit 103 converts the optimized intermediate code into an assembler code. At this time, based on the information embedded in the optimized intermediate code by the optimization unit 102, the addressing unit 103 executes a process corresponding to a sentence similar to another sentence in each sentence. Convert the code to call the function. As described above, in the present embodiment, codes that are similar to each other are extracted in units of sentences, and the extracted codes are replaced with codes that call common functions, so that excessive object code is not generated.

  Next, with reference to FIG. 3, a code sharing unit by the optimization unit 102 according to the embodiment of the present invention will be described. FIG. 3 is a diagram for explaining a code sharing unit by the optimization unit 102 according to the embodiment of the present invention.

  As shown in FIG. 3, even in the case where “COMPUTE A = A * B + C” is described in the source code 123, each of multiplication (MULTIPLY), addition (ADD), and substitution (MOVE) is performed. Decompose it into statements to be executed and share each statement. That is, the sentence is disassembled up to a decomposable unit and then shared. This disassembly is normally performed in the front end phase.

  In this way, commonization is performed in units of command statements in the language (COBOL) of the source code 123, such as a MULTIPLY statement, an ADD statement, a MOVE statement, a DEVICE statement, and a SUBSTRACT statement.

  Here, as described above, even in a high-level language such as COBOL, even in a low-level language such as an assembly code generated in the process of compilation, a multi-state code It is expressed by Therefore, in the present embodiment, even in the process expressed by one sentence in the source code 123 and its intermediate code, the assembly code has a common function for executing the process in a plurality of sentences corresponding to the one sentence. By replacing it with a call process, it avoids generating excessive object code.

  In this embodiment, the case where the high-level language is COBOL and the lower-level (low-level) language is assembly code is exemplified. However, any combination of other languages is possible as long as the language satisfies this relationship. May be applied.

  Next, with reference to FIG. 4, the format of the intermediate code information table, the similar code table, and the optimized intermediate code according to the embodiment of the present invention will be described with reference to FIG. FIG. 4 is a diagram showing a format of the intermediate code information table, the similar code table, and the optimized intermediate code according to the embodiment of the present invention.

  FIG. 4 shows the respective formats of the intermediate code information table, the similar code table, and the optimized intermediate code generated by the optimization unit 102.

  The intermediate code information table includes a plurality of records corresponding to the sentences included in the object generation intermediate code 2 generated by the code generation unit 101. One record includes a sentence code and parameter attribute information. Parameter attribute information is included for each parameter. The intermediate code information table is generated by the code generation unit 101 based on the object generation intermediate code 2 and stored in the memory 11 or the storage unit 12.

  The sentence code is information that uniquely identifies an instruction (such as MULTIPLY or ADD described above) in the sentence. For example, the code generation unit 101 may generate a value that uniquely identifies an instruction as a statement code, and uses the code uniquely assigned to the instruction included in the object generation intermediate code 2 as the statement code. You may make it do.

  The parameter attribute information is information indicating parameter attributes (type, length, etc.). The parameter attribute information is used to determine whether or not the parameter formats match so that each sentence can be shared as a function. In general, information such as parameter values, types, and lengths in each sentence can be extracted from the intermediate code (object generation intermediate code 2). Therefore, the code generation unit 101 extracts the parameter attribute information from the object generation intermediate code 2 and stores it in the record. Here, when the functions are shared in the assembly code, it is preferable that the types and lengths of the parameters as the arguments match. Therefore, in the present embodiment, a case where a parameter type and length are extracted and compared as parameter attributes is illustrated. Therefore, if the parameter attribute information is information that can be used to determine whether or not the parameter formats match to the extent that each sentence can be shared as a function, the parameter type and length depending on the language to be handled. However, the content may be changed.

  The similar code table includes a record for each kind of sentence similar to each other in the object generation intermediate code 2. Specifically, sentences having the same command and parameter format are treated as the same type of sentence. One record includes a similar code number, a sentence code, and parameter attribute information. The similar code table is generated by the optimization unit 102 and stored in the memory 11 or the storage unit 12.

  The similar code number is information for uniquely specifying the types of sentences similar to each other. The sentence code and the parameter attribute information are as described above. Based on the intermediate code information table, the optimization unit 102 detects sentences having sentence codes and parameter attribute information that match each other as sentences similar to each other. When the optimization unit 102 detects a sentence similar to another sentence and there is no record regarding the type of the sentence in the similar code table, the optimization unit 102 adds a record related to the detected sentence to the similar code table. At this time, the record to be added includes a similar code number indicating the type of the detected sentence, the sentence code of the detected sentence, and parameter attribute information of the detected sentence. The optimization unit 102 generates a number that does not overlap with other similar code numbers included in the similar code table as the similar code numbers included in the record. When the optimization unit 102 detects a sentence similar to another sentence as the sentence code and parameter attribute information included in the record, the optimization unit 102 acquires the sentence code and parameter attribute information of the sentence from the intermediate code information table.

  The optimized intermediate code includes a similar code number and parameter information in one sentence. When the optimization unit 102 detects a sentence similar to another sentence, the optimization unit 102 generates an optimized intermediate code by replacing the sentence code of the detected sentence with a similar code number corresponding to the type of the detected sentence. When the optimization unit 102 does not detect a sentence similar to another sentence, the optimization unit 102 generates an optimized intermediate code while leaving the original sentence code as it is. In the sentence, a similar code number may be added without replacing the sentence code. The optimized intermediate code is generated by the optimization unit 102 and stored in the memory 11 or the storage unit 12.

  The similar code number is as described above. The parameter indicates parameter information in the sentence. As described above, this information includes information such as parameter values, types, and lengths. In this way, the sentence in which the sentence code is replaced with the similar code number is stored in the sentence corresponding to the similar code number when the addressing unit 103 converts the sentence code from the optimized intermediate code to the assembler code. It is converted as a code that calls a common function that executes processing.

  Next, the common processing according to the embodiment of the present invention will be described with reference to FIGS. FIG. 5 is a flowchart showing processing of the optimization unit 102 according to the embodiment of the present invention. FIG. 6 is a diagram showing an example of the intermediate code information table according to the embodiment of the present invention. FIG. 7 is a diagram showing an example of a similar code table according to the embodiment of the present invention. FIG. 8 is a diagram illustrating an example of the optimized intermediate code according to the embodiment of the present invention.

  Here, FIG. 3 exemplifies a case where the object generation intermediate code 2 including the code of six sentences shown as being decomposed is a processing target. Therefore, the code generation unit 101 generates an intermediate code information table for each sentence of the object generation intermediate code 2 as shown in FIG.

  Specifically, as an intermediate code information table, the first sentence record includes a statement code indicating a MULTIPLY instruction, parameter attribute information indicating the type and length of parameter A, and the type and length of parameter B, respectively. Parameter attribute information indicating parameter X information indicating parameter X type and length. The record of the second sentence includes a statement code indicating an ADD instruction, parameter attribute information indicating the type and length of the parameter C, parameter attribute information indicating the type and length of the parameter X, and a type of the parameter Y. And parameter attribute information indicating the length. The record of the third sentence includes a sentence code indicating the MOV instruction, parameter attribute information indicating the type and length of the parameter Y, and parameter attribute information indicating the type and length of the parameter A.

  The record of the third sentence includes a statement code indicating a MULTIPLY instruction, parameter attribute information indicating the type and length of the parameter E, parameter attribute information indicating the type and length of the parameter F, and a type of the parameter V And parameter attribute information indicating the length. The record of the second sentence includes a statement code indicating an ADD instruction, parameter attribute information indicating the type and length of the parameter D, parameter attribute information indicating the type and length of the parameter V, and a type of the parameter W. And parameter attribute information indicating the length. The record of the third sentence includes a statement code indicating the MOVE instruction, parameter attribute information indicating the type and length of the parameter W, and parameter attribute information indicating the type and length of the parameter D.

  Here, the first sentence, the fourth sentence, the second sentence, the fifth sentence, the third sentence, and the sixth sentence are respectively similar sentences. That is, the type and length of the parameter A in the first sentence is the same as the type and length of the parameter E in the fourth sentence, and the type and length of the parameter B in the first sentence is the type of the parameter F in the fourth sentence. It is assumed that the type and length of the parameter X in the first sentence match the type and length of the parameter V in the fourth sentence. Note that the first sentence instruction and the fourth sentence instruction are both MULTIPLY and match. The type and length of the parameter C in the second sentence are the same as the type and length of the parameter D in the fifth sentence, and the type and length of the parameter X in the second sentence are the type of the parameter V in the fifth sentence. And the type and length of the parameter Y in the second sentence are the same as the type and length of the parameter W in the fifth sentence. Note that the second sentence instruction and the fifth sentence instruction are both ADD and match. The type and length of the parameter Y in the third sentence are the same as the type and length of the parameter W in the sixth sentence, and the type and length of the parameter A in the third sentence are the same as the type of the parameter D in the sixth sentence. And match the length. Note that the third sentence instruction and the sixth sentence instruction are both MOVE and match.

  Next, the processing of the optimization unit 102 under the above-described conditions will be described with reference to FIG. The optimization unit 102 reads the record of the first sentence from the intermediate code information table (S1). The optimization unit 102 searches the similar code table and determines whether there is a sentence similar to the first sentence (S2).

  Here, since there is still no record for a sentence similar to the first sentence in the similar code table (S3: No), the optimization unit 102 searches the intermediate code information table and is similar to the first sentence. It is determined whether there is a sentence to be performed (S5).

  In the intermediate code information table, a sentence similar to the first sentence exists in the fourth sentence (S6: Yes). In other words, the instruction and parameter type and length indicated by the first record in the intermediate code information table match the instruction and parameter type and length indicated by the fourth sentence record in the intermediate code information table.

  Therefore, the optimization unit 102 adds a record for the sentence to the similar code table (S7). Specifically, as shown in FIG. 7, in the record to be added, the similar code number SIM1, which uniquely identifies the type (command, type and length) of the first sentence (fourth sentence), the first sentence (Fourth sentence) MULTIPLY statement code, parameter A (E) type and length information, parameter B (F) type and length information, and parameter X (V) type And information indicating the length is set.

  Then, as shown in FIG. 8, the optimization unit 102 has optimized the sentence code of the first sentence of the object generation intermediate code 2 with the similar code number SIM1 of the record added to the similar code table. An intermediate code is generated (S4).

  The optimization unit 102 determines whether the end of the record of the intermediate code information table has been reached (S9). Here, since it is not the end of the record (S9: No), the process returns to step S1.

  Subsequently, since the second sentence and the third sentence are similar to the fifth sentence and the sixth sentence as described above, similarly, records are added to the similar code table (S1, S2, S3: No). , S5, S6; Yes, S7) and generation of optimized intermediate code (S4) in which the sentence code is replaced with the similar code number (SIM2 or SIM3).

  As a result, as shown in FIG. 7, the similar code number SIM2 that uniquely identifies the type (command, type, and length) of the second sentence (fifth sentence), and the second sentence (fifth sentence) ADD A statement code indicating an instruction, information indicating the type and length of the parameter C (D), information indicating the type and length of the parameter X (V), and information indicating the type and length of the parameter Y (W) Sentence code number SIM3 that uniquely identifies the set record and the type (command, type and length) of the third sentence (sixth sentence), and a sentence indicating the third sentence (sixth sentence) MOVE instruction A record in which information indicating a code, information indicating the type and length of parameter Y (W), and information indicating a type and length of parameter A (D) is added.

  Further, as shown in FIG. 8, the optimized intermediate code in which the sentence code of the second sentence of the object generation intermediate code 2 is replaced with the similar code number SIM2 of the record added to the similar code table, and the object generation The optimized intermediate code is generated by replacing the sentence code of the third sentence of the intermediate code 2 for use with the similar code number SIM3 of the record added to the similar code table.

  Subsequently, the optimization unit 102 reads the record of the third sentence from the intermediate code information table (S1). The optimization unit 102 searches the similar code table to determine whether there is a sentence similar to the third sentence (S2).

  As shown in FIG. 7, the similar code table includes a record (similar code number SIM1) for a sentence similar to the third sentence (S3: Yes). That is, the instruction and parameter type and length indicated by the third record in the intermediate code information table match the instruction and parameter type and length indicated by the first record in the similar code table.

  Therefore, the optimization unit 102 optimizes by replacing the sentence code of the third sentence with the similar code number SIM1 of the first record of the similar code table in the object generation intermediate code 2. Generated intermediate code is generated (S4).

  The optimization unit 102 determines whether the end of the record of the intermediate code information table has been reached (S9). Here, since it is not the end of the record (S9: No), the process returns to step S1.

  Subsequently, since the fifth sentence and the sixth sentence are similar to the second sentence and the third sentence to which the record corresponding to the similar code table is added as described above, the sentence codes are similarly changed. Generation (S1, S2, S3: Yes, S4) of the optimized intermediate code replaced with the number (SIM2 or SIM3) is performed.

  Thus, as shown in FIG. 8, the optimized intermediate code in which the sentence code of the fifth sentence of the object generation intermediate code 2 is replaced with the similar code number SIM2 of the record added to the similar code table, and the object An optimized intermediate code is generated by replacing the sentence code of the sixth sentence of the generation intermediate code 2 with the similar code number SIM3 of the record added to the similar code table.

  Then, since the end of the record is reached (S9: Yes), the optimization unit 102 ends the process.

  Here, there is no case of No in step S6. However, in such a case, as described above, the optimized intermediate code is not replaced without replacing the sentence code with the similar code number. Is generated (S8).

  Next, effects according to the embodiment of the invention will be described with reference to FIG. FIG. 9 is a diagram for explaining the effect according to the embodiment of the invention.

  The code in each sentence of the optimized intermediate code is converted by the addressing unit 103 into a code that calls a common function that executes processing of the sentence specified by the similar code number included in the sentence. Further, the code of the common function is generated by the addressing unit 103 so as to execute processing of the code based on the code of the original sentence. Further, the code of the common function is generated by the addressing unit 103 in the form of the parameter of the code of the original sentence so that the parameter is an argument. Therefore, since a parameter (value) having the same type and the same length is specified as an argument in the common function, no wrinkles occur in processing within the function.

  For example, the code shown in the first sentence of FIG. 8 is replaced with a call to a common function that executes a MULTIPLY process corresponding to the similar code number SIM1. This common function includes a type and length parameter common to parameters A and E, a type and length parameter common to parameters B and F, and a type and length parameter common to parameters X and V. Generated as a common function as an argument.

  Here, the compiler originally includes an assembler code template from the intermediate code for each dissimilar code. For example, if an ADD instruction statement exists in the intermediate code, an assembler code for executing the ADD instruction processing on the original intermediate code statement parameter is generated by setting the intermediate code parameter in the template. can do. In this way, conversion into assembler code is possible by replacing each sentence in the intermediate code with the corresponding template.

  Therefore, when generating a common function, it may be generated using this template. That is, the compiler 120 includes an assembler code template for each sentence type (for each similar code number) and arranges the template code as a process in the common function, so that an assembler code can be easily generated. be able to.

  In this way, by replacing similar sentences with calls to common functions, as shown in the right diagram of FIG. 9, in the assembler code, the codes can be gathered in units of sentences and the amount of code can be reduced. Therefore, as a subsequent phase, when the code is optimized by the assembler and linker, the code size to be optimized can be reduced, so that the time required for the optimization can be reduced.

  On the other hand, as shown in the left diagram of FIG. 9, in the case where the present invention is not applied, since the code is not grouped in the assembler code, the entire function in which the sentence is described is not collected. The amount of code becomes large. Therefore, when the code is optimized by the assembler and the linker, the code size to be optimized becomes large, and the time required for the optimization increases.

<Outline of Embodiment of the Present Invention>
Next, a schematic configuration of the compiling device 1 according to the embodiment of the invention will be described with reference to FIG. FIG. 10 is a block diagram showing a configuration of the compiling device 9 which is a schematic configuration of the compiling device 1 according to the embodiment of the invention.

  The compiling device 9 includes a similar sentence detection unit 90 and a code conversion unit 91. The compiling device 9 converts the first source code including a plurality of statements each including an instruction and an operand into intermediate code, and further converts the second source code in a language lower than the first source code. Compile by converting to.

  The similar sentence detection unit 90 detects a similar sentence that is a sentence having the same instruction and operand format in the intermediate code. When the code conversion unit 91 converts the intermediate code into the second source code, the code corresponding to the similar sentence detected by the similar sentence detection unit 90 in the intermediate code is used with the operand of the similar sentence as an argument. It is converted as a code that calls a common function that executes these instructions.

  As described above, according to the present embodiment, when an intermediate code is converted into an assembler code, a code corresponding to a similar sentence is executed using a similar sentence operand as an argument, and a common sentence instruction is executed. It is converted as code that calls the function. According to this, since the code size to be optimized can be reduced in the subsequent phase, the time required for optimization can be reduced.

  Note that the present invention is not limited to the above-described embodiment, and can be changed as appropriate without departing from the spirit of the present invention.

  A compiler (program) that realizes the functions of the above-described embodiments is stored using various types of non-transitory computer readable media and supplied to the computer (compiler device). can do. Non-transitory computer readable media include various types of tangible storage media. Examples of non-transitory computer-readable media include magnetic recording media (for example, flexible disks, magnetic tapes, hard disk drives), magneto-optical recording media (for example, magneto-optical disks), CD-ROMs (Read Only Memory), CD-Rs, CD-R / W, semiconductor memory (for example, mask ROM, PROM (Programmable ROM), EPROM (Erasable PROM), flash ROM, RAM (Random Access Memory)) are included. The program may also be supplied to the computer by various types of transitory computer readable media. Examples of transitory computer readable media include electrical signals, optical signals, and electromagnetic waves. The temporary computer-readable medium can supply the program to the computer via a wired communication path such as an electric wire and an optical fiber, or a wireless communication path.

  In addition to the case where the function of the above-described embodiment is realized by the computer executing the program that realizes the function of the above-described embodiment, this program is not limited to the OS ( A case where the functions of the above-described embodiment are realized in cooperation with an operating system or application software is also included in the embodiment of the present invention. Furthermore, the present invention is also applicable to the case where the functions of the above-described embodiment are realized by performing all or part of the processing of the program by a function expansion board inserted into the computer or a function expansion unit connected to the computer. It is included in the embodiment.

1, 9 Compile device 10 CPU
11 Memory 12 Storage unit 90 Similar sentence detection unit 91 Code conversion unit 100 Expansion unit 101 Code generation unit 102 Optimization unit 103 Addressing unit 120 Compiler 121 Assembler 122 Linker 123 Source code

Claims (8)

Converting a first source code including a plurality of sentences each including an instruction and an operand into an intermediate code, and further converting into a second source code in a language lower than the first source code Compiling device for compiling with
In the intermediate code, a similar sentence detection unit that detects a similar sentence that is a sentence having the same format of the instruction and the operand;
When the intermediate code is converted into the second source code, the code corresponding to the similar sentence detected by the similar sentence detection unit in the intermediate code is set with the operand of the similar sentence as an argument. A code conversion unit that converts the code to call a common function that executes instructions;
Compile device with The similar sentence detection unit includes similarity specifying information for uniquely specifying the format of the instruction and operand of the similar sentence in the similar sentence,
The code conversion unit is configured to specify a code corresponding to the similar sentence in the form of an operand specified by the similarity specifying information included in the similar sentence, using the operand of the similar sentence as an argument, and an instruction specified by the similarity specifying information As a code that calls a common function that executes
The compiling device according to claim 1. The compiling device further includes a storage unit for storing arbitrary information,
The similar sentence detection unit includes, in the intermediate code, intermediate code information including instruction information indicating an instruction of the sentence and operand format information indicating an operand format of the sentence based on the sentence in the intermediate code. Generated for each sentence to be stored in the storage unit,
The similar sentence detection unit detects and detects intermediate code information in which the instruction and operand formats indicated by the instruction information and the operand format information respectively match among the intermediate code information stored in the storage unit. The sentence corresponding to the intermediate code information is determined as a similar sentence,
The compiling device according to claim 2. The similar sentence detection unit, when detecting the similar sentence, similar identification information for uniquely identifying the format of the instruction and operand of the similar sentence, and instruction information indicating each of the format of the instruction and operand of the similar sentence And similar sentence information including the operand information and storing in the storage unit,
When the instruction and operand format indicated by the similar sentence information matches the instruction and operand format indicated by the intermediate code information, the similar sentence detection unit determines the similarity specifying information included in the similar sentence information, Included in the sentence corresponding to the intermediate code information,
The compiling apparatus according to claim 3. The form of the operand is the type and length of the operand.
The compiling device according to any one of claims 1 to 4. The first source code is a source code written in a COBOL language,
The second source code is an assembler code.
The compiling device according to any one of claims 1 to 5. Converting a first source code including a plurality of sentences each including an instruction and an operand into an intermediate code, and further converting into a second source code in a language lower than the first source code Compile method to compile with
Detecting a similar sentence in the intermediate code, which is a sentence having the same format of the instruction and the operand;
When the intermediate code is converted to the second source code, a code corresponding to the detected similar sentence is executed in the intermediate code, with the operand of the similar sentence as an argument, and a common sentence instruction is executed Converting it as code that calls a function;
Compile method with Converting a first source code including a plurality of sentences each including an instruction and an operand into an intermediate code, and further converting into a second source code in a language lower than the first source code A compiler for compiling with
In the intermediate code, a process of detecting a similar sentence that is a sentence having the same format of the instruction and the operand;
When the intermediate code is converted to the second source code, a code corresponding to the detected similar sentence is executed in the intermediate code, with the operand of the similar sentence as an argument, and a common sentence instruction is executed A process to convert the code to call a function,
Is a compiler that allows a computer to execute.

Images