JP3672207B2 - Program converter - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to a program conversion apparatus that translates a program, and more particularly to a program conversion apparatus that reduces the code size of an override method call instruction of an object-oriented language and improves the execution speed.
[0002]
[Prior art]
Object oriented languages have override methods as special methods for building diversity. An override method is, for example, when class A and class B that inherits class A each have method f of the same type and call method f on an object of class B, the call returns a pointer or reference to class A. A method having a function that allows the method f of the class B to be called even though it is via. Such a function is called an override function.
[0003]
In the object-oriented language C ++ (hereinafter referred to as “C ++ language”), the override method is called a virtual function and can be specified by adding a virtual specifier to the head of the function. In the C ++ language, a method is a function. If the function f is designated as a virtual function in class A, the function f automatically becomes a virtual function in class B that inherits the class A.
[0004]
In the object-oriented language Java (hereinafter referred to as “Java language”), the method is an override method by default.
A conventional method for realizing an object-oriented language override method call will be described with reference to an example of “Annotation C ++ Reference Manual” (B. Straustrap Toppan ISBN 4-8101-8027-110.7c).
[0005]
FIG. 12 is a diagram showing a class definition including a virtual function of C ++ language. A function having a virtual specifier at the head and a function inheriting it are virtual functions in the figure. Therefore, the functions f, g and h of class A, the functions f, g and h of class B and the functions f, g and h of class C are virtual functions.
FIG. 13 is a diagram showing the inheritance relationship of the classes shown in FIG. Class A is inherited by class B, and class B is inherited by class C.
[0006]
FIG. 14 is a diagram showing the memory allocation of objects created by the class shown in FIG. 12 for each class. Taking class A as an example, generally, the method address table “A_vtbl” is arranged outside the object, and only the address “A_vptr” of this method address table is arranged in the object. Since the method address table is not arranged for each object, when multiple objects of the same class are created, the size of the memory can be saved by the overlap. Here, “& A :: f” represents the address of the virtual function f defined in the class A. When calling the virtual function f, first, the address “& A :: f” of the virtual function in the method address table is read based on the address “A_vptr” of the method address table “A_vtbl” in the object, and then this address is read. I will call it.
[0007]
FIG. 15 is a diagram illustrating an example in which a function i including a call to a virtual function h of class C is described in the C ++ language. Here, the argument of i is a pointer to an object of class C.
FIG. 16 is a diagram showing an example in which the function i in FIG. 15 is converted into a machine language instruction sequence by a conventional program conversion apparatus. The function i is called in a state where the pointer to the object as an argument is held in the register r0.
[0008]
First, the pointer to the virtual function h in the class C object is transferred to the r1 register by the instruction “mov (r0 + 4), r1”. Next, using this, the real address “& C :: h” of the virtual function h in the position where the offset 8 in the method address table is added is transferred to the r1 register by the instruction “mov (r1 + 8), r1”, and the instruction “ jsr r1 "branches to the address of r1. Here, the instruction “mov (r0 + d), r1” represents an instruction for reading the contents of the memory indicated by the address obtained by adding d to the address of r0 to r1, and the instruction “jsr r1” is a subroutine call that branches to the address of r1. The instruction “rts” represents a return instruction from the function i.
[0009]
FIG. 17 shows an example in which the function i including the call to the function h is converted into a machine language instruction sequence when the function h is defined as a function that is not a virtual function (hereinafter referred to as “non-virtual function”). FIG.
When FIG. 16 is compared with FIG. 17, the call of the virtual function is 4 instructions, and the call of the non-virtual function is 2 instructions.
[0010]
[Problems to be solved by the invention]
However, since the method for realizing the override method call of the conventional object-oriented language as described above handles all the items specified in the override method in the same way, if a method that does not use the override function is specified in the override method, the machine language instruction There is a problem that the code size of the column becomes large and the execution speed becomes slow.
[0011]
In addition, the programmer specifies all the methods that do not use the override function as methods that are not override methods (hereinafter referred to as “non-override methods”). Methods that cannot be determined whether or not to use must be specified later as non-override methods, which increases the burden on the programmer.
[0012]
Furthermore, although a final specifier indicating that a method is not an override method is prepared in the Java language, but there is no specifier indicating that the method is not an override method in the C ++ language, when a certain method is designated as an override method in the class A, The method cannot be designated as a non-override method in the class B that inherits the class A.
[0013]
Accordingly, an object of the present invention is to provide a program conversion apparatus that reduces the code size of an override method call instruction of an object-oriented language and improves the execution speed.
[0014]
[Means for Solving the Problems]
A program conversion apparatus according to the present invention is a program conversion apparatus that translates an object-oriented language program including a definition of a class including an override method and an override method calling instruction into a machine language instruction sequence to generate an execution file, Extraction means for extracting inheritance relationships of all classes as inheritance relationship information based on the definition of the class, and whether a class to which a method called by the override method call instruction belongs is inherited based on all the inheritance relationship information A judging means for judging whether or not, and a method translating means for translating the override method calling instruction into a machine language instruction string when it is determined not to be inherited by the judging means.
[0015]
In the present invention, when all class definitions necessary for program execution are included in one input file, the override method call instruction is not an override method or an override method based on the inheritance relationship of all classes. Take the method of translating into either case.
This takes advantage of the fact that if a class is not inherited at all by another class, the override method defined in that class cannot use the override function, the override method call instruction is not an override method. Can be translated into That is, an indirect call can be made a direct call.
[0016]
Further, the program conversion apparatus according to the present invention includes a translation apparatus that translates an object-oriented language program including a definition of a class including an override method and an override method calling instruction into a machine language instruction sequence on a file basis and outputs the machine language instruction sequence. And a concatenation device that concatenates output files translated by the translation device to generate an execution file, wherein the object-oriented language program defines a class including an override method and calls an override method. An instruction is included, and the translation device includes inheritance relationship translation means for translating the inheritance relationship of a file unit class into inheritance relationship information based on the definition of the class, and a method called by the instruction for the override method call command. A method instruction sequence that includes method class information that represents a class to be executed, non-override information that represents a machine language instruction sequence when the method called by this instruction is not an override method, and override information that represents a machine language instruction sequence when the method is an override method A method translation means for translating into a class to which the method called by the override method call instruction belongs based on all the inheritance relation information in all output files translated by the translation device. A determination means for determining whether the method instruction sequence is inherited, and if the determination means determines that the method instruction sequence is not inherited, the method instruction sequence is replaced only with a machine language instruction sequence for a case where the method is not an override method. If it is determined that Characterized in that it comprises a replacement means for replacing only machine language instruction sequence when it is de-method.
[0017]
When there are a plurality of input files, the translation device only knows the inheritance relationship of the class for each file, but not the inheritance relationship of all the classes. Moreover, the conventional inheritance device does not know the inheritance relationship of classes.
According to the present invention, the inheritance relationship of the file unit class is translated into the inheritance relationship information by the translation device, and all the inheritance relationship information is referred to by the connection device, so that the inheritance relationship of all the classes can be known in the connection device. Further, the method of translating the override method call instruction in the translation apparatus into an instruction sequence for both the case where it is not the override method and the case where it is the override method, and selecting either one in the concatenation apparatus.
[0018]
This takes advantage of the fact that if a class is not inherited at all by another class, the override method defined in that class cannot use the override function, and the override method call instruction is not an override method. Can be translated into That is, an indirect call can be made a direct call.
[0019]
DETAILED DESCRIPTION OF THE INVENTION
Hereinafter, embodiments of the present invention will be described with reference to the drawings.
FIG. 1 is a diagram showing the configuration of a program conversion apparatus according to the present invention. For convenience, FIG. 1 also shows input files A101 and B102, output files A108 and B109, and an execution file 115. Here, the input files A101 and B102 are source programs written in a high-level language. The output files A108 and B109 are machine language instruction sequences obtained by translating each input file. Further, the execution file 115 is a machine language instruction sequence generated by linking the two output files. The file mentioned here refers to a collection of source programs and machine language instruction sequences as input / output units.
[0020]
This apparatus is roughly composed of a translation unit 103 and a connection unit 110.
The translation unit 103 is implemented on a file-by-file basis, translates the class inheritance relationship into the inheritance relationship pseudo-instruction for each class definition, and converts the override method invocation instruction into a method class pseudo-instruction representing the class to which the method called by this instruction belongs, When the method called by the instruction is not an override method, it is translated into a machine language instruction string and when it is an override method, other untranslated instructions are translated into a machine language instruction string and output as an output file. To do.
[0021]
Here, the output file A108 is output by inputting the input file A101, and the output file B109 is output by inputting the input file B102.
The translation unit 103 includes an inheritance relationship translation unit 104, a method call detection unit 105, a method translation unit 106, and an instruction translation unit 107.
For each class definition, the inheritance relationship translation unit 104 translates the inheritance relationship of the class into an inheritance relationship pseudo-instruction.
[0022]
The method call detection unit 105 detects an override method call instruction in the input file.
The method translation unit 106 translates the override method call instruction detected by the method call detection unit 105 into a method instruction sequence. Here, the method instruction sequence is a method class pseudo-instruction representing the class to which the method called by this instruction belongs, a machine language instruction sequence when the method called by this instruction is not an override method, and a machine language instruction sequence when it is an override method And pseudo-instructions for identifying them.
[0023]
The instruction translation unit 107 translates an instruction that has not been translated by the method translation unit 106 into a machine language instruction sequence.
The concatenating unit 110 replaces and concatenates all the output files translated by the translating unit 103 to generate an execution file. Here, the execution file 115 is output by inputting the output files A 108 and B 109.
[0024]
The concatenation unit 110 includes a method instruction sequence detection unit 111, an inheritance class determination unit 112, a method replacement unit 113, and a file connection unit 114.
The method instruction sequence detection unit 111 detects the method instruction sequence translated by the method translation unit 106 from all input output files.
The inherited class determining unit 112 recognizes the class to which the method belongs from the method class pseudo instruction in the method instruction sequence detected by the method instruction sequence detecting unit 111, and determines whether or not the class is inherited by another class. Judgment is made based on all inheritance relation pseudo-instructions in all output files.
[0025]
The method replacement unit 113 is not an override method when the method instruction sequence detected by the method instruction sequence detection unit 111 is determined not to be inherited by the inheritance class determination unit 112. If it is determined that the class is inherited, it is replaced only by the machine language instruction sequence in the case of the override method. to erase.
[0026]
The file concatenation unit 114 concatenates all the files replaced by the method replacement unit 113 to generate an execution file.
The operation of the program creation apparatus configured as shown in FIG. 1 will be described using a C ++ language program.
FIG. 2 shows a definition of a class X including a virtual function of the C ++ language, a definition of a class Y that inherits the class X, a definition of a class Z that inherits the class X, a definition of the function void i (Y *), and a function void j (Z It is a figure which shows the definition of *). Here, it is stored in the input file A101 in FIG.
[0027]
FIG. 3 is a diagram showing the inheritance relationship of the classes shown in FIG. Class X is inherited by class Y and class Z.
FIG. 4 shows a definition of a class X including a virtual function in the C ++ language, a definition of a class Y that inherits the class X, a definition of a class Z that inherits the class X, a definition of a class W that inherits the class Z, and a function void k (W It is a figure which shows the definition of *). Here, it is stored in the input file B102 in FIG. For simplicity, method definitions, programs, and subsequent processing contents not related to the description are omitted. However, all class definitions necessary for program execution are described.
[0028]
FIG. 5 is a diagram showing the inheritance relationship of the classes shown in FIG. Class X is inherited by class Y and class Z, and class Z is inherited by class W.
The input file A101 contains the C ++ language source program shown in FIG. 2, and the input file B102 contains the C ++ language source program shown in FIG.
[0029]
The translation unit 103 outputs the output file A108 shown in FIG. 6 in response to the input of the input file A101 shown in FIG.
Similarly, the translation unit 103 outputs the output file B109 shown in FIG. 7 in response to the input of the input file B102 shown in FIG.
The linking unit 110 outputs the execution file 115 shown in FIG. 8 in response to the input of the output file A 108 shown in FIG. 6 and the output file B 109 shown in FIG.
[0030]
The meanings of the machine language instruction sequence used here are as follows.
. BASE name: an inheritance relationship pseudo-instruction indicating that a class represented by name is inherited from another class.
_I_FP1Y: A label representing the address of the function void i (Y *).
[0031]
. METHODS: a pseudo-instruction that represents the beginning of a method instruction sequence.
. CLASS name: A method class pseudo instruction representing a class to which a method belongs.
jsr Label: A subroutine call instruction that branches to an address represented by Label.
[0032]
_H — 1Y: a label representing the address of the virtual function void h (void) of class Y
. METHODM M: A pseudo instruction that separates an instruction sequence when the method is not an override method and an instruction sequence when the method is an override method.
mov (r0 + 4), r1: a transfer instruction for loading the contents of the memory having r0 + 4 as an address into r1.
[0033]
mov (r1 + 0), r1: This is a transfer instruction for loading the contents of the memory having r1 as an address into r1.
jsr r1: A subroutine call instruction that branches to the address stored in the register r1.
. METHOD E: A pseudo instruction indicating the end of a method instruction sequence.
[0034]
rts: a return instruction from the function.
_J_FP1Z: A label representing the address of the function void j (Z *).
_H — 1Z: A label indicating the address of the virtual function void h (void) of class Z.
[0035]
_K_FP1W: A label representing the address of the function void k (W *).
_H — 1W: A label representing the address of the virtual function void h (void) of class W.
From here, the detailed operation of the translation unit 103 will be described.
[0036]
FIG. 9 is a flowchart illustrating the operation of the translation unit 103.
First, the input file A101 is input. Here, consider the case where the C ++ language program shown in FIG. 2 is input (step 901).
Next, it is determined whether or not the process of the inheritance relationship translation unit 104 is finished. If it has not been completed, the class information is acquired. Here, the class information is sequentially acquired for each definition of class X, class Y, and class Z, and then the process of the method call detecting unit 105 is performed (step 902).
[0037]
If there is an unprocessed class definition, class information is acquired for each class definition. Here, class information is acquired sequentially for each definition of class X, class Y, and class Z (step 903).
Next, it is determined whether or not this class inherits another class from the obtained class information for each class definition. If yes, go to translate the inheritance relationship, if no, return to end determination. Here, in the case of class X, since the other class is not inherited, the process returns to the end determination, and in the case of class Y and class Z, since class X is inherited, the inheritance relationship is sequentially translated (step 904). .
[0038]
If this class inherits another class, the inheritance relationship of the class is translated into an inheritance relationship pseudo-instruction. Here, since class Y and class Z inherit class X, the inherited class name is translated into inheritance relation pseudo-instruction “.BASE 1X”, and the process returns to the end determination (step 905). Note that the inheritance relationship pseudo-instruction may represent the class name of the inherited class and the class name of the inheriting class as a pair. In this way, the inheritance relationship of all classes can be completely reproduced by the concatenation device. It is also possible to output the information etc. for reference.
[0039]
When the process of the inheritance relationship translation unit 104 ends, it is next determined whether or not the process of the method call detection unit 105 has ended. If not finished, go to detect override method call instruction, and if finished, go to conventional translation processing. Here, instructions are sequentially detected for the virtual function call instruction of the function “void i (Y *)” and the virtual function call instruction of the function “void j (Z *)”, and then the conventional translation processing is performed (step 906).
[0040]
If there is an unprocessed override method call instruction, this is detected. Here, the virtual function calling instructions of the function “void i (Y *)” and the function “void j (Z *)” are sequentially detected and translated into a method instruction sequence (step 907).
Next, the method translation unit 106 translates the detected override method call instruction into a method instruction sequence. Here, the virtual function calling instructions of the function “void i (Y *)” and the function “void j (Z *)” are sequentially translated into a method instruction sequence, and the process returns to the end determination (step 908). Here, the method instruction string of the function “void i (Y *)” is a portion that starts with “.METHODS S” in the first half of the output file A 108 shown in FIG. 6 and ends with “.METHODE E”. “.CLASS 1Y” included in this method instruction sequence is a method class pseudo-instruction indicating that a method called by this instruction belongs to class Y. Between “.CLASS 1Y” and “.METHOD M”, A machine language instruction sequence is a machine language instruction sequence when a method called by this instruction is not an override method, and a machine language instruction sequence between “.METHOD M” and “.METHODE E” is an override method. Machine language instruction sequence. The method for generating the machine language instruction sequence is the same as the conventional method, and thus the description thereof is omitted. Further, the method instruction sequence of the function “void j (Z *)” is the same as that of the function “void i (Y *)”, and thus the description thereof is omitted.
[0041]
FIG. 10 shows a method instruction sequence.
Since the method instruction sequence always has the same format, the method instruction sequence shown in FIG. 10A may be represented by a method class pseudo instruction and one macro instruction as shown in FIG. As shown in FIG. 10 (c), it may be represented by one macro instruction including information on the method class pseudo instruction. Here, in FIG. 10B, the macro name “jsrv” is sequentially output after the label name to be called when the method called by the override method call instruction is not an override method, and is used when the method is an override method. The offset value from the head of the object to be performed, the offset value from the head of the method address storage table used when the method is an override method, and the register name used when the method is an override method. In FIG. "srw" is sequentially output after the class name to which the method called by the override method call instruction belongs, and the method called by this override method call instruction is not an override method The label name to be called, the offset value from the top of the object to be used if it is an override method, the offset value from the top of the method address storage table to be used if it is an override method, and the register to be used if it is an override method Name. Note that it is not always necessary to use a fixed register name for the override method.
[0042]
When the process of the method call detection unit 105 is completed, the instruction translation unit 107 translates the instruction that has not been translated by the method translation unit 106 into a machine language instruction sequence. Since this process is not different from the process performed by the conventional translation apparatus, detailed description thereof is omitted (step 909).
Next, the output file A108 is output. Here, the output file shown in FIG. 6 is output (step 910).
[0043]
Subsequently, the input file B102 is input. Here, consider the case where the C ++ language program shown in FIG. 4 is input (step 901).
Next, class information is sequentially acquired for each definition of class X, class Y, class Z, and class W, and then the process of the method call detection unit 105 is performed (step 902).
[0044]
If there is an unprocessed class definition, class information is sequentially acquired for each definition of class X, class Y, class Z, and class W (step 903).
Next, in the case of class X, since the other class is not inherited, the process returns to the end determination. In the case of class Y and class Z, class X is inherited, and in the case of class W, class Z is inherited. Go to translate inheritance relationship (step 904).
[0045]
Since class Y and class Z inherit class X, the inherited class name is translated into inheritance relation pseudo-instruction ".BASE 1X", and class W inherits class Z because class W inherits class Z. The name is translated into an inheritance relationship pseudo-instruction “.BASE 1Z”, and the process returns to the end determination in sequence (step 905).
When the process of the inheritance relationship translation unit 104 is finished, next, an instruction is detected for the virtual function call instruction of the function “void k (W *)”, and then the conventional translation process is performed (step 906).
[0046]
If there is an unprocessed override method call instruction, a virtual function call instruction of the function “voidk (W *)” is detected and translated into a method instruction sequence (step 907).
Next, the virtual function call instruction of the function “void k (W *)” is translated into a method instruction sequence, and the process returns to the end determination (step 908). Since the method instruction string of the function “void k (Z *)” is the same as that of the function “void i (Y *)”, the description thereof is omitted.
[0047]
When the process of the method call detection unit 105 is completed, the instruction translation unit 107 translates the instruction that has not been translated by the method translation unit 106 into a machine language instruction sequence. Since this process is not different from the process performed by the conventional translation apparatus, detailed description thereof is omitted (step 909).
Next, the output file B109 is output. Here, the output file shown in FIG. 7 is output (step 910).
[0048]
Subsequently, a detailed operation of the connecting unit 110 will be described.
FIG. 11 is a diagram illustrating an operation flowchart of the connecting unit 110.
First, an output file A 108 and an output file B 109 are input. Here, a case is considered where the output file shown in FIG. 6 and the output file shown in FIG. 4 are input (step 1101).
[0049]
Next, it is determined whether or not the process of the method instruction sequence detection unit 111 is completed. If it has not been completed, the instruction sequence is detected. If it has been completed, the succession related pseudo-instruction is deleted. Here, the instruction sequence of the function “void i (Y *)”, the method instruction sequence of the function “void j (Z *)”, and the method instruction sequence of the function “void k (W *)” are sequentially detected. Then, the succession relation pseudo-instruction is deleted (step 1102).
[0050]
If there is an unprocessed method instruction sequence, the method instruction sequence is detected from all input output files. Here, the method instruction sequence of the function “void i (Y *)”, the function “void j (Z *)” and the function “void k (W *)” is sequentially detected to determine whether the class is inherited. (Step 1103). Next, the class to which the method belongs is recognized from the method class pseudo instruction in the detected method instruction sequence, and whether or not the class is inherited by other classes is determined by all the inheritance relation pseudo tests in all output files. Judgment based on instructions. Here, first, the class Y is recognized from the method class pseudo instruction “.CLASS 1Y” in the method instruction sequence of the function “void i (Y *)”, and all the inheritance relation pseudo instructions “. Based on “BASE 1X” and “.BASE 1Z”, it is determined that the class Y is not inherited by other classes, and is replaced with an instruction sequence when it is not an override method, and then the function “void j (Z *)” Class Z is recognized from the method class pseudo-instruction ".CLASS 1Z" of the "." Class Z is determined to be inherited by other classes based on the inheritance relation pseudo-instruction ".BASE 1Z" in the output file B109, If it is an override method, go to replace with the instruction sequence, and then suspect the method class in the method instruction sequence of the function “void k (W *)” Class W is recognized from instruction “.CLASS 1W”, and class W is not inherited by other classes based on all inheritance relation pseudo-instructions “.BASE 1X” and “.BASE 1Z” in all output files. Judgment is made and the instruction sequence for the case where the method is not an override method is replaced (step 1104).
[0051]
If it is determined that the class to which the method belongs is not inherited by another class, the method instruction sequence detected by the method instruction sequence detection unit 111 is only the machine language instruction sequence when the method replacement unit 113 is not an override method. Replace with. Here, the method instruction sequence of the function “void i (Y *)” is sequentially replaced with the instruction “jsr_h_1Y”, and the method instruction sequence of the function “void j (W *)” is sequentially replaced with the instruction “jsr_h_1W”, and the end determination is made. Return (step 1105).
[0052]
If it is determined that the class to which the method belongs is inherited by another class, the method instruction sequence detected by the method instruction sequence detection unit 111 is a machine language instruction when the method replacement unit 113 is an override method. Replace with column only. Here, the method instruction string of the function “void j (Z *)” is replaced with the instructions “mov (r0 + 4), r1”, “mov (r1 + 0), r1”, and “jsr r1”, and the process returns to the end determination (step 1106). ).
[0053]
When the process of the method instruction sequence detection unit 111 is completed, the method replacement unit 113 deletes all the inheritance relation pseudo instructions. Here, the inheritance relationship pseudo-instructions “.BASE 1X” and “.BASE 1Z” are deleted (step 1107).
Next, the file concatenation unit 114 concatenates all of the files replaced by the method replacement unit 113 to generate an execution file. Note that the processing for connecting the above files is not different from the processing performed by the conventional connecting device, and therefore detailed description thereof is omitted (step 1108).
[0054]
Next, the execution file 115 is output. Here, the execution file shown in FIG. 8 is output (step 1109).
Note that the processing performed by the method replacement unit 113 in this embodiment is a form in which both the instruction sequence when the method instruction sequence is not an override method and the instruction sequence when the method instruction sequence is an override method are used as shown in FIG. If the method instruction string is a macro instruction as shown in FIGS. 10 (b) and 10 (c), it is based on this macro instruction. Thus, the necessary instruction sequence is generated.
[0055]
In this embodiment, the translation device and the connection device are provided. However, the connection device is not always necessary. When all the class definitions necessary for program execution are included in one input file, it may be a program conversion device that only translates this input file. It may be generated by being connected in advance. In this case, the program conversion device needs to translate the class name inherited in the class definition into a pseudo instruction, translate the override method call instruction into a method instruction string, or replace the method instruction string. Instead, it is only necessary to extract the inheritance relationship of all classes based on the class definition and translate the override method call instruction into either the case where the override method is not an override method or the case where it is an override method.
[0056]
Further, the program conversion apparatus of the present embodiment can be realized by causing a general-purpose computer to read a program that realizes the present embodiment. Therefore, it is easily transferred by moving only the computer-readable storage medium that records this program.
[0057]
【The invention's effect】
(A) As is clear from the above description, the program conversion apparatus according to the present invention is a program conversion apparatus that translates an object-oriented language program into a machine language instruction sequence to generate an execution file, and the object-oriented The language program includes a definition of a class including an override method and an override method call instruction, an extraction means for extracting inheritance relationships of all classes as inheritance relationship information based on the definition of the class, and all the inheritance relationships Determining means for determining whether or not a class to which a method called by the override method calling instruction belongs is inherited based on information, and overriding the override method calling instruction when the determining means determines that the class is not inherited Machine language life when not Characterized in that it comprises a method translation means for translating the column.
[0058]
In the present invention, when all class definitions necessary for program execution are included in one input file, the override method call instruction is not an override method or an override method based on the inheritance relationship of all classes. Take the method of translating into either case.
This takes advantage of the fact that if a class is not inherited at all by another class, the override method defined in that class cannot use the override function, the override method call instruction is not an override method. Can be translated into That is, an indirect call can be made a direct call.
[0059]
Therefore, the code size of the override method call instruction can be reduced by this amount, and the execution speed is improved.
(B) Further, the program conversion apparatus according to the present invention connects a translation apparatus that translates an object-oriented language program into a machine language instruction sequence for each file and outputs it as an output file, and an output file translated by the translation apparatus And a concatenation device for generating an executable file, wherein the object-oriented language program includes a class definition including an override method and an override method call instruction, and the translation device includes the class Inheritance relationship translation means for translating the inheritance relationship of a file unit class into inheritance relationship information based on the definition of the method, method class information indicating a class to which a method called by this instruction belongs, and method class information that is called by this instruction Method A method translating means for translating into a method instruction sequence including non-override information representing a machine language instruction sequence when not a ride method and override information representing a machine language instruction sequence when being an override method; Determining means for determining whether a class to which a method called by the override method call instruction belongs is inherited based on all the inheritance relationship information in all output files translated by the translation device; When it is determined that the method instruction sequence is not inherited by the determining means, only the machine language instruction sequence when it is not an override method is replaced. On the other hand, when it is determined that the method instruction sequence is inherited, it is an override method. And a replacement means for replacing only with a machine language instruction sequence. That.
[0060]
When there are a plurality of input files, the translation device only knows the inheritance relationship of the class for each file, but not the inheritance relationship of all the classes. Moreover, the conventional inheritance device does not know the inheritance relationship of classes.
According to the present invention, the inheritance relationship of the file unit class is translated into the inheritance relationship information by the translation device, and all the inheritance relationship information is referred to by the connection device, so that the inheritance relationship of all the classes can be known in the connection device. Further, the method of translating the override method call instruction in the translation apparatus into an instruction sequence for both the case where it is not the override method and the case where it is the override method, and selecting either one in the concatenation apparatus.
[0061]
This takes advantage of the fact that if a class is not inherited at all by another class, the override method defined in that class cannot use the override function, the override method call instruction is not an override method. Can be translated into That is, an indirect call can be made a direct call.
[0062]
Therefore, the code size of the override method call instruction can be reduced by this amount, and the execution speed is improved.
(C) The program conversion apparatus according to the present invention is the program conversion apparatus according to (b), wherein the method translation means represents the non-override instruction and the override instruction by one macro instruction. To do.
[0063]
This reduces the number of instructions.
Therefore, the file size of the output file output from the translation device can be reduced, and the execution speed of the connecting device is improved.
(D) The program conversion apparatus according to the present invention is the program conversion apparatus according to (b), wherein the method translating means converts the method class information, the non-override instruction, and the override instruction into one macro instruction. It is characterized by expressing by.
[0064]
As a result, the instructions for the method class information are not necessary, and the number of instructions is reduced. Further, since the macro instruction is one line, it is similar to the instruction format performed by the conventional connecting apparatus.
Therefore, the file size of the output file output from the translation device can be reduced, the execution speed of the connecting device can be improved, and the additional change of the connecting device can be reduced.
[0065]
(E) The program conversion apparatus according to the present invention is the program conversion apparatus according to (d), wherein the macro instruction includes a macro name, the method class information, a label name to be called when it is not an override method, and an override method. It is characterized by comprising an offset value from the top of the object used in the case of and an offset value from the top of the method address storage table used in the case of the override method.
[0066]
As a result, the format of the macro instruction is similar to the format of the instruction performed by the conventional coupling device.
Therefore, the additional change of the connecting device can be reduced.
(F) The program conversion apparatus according to the present invention is the program conversion apparatus according to (a), (b), (c), (d), or (e), wherein the inheritance relationship information is other than the class definition. This is information representing a class name inherited by the class.
[0067]
Thus, when a plurality of classes inherit the same class, a plurality of the inheritance relationship information is not necessary, and one can be shared.
Therefore, the file size of the output file output from the translation device can be reduced, and the execution speed of the connecting device is improved.
(G) A computer-readable storage medium storing a program according to the present invention is a computer-readable storage medium recording a program for translating an object-oriented language program into a machine language instruction sequence to generate an execution file. The object-oriented language program includes a class definition including an override method and an override method call instruction, and an extraction procedure for extracting inheritance relationships of all classes as inheritance relationship information based on the class definition And a determination procedure for determining whether or not a class to which a method called by the override method call instruction belongs is inherited based on all the inheritance relationship information, and when the determination procedure determines that the class is not inherited Override method call Characterized in that it comprises a method translation procedure to be translated into machine language instruction sequence If the instruction is not the overriding method.
[0068]
In the present invention, when all class definitions necessary for program execution are included in one input file, the override method call instruction is not an override method or an override method based on the inheritance relationship of all classes. Take the method of translating into either case.
This takes advantage of the fact that if a class is not inherited at all by another class, the override method defined in that class cannot use the override function, the override method call instruction is not an override method. Can be translated into That is, an indirect call can be made a direct call.
[0069]
Therefore, the code size of the override method call instruction can be reduced by this amount, and the execution speed is improved.
(H) A computer-readable storage medium storing the program according to the present invention includes a translation procedure for translating an object-oriented language program into a machine language instruction sequence for each file, and outputting the output file as an output file. A computer-readable storage medium storing a program comprising a concatenation procedure for concatenating output files generated to generate an execution file, wherein the object-oriented language program includes a class definition including an override method and an override method A call instruction, and the translation procedure includes an inheritance relationship translation procedure for translating the inheritance relationship of a file unit class into inheritance relationship information based on the definition of the class, and a method called by the instruction for the override method call instruction. Class to which the Is translated into a method instruction sequence that contains non-override information that represents the machine language instruction sequence when the method called by this instruction is not an override method and override information that represents the machine language instruction sequence when it is an override method And the concatenation procedure is inherited by the class to which the method called by the override method call instruction belongs based on all the inheritance relationship information in all the output files translated by the translation procedure. A determination procedure for determining whether the method instruction sequence is not inherited in the determination procedure, and when it is determined that the method instruction sequence is not inherited, only the machine language instruction sequence for the case where the method is not an override method is replaced; If so, the override method Characterized in that it comprises a replacement procedure for replacing only the machine language instruction sequence when it is.
[0070]
When there are multiple input files, the translation procedure only knows the inheritance relationship of the class for each file, not the inheritance relationship of all the classes. Moreover, the inheritance relationship of classes is not known at all in the conventional connection procedure.
In the present invention, the inheritance relationship of the file unit class is translated into the inheritance relationship information in the translation procedure, and all the inheritance relationship information is referred to in the connection procedure, so that the inheritance relationship of all the classes can be determined in the connection procedure. Further, the method of translating the override method call instruction in the translation procedure into both the instruction sequence for the case where it is not the override method and the case of the override method, and selecting either in the concatenation procedure is adopted.
[0071]
This takes advantage of the fact that if a class is not inherited at all by another class, the override method defined in that class cannot use the override function, the override method call instruction is not an override method. Can be translated into That is, an indirect call can be made a direct call.
[0072]
Therefore, the code size of the override method call instruction can be reduced by this amount, and the execution speed is improved.
[Brief description of the drawings]
FIG. 1 is a diagram showing a configuration of a program conversion apparatus according to the present invention.
FIG. 2 is a definition of a class X including a virtual function in the C ++ language, a definition of a class Y that inherits the class X, a definition of a class Z that inherits the class X, and a function void i (Y *). And the definition of the function void j (Z *).
FIG. 3 is a diagram illustrating an inheritance relationship of classes illustrated in FIG. 2;
FIG. 4 shows a definition of a class X including a virtual function in the C ++ language, a definition of a class Y that inherits the class X, a definition of a class Z that inherits the class X, and a class W that inherits the class Z. And the definition of the function void k (W *).
FIG. 5 is a diagram illustrating the inheritance relationship of the classes illustrated in FIG. 4;
6 is a diagram showing an output file A108 output by a translation unit 103 in response to input of the input file A101 shown in FIG.
7 is a diagram showing an output file B109 output by the translation unit 103 in response to the input of the input file B102 shown in FIG.
8 is a diagram showing an execution file 115 output by the concatenation unit 110 in response to the input of the output file A 108 shown in FIG. 6 and the output file B 109 shown in FIG.
FIG. 9 is a diagram showing an operation flowchart of the translation unit 103;
FIG. 10A shows a method instruction sequence. FIG. 10B is a diagram showing a method instruction sequence by a method class pseudo instruction and one macro instruction. FIG. 10C is a diagram showing a method instruction sequence including one macro instruction including information on a method class pseudo instruction.
FIG. 11 is a diagram illustrating an operation flowchart of a connecting unit 110;
FIG. 12 is a diagram illustrating a class definition including a virtual function of C ++ language.
13 is a diagram showing the inheritance relationship of the classes shown in FIG.
FIG. 14 is a diagram showing the memory allocation of objects created with the class shown in FIG. 12 by class.
FIG. 15 is a diagram illustrating an example in which a function i including a call to a virtual function h of a class C is described in the C ++ language.
FIG. 16 is a diagram showing an example in which the function i in FIG. 15 is converted into a machine language instruction sequence by a conventional program conversion apparatus.
FIG. 17 is a diagram illustrating an example in which a function i including a call to the function h is converted into a machine language instruction sequence when it is assumed that the function h is defined as a non-virtual function.
[Explanation of symbols]
101 Input file A
102 Input file B
103 Translation Department
104 Inheritance Translation Department
105 Method call detector
106 Method Translation Department
107 Instruction Translation Department
108 Output file A
109 Output file B
110 connecting part
111 Method instruction sequence detector
112 Inheritance class determination part
113 Method replacement part
114 File connection
115 Executable file

Claims (5)

Program conversion comprising: a translation device that translates an object-oriented language program into a machine language instruction sequence in units of files and outputs an output file; and a concatenation device that concatenates the output files translated by the translation device to generate an execution file A device,
The object-oriented language program includes a class definition including an override method and an override method call instruction.
The translation device includes:
Inheritance relationship translation means for translating the inheritance relationship of the file unit class into the inheritance relationship information based on the definition of the class;
The override method call instruction includes method class information representing a class to which a method called by this instruction belongs, non-override information representing a machine language instruction string when a method called by this instruction is not an override method, and an override method. A method translation means for translating into a method instruction sequence including override information representing a machine language instruction sequence in the case,
The connecting device is
Determining means for determining whether a class to which a method called by the override method calling instruction belongs is inherited based on all the inheritance relationship information in all output files translated by the translation device; ,
If it is determined not to be inherited in the previous Symbol judging means, wherein the override information contained in the method instruction sequence is not used, and by using the non-override information contained in the method instruction sequence, if not override method When it is determined that the machine language instruction sequence is generated and inherited by the determination means, the non-override information included in the method instruction sequence is not used, and the override information included in the method instruction sequence is not used. A program conversion apparatus , comprising: a replacement unit that generates a machine language instruction sequence in the case of an override method by using and replaces the method instruction sequence with the generated machine language instruction sequence . The method translation means includes:
Upon translating the override method call instruction, the translation said a non-override information, and one macro instruction containing both the override information in the method instruction sequence is table at one and directive including the method class information program conversion apparatus according to claim 1, characterized in that. The method translation means includes:
Upon translating the override method call instruction, according to the above methods class information, wherein the non-overriding information, characterized in that translating the method instruction sequence is table at one macroinstruction that includes all of the override information Item 2. The program conversion device according to Item 1 . The macro instruction is
Macro name, method class information, label name to call when non-override method is not an override method, offset value from the beginning of the object to be used when it is an override method as part of override information , and override information 4. The program conversion apparatus according to claim 3, wherein the program conversion apparatus comprises an offset value from the head of a method address storage table used when the method is an override method as a part .   The method translation means includes:
  In translating the override method call instruction, the non-override A non-override instruction that is a machine language instruction sequence when not an override method instead of information, and a method instruction sequence that includes an override instruction that is a machine language instruction sequence when it is an override method instead of the override information;
  The replacement means includes
  When replacing the method instruction sequence with a machine language instruction sequence when it is not an override method, only the unnecessary part other than the non-override instruction is removed from the method instruction sequence, and the method instruction sequence is replaced with the override method. When replacing with the machine language instruction sequence in a certain case, the processing should only be performed by removing unnecessary parts other than the override instruction from the method instruction sequence.
  The program conversion apparatus according to claim 1.

Images