JPH05257672A - Patch processing system for compiled code object - Google Patents

Abstract

PURPOSE:To execute a correction of the complied code object in a patch-work, in a language processing system in which an interpreter loads the complied code object generated and outputted by a compiler in a storage area and executes its execution management. CONSTITUTION:A discrimination part 81 of a loader 8 in an interpreter 3 recognizes a correcting part based on correction information 71, and determines its correction method. In the case the correction is executed by a short instruction string correcting method, a short instruction string correcting means 82 rewrites the contents of its correction part by the machine language instruction string 61 concerned. In the case the correction is executed by a long instruction string correcting method, a long instruction string correcting means 83 rewrites the contents of its correction part to an instruction for branching to a patch area 42, and also, stores the machine language instruction string 61 concerned and the instruction for branching to just after the correcting part in an additional patch area 9. A correction file loading means 84 loads the corrected compiled code object, and the contents of the additional patch area 9 in a storage area 4.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a language processing system which comprises an interpreter and a compiler, and in which the interpreter loads a compiled code object generated and output by the compiler into a storage area and manages its execution, and more particularly to a compiled code object Patch processing method.

[0002]

2. Description of the Related Art A type of language processing system is composed of an interpreter that interprets and executes a source program and data objects, and a compiler that translates the source program to improve execution efficiency. The compiler compiles the source program in function units. There is a language processing system in which an interpreter loads a compiled code object including a machine language instruction sequence to be output by the interpreter and manages the execution. As a document describing such a language processing system, for example, Japanese Patent Application No. 63-3108.
No. 27 attached to the specification and drawings.

By the way, if the existing compiled code object generated by compiling includes a partially invalid machine language instruction string, the intended function cannot be realized, so that the correction is necessary.

Generally, as a method of modifying the compile unit, there are a method of modifying the source program and recompiling it, and a method of directly modifying the machine language in the compile unit by a so-called patch. In some language processing systems, the compiled code object does not have the compile unit type defined on its operating system, so that it cannot be used even if there is an existing patch system for the compile unit.

Therefore, conventionally, a modified compiled code object is generated by modifying the source program and recompiling it.

[0006]

Therefore, it takes a lot of labor and time to recompile the entire source program even if the machine language instruction sequence to be modified is a small part of the whole.

Further, if the compile environment at the time when the original compiled code object was generated cannot be reproduced, it cannot be recompiled and therefore cannot be corrected.

The present invention has been made in view of the above circumstances, and an object thereof is to provide a novel compiled code object patch processing system capable of modifying an already existing compiled code object by a patch system. To provide.

[0009]

In order to achieve the above object, the present invention provides a compiler that translates a source program and outputs a compiled code object, and a compiled code object output by the compiler into a storage area. In a patch processing method of a compiled code object in a language processing system including an interpreter that interprets and executes a file, a file that stores a compiled code object to be modified and a patch image storage that stores a machine language instruction string that is the content of modification Department,
Modification information input means for inputting modification information indicating a relationship between a modification position of the compiled code object to be modified and a machine language instruction sequence in the patch image storage unit to be applied to the modification position; and an additional patch area. And
The loader in the interpreter recognizes the modified portion of the compiled code object in the file based on the inputted modification information, and modifies the modified portion by the short instruction string correcting method or the long instruction string correcting method. And a corresponding machine language instruction sequence stored in the patch image storage unit for the correction location of the compiled code object determined to be corrected by the short instruction sequence correction method by the determination unit. And a short instruction string correcting means for rewriting with a command for branching to a patch area of the compiled code object determined to be corrected by the long instruction string correcting method by the judging section, and stored in the patch image storing section. The corresponding machine language instruction sequence and the instruction to return the control to the correction location are added to the additional patch area. It includes a long instruction string correcting means for paying, and fix the load means for loading the compiled code object and content of the additional patch area after the correction in the storage area.

[0010]

In the patch processing method for the compiled code object of the present invention, the file holds the compiled code object to be modified, the patch image storage section holds the machine language instruction string as the modification content, and the modification information is input. The means inputs modification information indicating a relationship between a modification position of the compiled code object to be modified and a machine language instruction string in the patch image storage unit to be applied to the modification position.

When the compiled code object is loaded by the loader in the interpreter, the determination unit in the loader recognizes the corrected portion of the compiled code object in the file based on the input correction information and shortens the corrected portion. It is determined whether the instruction sequence modification method or the long instruction sequence modification method is used. If it is determined that the short instruction string modification method is used, the short instruction sequence modification means determines the modification location of the compiled code object. When it is determined to rewrite with the corresponding machine language instruction string stored in the patch image storage unit and to correct with the long instruction string correction method, the long instruction string correction means branches the correction location of the compiled code object to the patch area. In addition to rewriting with a command, the corresponding machine language command sequence stored in the patch image storage section Storing instructions and to return control to where the additional patch area.

Then, the modified file loading means loads the modified compiled code object and the contents of the additional patch area into the storage area.

[0013]

Embodiments of the present invention will now be described in detail with reference to the drawings.

Referring to FIG. 1, a language processing system 1 to which the present invention is applied includes a compiler 2, an interpreter 3 and a storage area 4, a file 5, a patch image storage section 6, a correction information input section 7 and an additional patch. Area 9 is connected.

The interpreter 3 has a loader 8 for loading the compiled code object into the storage area 4, and the loader 8 is provided with a correction section 85 and a correction file loading means 84. Further, the correction unit 85 includes a determination unit 81, a short instruction sequence correction unit 82, and a long instruction sequence correction unit 8.
3 is provided.

A compiled code object 51 to be modified is stored in the file 5. The compiled code object 51 is generated and output by the compiler 2 translating a source program (not shown).

The patch image storage unit 6 stores a machine language instruction sequence 61 which is the content of modification.

The modification information input unit 7 is means for inputting modification information 71 indicating the relationship between the modification position of the compiled code object 51 to be modified and the machine language instruction sequence 61 to be applied to the modification position. ..

The language processing system 1 achieves a predetermined function by the interpreter 3 loading the compiled code object output by the compiler 2 into the storage area 4 and interpreting and executing the compiled code object. If a part of the object contains an illegal machine language instruction, the intended function cannot be achieved. Therefore, patch processing for replacing the compiled code object with a correct machine language instruction is performed. In this embodiment, the patch processing is performed in the loader 8 of the interpreter 3 as follows.

First, the user creates a correct machine language instruction sequence 61 to be used for replacement, stores it in the patch image storage unit 6, and applies it to the modified position of the compiled code object 51 to be modified and its modified position. The modification information 71 indicating the relationship with the machine language instruction sequence 61 in the power patch image storage unit 6 is created.

For example, a machine language instruction string of a total of 8 bytes at the 100th to 107th bytes from the head of the compiled code object is modified by a 4-byte machine language instruction M1 as shown in FIG. The machine language instruction of 8 bytes in total at the 207th byte is a machine language instruction M2-1, M2-2, M of 12 bytes in total as shown in FIG.
In the case of correction by 2-3, a machine language instruction sequence 61-1 composed of machine language instructions M1 and machine language instructions M2-1, M2-
A machine language instruction sequence 61-2 composed of M2-3 and M2-3 is stored in the patch image storage unit 6, and (correction start position = 100th byte, correction end position = 108th byte, applied machine language command sequence). = 61-1) correction information,
(Correction start position = 200th byte, correction end position = 20
The modification information 71 including the modification information of the 8th byte, the applied machine language instruction string = 61-2) is created.

When such modification information 71 is input from the modification information input unit 7 and the interpreter 3 is instructed to load the compiled code object 51, the loader 8 performs the following processing.

Judgment unit 81 in correction unit 85 of loader 8
Reads one piece of correction information from the correction information input unit 7,
The size of the modified part of the compiled code object 51 indicated by the modification information is compared with the size of the machine language instruction string to be applied to the modified part, and if the former is larger than the latter or equal, the modification method is short instruction. If the former is smaller than the latter, the modification method is determined to be the long instruction string modification method.

The short instruction sequence correcting means 82 of the correction unit 85 determines the correction location of the compiled code object 51 which is determined by the determination unit 81 to be corrected by the short instruction sequence correction method.
It is rewritten with the corresponding machine language instruction sequence stored in the patch image storage unit 6.

On the other hand, the long instruction sequence correcting means 83 is provided with the judging section 8
The modified location of the compiled code object 51 determined to be modified by the long instruction sequence modification method according to 1 is rewritten by the instruction branching to the patch area 42, and the corresponding machine language instruction sequence stored in the patch image storage unit 6 is stored. The instruction to return the control to the correction location is stored in the additional patch area 9.

For example, in the case of FIG. 2, (correction start position = 10
Based on the correction information of the 0th byte, the correction end position = 108th byte, the applied machine language instruction string = 61-1), the determination unit 81 determines that the size of the correction point = 8 (108-100) bytes and the correction point. Machine language instruction sequence 61-1 to be applied to
Size = 4 bytes, and the former is smaller than the latter, it is decided to modify by the short instruction sequence modification method.

For this reason, the short instruction sequence correcting means 82 operates as shown in FIG.
As shown in, the contents of the 100th byte of the modified portion of the compiled code object 51 are the machine language instruction sequence 61-
1 is rewritten by the machine language instruction M1 that composes 1, and the remaining 4 bytes of the corrected portion are rewritten by the NOP instruction which is an instruction that does nothing.

Further, (correction start position = 200th byte,
Correction end position = 208th byte, applied machine language instruction string = 6
Based on the modification information 1-2), the determination unit 81 determines that the size of the modified part = 8 (208-200) bytes and the size of the machine language instruction sequence 61-2 applied to the modified part = 12.
The byte is compared, and the former is larger than the latter, so it is decided to correct by the long instruction sequence correction method.

For this reason, the long instruction sequence correction means 83 is provided in FIG.
As shown in, the contents of the 200th byte of the corrected portion of the compiled code object 51 are rewritten by the instruction B1 branching to the patch area 42. Further, in the 16-byte area from the head of the additional patch area 9, the machine language instruction M that constitutes the machine language instruction sequence 61-2 to be applied to the correction location at this time
2-1 and M2-2 and M2-3, and an instruction that transfers control to the compiled code object 51 so that the end of the correction point, that is, the next instruction of the machine language instruction sequence to be corrected, is executed after these instructions are executed. B2 and are stored.

Next, when the above-described processing of the modifying unit 85 is completed, the modified file loading means 84 of the loader 8 causes the modified compiled code object 5 in the file 5 to be modified.
1 is loaded into the area 41 for loading the compiled code object in the storage area 4, and the contents of the additional patch area 9 are loaded into the patch area 42 of the storage area 4.

By performing the above processing,
The modified compiled code object 51 is loaded in the storage area 4.

Next, the area from the end of the compiled code object of one function on the storage area 4 is used as the patch area 42, and the area from the end of the compiled code object 51 on the file 5 is additionally patched. An embodiment used as the area 9 will be described.

FIG. 3 shows a loader 8 in such an embodiment.
5 is a flowchart showing an example of processing executed by the. Note that in FIG. 3, steps S1 to S4 are the determination unit 81, step S5 is the short instruction sequence correction means 82, and steps S6 to S.
10 is executed by the long instruction sequence correction means 83, and step S11 is executed by the correction file loading means 84.

As shown in FIG. 3, when the loader 8 starts its operation, first, the pointer PE for managing the used area of the patch area 42 is initialized to 0 (S1).

Next, one piece of correction information is read from the correction information input section 7 (S2), and it is judged whether or not the correction information has ended (S3). If not, the correction information read in step S2 this time is used. Based on this, the size of the modified part of the compiled code object 51 is compared with the size of the machine language instruction string to be applied to the modified part (S4), and if the former is larger than the latter or the same, the modification method is changed to the short instruction string modification method. If the former is smaller than the latter, the modification method is determined to be the long instruction sequence modification method. If the short instruction sequence correction method is used, step S5 is executed and the process returns to step S2.
When the correction is performed by the long instruction sequence correction method, steps S6 to S8
Is executed and the process returns to step S2.

Therefore, in the example shown in FIG. 2, in the case of the correction information (correction start position = 100th byte, correction end position = 108th byte, applied machine language instruction string = 61-1), the size of the correction point Is larger than the size of the machine language instruction sequence 61-1 to be applied to the correction location, it is determined to be corrected by the short instruction sequence correction method (YES in S4), and the compiled code object 51 is corrected as shown in FIG. The content of the 100th byte of the location is rewritten by the machine language instruction M1 that constitutes the machine language instruction sequence 61-1 and the remaining 4 portions of the correction location are rewritten.
The byte is rewritten by the NOP instruction, which is an instruction that does nothing (S5).

Further, (correction start position = 200th byte,
Correction end position = 208th byte, applied machine language instruction string = 6
In the case of the correction information 1-2), since the size of the corrected portion is smaller than the size of the machine language instruction string 61-2 applied to the corrected portion, it is determined that the correction is performed by the long instruction string correction method (NO in S4).

Therefore, first, step S6 is executed,
The branch width from the correction location to the location currently used in the patch area 42 is calculated.

In the case of this embodiment, since the area from the end of the compiled code object is used as the patch area, the branch width can be calculated by the following formula. Branch width = size of compiled code object 51-correction start position of current correction point + pointer PE value

The compiled code object 5
As the size of 1, the size described in the header information in the compiled code object 51 as shown in FIG. 4 is used.

Therefore, assuming that the size of the compiled code object 51 is 1000 bytes, the modification start position of the modification location this time is the 200th byte and the value of the pointer PE at the present time is 0, so the branch width is 1000-200.
+ 0 = 800.

Next, in step S7, the branch width 80
A branch instruction of 0 is generated, and as shown in FIG. 4, the content at the beginning of the modified portion is rewritten by the branch instruction B11.

The machine language instruction example 61-2 used for the correction this time is 12 bytes, and 4 bytes are required as an instruction branching immediately after the correction location after execution of this instruction sequence, so that it corresponds to a total of 16 bytes. The value "16" is set to the pointer P
It is added to E (S8), and the process returns to step S2.

When the above processing is performed and YES is determined in step S3, that is, when all the correction information 71 has been processed, the process proceeds to step S9, and the machine language instruction sequence by all the long instruction sequence correction methods is processed. , A modified area branch instruction is generated and added, and is added collectively to an additional patch area 91 behind the compiled code object 51 in the file 5.

In the case of FIG. 2, since there is only one correction point by the long instruction sequence correction method, as shown in FIG. 4, machine language instructions M2-1, M2-2, M2-3 applied to the correction point.
And the modified area branch instruction B21 that branches at the 208th byte of the compiled code object 51 are stored in the additional patch area 91.

Next, the size information in the compiled code object 51 of FIG. 4 is modified by the size of the machine language instruction string stored in the additional patch area 91 (S10), and then the modified information in the file 5 is corrected. The compiled code object 51 (including the contents of the additional patch area) is loaded into the storage area 4.

Next, an area different from the area from the end of the compiled code object on the storage area 4 and having the head designated by a certain register R and shared by a plurality of compiled code objects is set. An embodiment will be described in which the patch area 42 is used and an additional patch area 9 is provided for each compiled code object. In this case, each additional patch area 9 is provided in the file 5 in which the corresponding compiled code object is stored.

FIGS. 5 and 6 are flow charts showing an example of the processing executed by the loader 8 in such an embodiment.

5 is different from the process of FIG. 3 in that steps S6 to S8 of FIG.
21, S22, and steps S9 to S11 in FIG.
Has been changed to steps S23 to S31, so only the operation relating to the difference will be described below.

When the loader 8 determines in step S4 that the correction is to be made by the long instruction sequence correction method, it generates a temporary subroutine branch instruction that uses the register R and the stack and corrects the compiled code object 51 in the file 5. Is rewritten with the temporary subroutine branch instruction and the NOP instruction if necessary (S21).

Here, the temporary subroutine branch instruction is
An instruction (original subroutine branch instruction) that branches to a location separated by the branch width described in the instruction after stacking the current address, and the branch width has not yet been determined. An instruction in which a mark and a certain numerical value are embedded in the description part of.

In the case of the present embodiment, such a temporary subroutine branch instruction is used so that the patch area in the storage area 4 is shared by a plurality of compiled code objects, but the additional patch area is used for each compiled code. Since the object is managed independently and the loading is also done separately, which part of the patch area and after which the machine language instruction string by the method of modifying the long instruction string of the compiled code object currently being processed is stored Is due to not being determined at this point.

The numerical value embedded in the branch width portion of the temporary subroutine branch instruction is the value of the pointer PE.

Therefore, in the case of the modified portion of the 200th byte to the 203rd byte of the compiled code object 51 of FIG. 2, the value of the pointer PE at that time is 0, so that the branch width portion is a temporary subroutine branch instruction. A temporary subroutine branch instruction in which a mark indicating "1" and the numerical value 0 are embedded is generated, and as a result, 200
The contents of the byte are rewritten, and the contents of the following 4 bytes are rewritten by the NOP instruction.

After the execution of step S21, in step S22, a machine language instruction example 61- used for this correction is displayed.
The pointer PE is updated by 16 bytes corresponding to the total size of the size of 2 and the size of the instruction to return the control to the corrected position after the execution of this instruction sequence.

Next, when it is determined in step S3 that the processing of all modification information has been completed, a modification area return command is generated and added to the machine language command string by all the long command string modification methods, and the modification area return command is added as shown in FIG. The files are collectively stored in the additional patch area 92 in the file 5 (S23).

Here, the modified area return instruction is an instruction for returning to the address stacked on the stack.

In the case of FIG. 2, since there is only one correction point by the long instruction sequence correction method, as shown in FIG. 7, machine language instructions M2-1, M2-2, M2-3 applied to the correction point.
And the correction area return command B22 are added patch area 9
Stored in 2.

After the above processing, the modified compiled code object 51 in the file 5 is processed as follows.
And the contents of the additional patch area 92 are loaded into the storage area 4.

First, the contents of the additional patch area 92 are loaded into the patch area 42 'of the storage area 4 of FIG. 7 (S2).
4). At this time, if the patch area 42 'is empty, the patch area 42' is loaded in the first area, but if another content is already loaded, it is loaded in the area immediately after that. Then, at this time, the load position indicating from which part of the patch area 42 'the data is loaded is set in the variable L (S25). In the case of FIG. 7, since it is loaded in the 10th byte and later of the patch area 42 ', L = 10 is set.

Next, the modified compiled code object 51 in the file 5 is read by 4 bytes (S2
6), it is determined whether the read 4-byte contents are a temporary subroutine branch instruction (S28), and if the contents are not a temporary subroutine branch instruction (NO in S28), the read contents are stored in the storage area 4 of FIG. It is loaded into 41 (S29).

On the other hand, when the read content is a temporary subroutine branch instruction (YES in S28), the temporary subroutine branch instruction is modified using the value of the variable L (S30), and the modified subroutine branch instruction is stored in the storage area. Area 41 of 4
(S31).

For example, in the case of the temporary subroutine branch instruction B12 of FIG. 7, the value embedded in the branch width part is 0 and the value of the variable L is 10, so the value 1 obtained by adding 0 and 10 is 1.
0 is written as a branch width in the branch width portion and the subroutine branch instruction B13 is loaded.

The above processing is repeated, and step S
When it is determined in 27 that all the contents of the compiled code object 51 have been processed, the process ends.

Next, an area different from the area from the end of the compiled code object in the storage area 4, the area whose head is designated by a certain register R and which is shared by a plurality of compiled code objects is set. It is used as a patch area, and the additional patch area 9 is configured by a patch storage file shared by a plurality of compiled code objects to manage the patch contents in function units in compiled code object units, and to perform one language processing. An example of collectively storing and managing patch contents of all functions in the system will be described.

FIG. 8 shows a loader 8 in such an embodiment.
5 is a flowchart showing an example of processing executed by the.

The process of FIG. 8 is different from the process of FIG. 3 in that step S41, step S41, and step S41 of FIG.
S42 is inserted, and steps S6 to S8 are step S4.
3 to S45, and steps S9 to S11 are changed to steps S46 and S47. Less than,
Only the operation related to the difference will be described.

When there are a plurality of compiled code objects to be loaded, the loader 8 first pays attention to one of them (S41), and steps S2 to S5 and S43 to S for this noted compiled code object.
The process of 45 is performed, and when the process is completed, another compiled code object is focused on and the same process is performed. When the processes of steps S2 to S5 and S43 to S45 are performed for all the compiled code objects (S
(YES in 42), the processes of steps S46 and S47 are performed.

In the process of processing a certain compiled code object, if the loader 8 determines in step S4 to modify by the long instruction string modifying method, the register R
And a subroutine branch instruction that uses the stack is generated, and the compiled code object 5 in the file 5 is generated.
The correction point of 1 is rewritten by the subroutine branch instruction and the NOP instruction if necessary (S43).

In the case of this embodiment, all the patch contents for the function are stored in the common patch storage file 93 shown in FIG. 9 and the contents are stored as they are in the patch area 42 "of FIG. The branch width of the branch instruction can be determined at this point, that is, the value itself of the pointer PE at the current point becomes the branch width.

Next, a modified area return instruction is generated,
Added to the machine language instruction sequence by this long instruction sequence correction method,
It is stored in the patch storage file 93 (S44). Then, the value of the pointer PE is updated by the size of the machine language instruction string and the modified area return instruction (S45).

Therefore, in the case of the corrected portion of the 200th byte to the 203rd byte of the compiled code object 51 of FIG. 2, the value of the pointer PE at that time is 0, so that the branch width = 0 subroutine as shown in FIG. Branch instruction B1
3, the contents of the 200th byte of the modified portion of the compiled code object 51 are rewritten, and the contents of the following 4 bytes are rewritten by the NOP instruction.

When the loader 8 finishes the processing for the compiled code object 51, it performs the same operation if there is a compiled code object to be processed next.
Here, as shown in FIG. 9, there is a file 5'that stores another compiled code object 51 ', and when the correction location is to be modified by the long instruction string modification method, the subroutine branch instruction to be inserted at the modification location As the branch width, the value 16 of the pointer PE at that time is used, and the machine language instructions M3-1 and M3-2 and the correction area return instruction B23 that form the machine language instruction sequence used in the long instruction sequence correction method are used.
Is stored immediately after the correction area return command B22 in the patch storage file 93.

When the modification process for all the required compiled code objects is completed as described above (YES in S42), the loader 8 stores the modified compiled code objects 51, 51 'in the storage area 4
(S46), the contents of the patch storage file 93 are loaded into the patch area 42 ″ (S47), and the process is terminated.

[0075]

As described above, according to the present invention,
You can directly modify an already existing compiled code object.

Therefore, a modified compiled code object can be obtained without recompiling the source program, and it is particularly effective when the machine language instruction sequence to be modified is only a part of the whole.

Further, even when the compilation environment at the time when the original compiled code object is generated cannot be reproduced, the modified compiled code object can be generated.

[Brief description of drawings]

FIG. 1 is a block diagram showing an example of a language processing system to which the present invention is applied.

FIG. 2 is a diagram showing an example of the contents of a machine language instruction string used for modification, modification information, an additional patch area, and an example of a compiled code object after modification.

FIG. 3 is an embodiment in which an area from the end of a compiled code object of one function on a storage area is used as a patch area, and an area from the end of a compiled code object on a file is used as an additional patch area. 5 is a flowchart showing an example of processing executed by a loader in FIG.

FIG. 4 shows an example of an instruction string stored in an additional patch area set in an area from the end of a compiled code object on a file, and an example of contents of a modified portion of a compiled code object modified by the instruction. FIG.

FIG. 5 is an area different from the area from the end of the compiled code object in the storage area, where the head is designated by a predetermined register and shared by a plurality of compiled code objects is used as a patch area. 15 is a flowchart showing a part of an example of processing executed by a loader in the embodiment in which an additional patch area is provided for each compiled code object.

FIG. 6 is a flowchart showing an example of a process that follows the process of FIG.

FIG. 7 shows an example of the contents of a patch area which is different from the area from the end of the compiled code object in the storage area and whose head is designated by a predetermined register and which is shared by a plurality of compiled code objects. FIG. 7 is a diagram showing an example of contents of an additional patch area provided for each compiled code object and an example of contents of a compiled code object after correction.

FIG. 8 is an area different from the area from the end of the compiled code object in the storage area, the area whose head is designated by a predetermined register and shared by a plurality of compiled code objects is used as a patch area. 15 is a flowchart showing an example of processing executed by the loader in the embodiment in which the additional patch area is configured by a patch storage file shared by a plurality of compiled code objects.

FIG. 9 shows an example of the contents of a patch area which is different from the area from the end of the compiled code object in the storage area and whose head is designated by a predetermined register and which is shared by a plurality of compiled code objects. FIG. 5 is a diagram showing an example of contents of a patch storage file and an example of contents of a compiled code object after correction.

[Explanation of symbols]

1 ... Language processing system 2 ... Compiler 3 ... Interpreter 4 ... Storage area 5 ... File 6 ... Patch image storage section 7 ... Correction information input section 8 ... Loader 9, 91 ... Additional patch area 41 ... Area for loading compiled code object 42, 42 ', 42 "... Patch area 51, 51' ... Compiled code object 61, 61-1, 61-2 ... Machine language instruction sequence 71 ... Correction information 81 ... Judgment unit 82 ... Short instruction sequence correction means 83 ... Long instruction sequence correction means 84 ... Correction file loading means 85 ... Correction section 93 ... Patch storage file

Claims (4)

[Claims] 1. Compiled code in a language processing system including a compiler that translates a source program and outputs a compiled code object, and an interpreter that loads the compiled code object output by the compiler into a storage area and interprets and executes the object. In the object patch processing method, a file that stores a compiled code object to be modified, a patch image storage unit that stores a machine language instruction sequence that is the content of modification, a modification position of the compiled code object to be modified, and Correction information input means for inputting correction information indicating a relationship with a machine language instruction sequence in the patch image storage unit to be applied to a correction position; and an additional patch area, and a loader in the interpreter, Based on the correction information entered, The determination unit that recognizes the correction location of the compiled code object in the file and determines whether the correction location is corrected by the short instruction sequence correction method or the long instruction sequence correction method, and A short instruction sequence correcting means for rewriting a modified portion of the compiled code object determined to be corrected by the instruction sequence correction method with a corresponding machine language instruction sequence stored in the patch image storage unit; and a long instruction sequence by the determination unit. The modified location of the compiled code object determined to be modified by the modification method is rewritten with an instruction for branching to the patch area, and control is returned to the corresponding machine language instruction string stored in the patch image storage section and the modified location. Instructions for storing in the additional patch area, and the compiled code object after the modification. -Object and patching method compiled code object, characterized in that it comprises a modified file loading means for loading the contents of the additional patch area in the storage area. 2. An area from the end of the compiled code object on the storage area is used as the patch area, and an area from the end of the compiled code object on the file is used as the additional patch area. In addition, the long instruction sequence correction means rewrites the correction location of the compiled code object determined by the determination unit to be corrected by the long instruction sequence correction method with an instruction branching to the area currently used in the patch area. At the same time, the corresponding machine language instruction sequence stored in the patch image storage unit and the instruction branching to the correction location are stored in the additional patch area, and the size of the machine language instruction sequence stored in the additional patch area is further stored. A contract characterized by only modifying the size information of the compiled code object. Patching scheme compiled code object claim 1. 3. The patch is an area different from the area from the end of the compiled code object in the storage area, the area whose head is designated by a predetermined register and shared by a plurality of compiled code objects. While being used as an area, the additional patch area is provided for each compiled code object, and the long instruction sequence correction means is for the compiled code object determined to be corrected by the determination unit by the long instruction sequence correction method. The correction location is rewritten with a temporary subroutine branch instruction for branching to the patch area using the register and stack, and the corresponding machine language instruction string stored in the patch image storage unit and the stack are moved to the correction location. Use the return command to return control to the additional patch area The correction file loading means loads the contents of the additional patch area into the storage area when the corrected compiled code object and the contents of the additional patch area corresponding thereto are loaded into the storage area. 2. The patch processing method for a compiled code object according to claim 1, wherein the temporary subroutine branch instruction in the modified compiled code object is modified based on the area. 4. The patch is an area different from the area from the end of the compiled code object in the storage area, the area whose head is designated by a predetermined register and which is shared by a plurality of compiled code objects. When used as an area, the additional patch area is configured by a patch storage file shared by a plurality of compiled code objects, and the long instruction sequence correction means corrects the long instruction sequence correction method by the determination unit. The corrected location of the determined compiled code object is rewritten by a subroutine branch instruction for branching to the area currently used in the patch area by using the register and stack, and the corresponding location stored in the patch image storage section is rewritten. Use the stack for the machine language instruction string and the modified part And a return instruction for returning control to the patch storage file, the modified file loading means loads the modified compiled code object into the storage area and the contents of the patch storage file into the patch area. The method for patching a compiled code object according to claim 1, wherein the patch processing method is for loading.