JPH05265742A - Program patch system - Google Patents

Abstract

PURPOSE:To provide a program patch system which can be easily corrected and in which an original program and the correction history can be grasped. CONSTITUTION:In a patch system where a 1st object program 31 compiled from a source program 1 is emergently corrected, the correction information including the correction data on the program 1 and the information designating a patch area where the correction result is stored are described into the program 1. Then, the correction result is stored in a corrected area of the program 31 and also a designated patch area as necessary based on the correction information so that the corrected area of the program 1 has the same size as the program 31. A compiler 2 is provided with a correction means 5 which produces a 2nd object program 32. Then, both programs 31 and 32 are compared with each other and a discordant part is applied to the program 31 as the patch data.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program patch (emergency correction) system, and more particularly to a patch at a source program (source code) level for a target program (object program).

A program for operating a computer system is accompanied by a bug, and in recent years, the bug has also increased with the increase in the program scale. For this reason, patches, which are means for urgently modifying programs, are indispensable. Therefore,
There is a demand for a program patch method that is easy to modify and that can grasp the original program and the applied modifications.

[0003]

2. Description of the Related Art Conventional patch data is created by the following method. (1) Describe the modification points in the source code on the source program list. (2) Assemble list in which the machine language code is described,
Find the modified part from the modified source code described in (1) and replace the logic of the program to be modified with the machine language code to create patch data.

[0004]

The above-described patch execution method has the following problems. (1) Most of recent software is written and created in a high-level language, and many program creators do not understand the machine language, and it is very difficult to create the patch data in the machine language code. (2) Even if the machine language is understood, calculation of addresses is complicated and complicated, and calculation errors are likely to occur.

Therefore, it is an object of the present invention to provide a program patch system which is easy to modify and which can grasp the original program and the applied modification.

[0006]

FIG. 1 is a block diagram showing the principle of the present invention. In the figure, 1 is the source program, 2 is the
The compiler, 31 is a first target program obtained by compiling the source program 1 by the compiler 2,
4 is modification information written in the source program 1 and including modification data indicating the modification location and modification content and information designating a patch area for storing the modification result, and 5 is , Based on the modification information, the modification result of the source program 1 is newly modified corresponding to the modified part of the first target program 31 so that the size is the same as the load module of the first target program 31. The modifying means 6 provided in the compiler, which replaces the data and, if necessary, stores it in a designated patch area to create the second object program 32, is disclosed in [JP-A-01-201727 (August 14, 1st year) "Applied as a software patch method"], the first object program 31 and the second object program 32 are compared, and the inconsistent portion is regarded as patch data. And then the first objective program 31
Is a patch creating means for creating patch data to be applied to.

[0007]

In the program patch method for urgently correcting the first object program 31 obtained by compiling the source program 1 by the compiler 2, the correction information 4 is described in the source program 1 and indicates the correction location and the content of the correction. The correction information including the correction data and the information designating the patch area for storing the correction result is written at the source program 1 level, and the correction means 5 sets the correction location of the source program 1 based on the correction information as the first purpose. Make the first correction result so that it has the same size as the load module of program 31.
The target program 31 is replaced with new correction data corresponding to the part to be corrected, and if necessary, stored in a designated patch area to create a second target program 32,
Since the patch means 6 compares the first object program 31 and the second object program 32 and applies the unmatched portion to the first object program 31 as patch data, it is possible to patch the object program at the source program level. Becomes

[0008]

FIG. 2 is a block diagram showing an embodiment of the present invention. The source program 1a is an original source program (hereinafter referred to as source program) written in a high-level language (for example, C language), and the source program 1b
Is a program coded by adding modification information 4a described later to the source program 1a. Compiler 25
Is a compiling unit 2a for translating a source program into a machine language target program (hereinafter referred to as an object program), and one component of the present invention, the modification information 4a.
(3) of the procedure described later for the result corrected based on
The correction unit 5a performs the processing described in the section. The compiler 25 executes the source programs 1a and 1b,
Translate into object programs 31a and 32a.

The patch section 6a is described in Japanese Patent Application Laid-Open No. 01-20
No. 1727 (August 14, 1991) "Applied as a software patch method"], it compares the object programs 31a and 32a, creates inconsistencies as patch data, and creates this as the object program 31a. By applying to, it is edited into a format that can be executed by a computer and output as a load module.

The above procedure will be described in detail below. (1) As shown in FIGS. 3-9, in order to correct the patch for the object program 31a resulting from the translation of the source program 1a by the compiler 25 at the source level, , The modification information 4a on the source program 1a (that is, patch modification target mark "\", deletion target position mark "D"
\ ", Change source data mark" n \ ", and patch area definition mark" P \ ") are added and coded. (2) In the above (1), when the same program was changed multiple times, In order to be able to identify the latest source code based on the correction of the above, add the modified version number "n \" at the time of program modification (n is a number indicating the patch modified version.) (3) Compiler 25 Reflect the source code patch by the following method without changing the size of the object program 31a created from the input source code in the unmodified state (the state of the original source program 1a before the source level patch was changed). Create the created object program 32a.

(A) If there is no difference in the number of bytes used between the object program 31a (machine code level) before the change and the object program 32a (machine code level) after the change, use the changed source code To create the object program 32a (Fig. 4
See).

(B) Regarding the changed part, if the object program 31a before the change is larger than the used byte number of the object program 32a after the changed, the area of the used byte number before the change is not changed and Embed the object program 32a. The end of the changed object program 32a is the object program 31 before the change
When it is necessary to link with the next step of a, a jump instruction to the next step of the object program 31a before change is added to the end of the object program 32a after change (see FIG. 6).

(C) Regarding the changed part, if the object program 31a before the change is smaller than the used byte number of the object program 32a after the changed, the data exceeding the used byte number of the object program 31a before the change is stored in the patch area. Expand it to the empty area of and combine with a jump instruction (see Figure 8).

The above operation will be described in detail below with reference to FIGS. FIG. 3 is a diagram showing the state of the original source program. In order to secure the patch area, the statement static char patch [1000] is described in the source program 1a in advance, and the patch area definition mark "P \" (see) is added to the statement.
Is added.

FIG. 4 is a relational diagram (1) between the source program and the object programs before and after the change, in which the size of the object program 31a before the change and the object program after the change are changed.
The case where the sizes of 32a are equal is shown.

When the number of bytes of the instruction before change (c = a + b) and the number of bytes of the instruction after change (c = a-b) are equal, the compiler 25 only replaces the instruction code (A
DD → SUBTRACT).

FIG. 5 is a relational diagram (2) between the source program and the object programs before and after the change, in which the size of the object program 32a after the change is smaller than the size of the object program 31a before the change. Indicates.

When the number of bytes of the instruction () after the change is smaller than the number of bytes of the instruction () before the change, the non-operation instruction (NOP) instruction is packed by the reduced number of bytes (that is, + b). Alternatively, the compiler 25 creates the object program 32a by a method of branching to the next valid step a with a jump (JUMP) instruction.

FIG. 6 is a relationship diagram (3) between the source program and the object programs before and after the change, in which the size of the object program 32a after the change is larger than the size of the object program 31a before the change. Show the case.

If the number of bytes of the instruction () after the change is larger than the number of bytes of the instruction () before the change, the JUMP p instruction [insert the (JUMP p) instruction at the end of the changed area] By subtracting the minutes, expand the minutes to the unused area p of the patch area defined by using the (JUMP p) instruction, and then use the (JUMP a) instruction to branch to the next step a after the change. 25 is an object program 32a
To create.

FIG. 7 is a relational diagram (part 4) between the source program and the object programs before and after the change, showing a case where one statement is corrected a plurality of times.

When the same line is further changed () from the case change () shown in FIG. 6, the previous patch data in the patch area p is left as it is and the unused area q (JUMP
q) The compiler 25 creates the object program 32a by the method of expanding the new change data with an instruction.

FIG. 8 is a relationship diagram (No. 5) between the source program and the object programs before and after the change, and shows a case in which the statement (two) is added to one statement (). ..

As in the case of FIG. 6, when the number of bytes of the instruction (and two) after the change is larger than the number of bytes of the instruction () before the change, the (JUMP p) instruction is changed from the excess to the area of the changed portion. The amount obtained by subtracting the amount to be inserted at the end is expanded to the unused area p of the patch area defined in by using the (JUMP p) instruction, and then by the (JUMP a) instruction, the next step a The compiler 25 creates the object program 32a by branching to.

FIG. 9 is a diagram of the relationship between the source program and the object programs before and after the change (No. 6), showing a case where one statement is deleted. As in Fig. 4, by deleting the instruction (), the number of instruction bytes after the change becomes smaller than the number of instruction bytes before the change. Therefore, the NOP instruction is packed or the next valid step The compiler 25 branches to the object program 32a with the (JUMP a) instruction.
To create.

FIG. 10 is a flow chart showing an embodiment of the present invention, showing a patch data creation and implementation method.
Object program 32 created as above
Based on a, the load module after patch modification is created and executed as shown below.

(B) Unchanged (original source state before changing with source level patch) source program
The original object program 31a () translated based on 1a is incorporated into the execution environment file 8a () to be executed on a real machine and is executed as a load module.

(B) If it is necessary to modify the program thereafter, the above procedure is performed based on the source program 1b which is coded by adding the modification information 4a to the source program 1a.
The modified object program 32a () created according to (a)-(c) of (3) is created. Automatic generation of patch data by file comparison between the original object program 31a () and the changed object program 32a () by the patch section 6a [JP-A-01-201727 (August 14, 2001)] "Software patch method"] is performed, and the created patch data is stored in the patch data file 9a ().

(C) By applying the patch data created in (b) to the execution environment file 8a (), it is executed as a load module with the same logic as the object program 32a () after the change 1.

(D) After that, when a request for program modification is made, the object program 32a () after modification 2 is created based on the case shown in FIG. 7, and the same as the above (b) and (c). Process (d) and (e).

[0031]

As described above, according to the present invention, since the patch correction data can be created at the source program level, it is not necessary to understand the machine language, and the complicated address calculation as at the machine language level can be performed. It becomes unnecessary and can prevent the error of address calculation, and the program modification is easy,
Moreover, there is an effect that the original program and the correction history can be easily grasped.

[Brief description of drawings]

FIG. 1 is a block diagram of the principle of the present invention.

FIG. 2 is a block diagram showing an embodiment of the present invention.

FIG. 3 shows the state of the original source program

FIG. 4 is a relationship diagram (1) between the source program and the object program before and after the change.

FIG. 5 is a relationship diagram between the source program and the object program before and after the change (Part 2)

FIG. 6 is a relational diagram (3) between the source program and the object program before and after the change.

FIG. 7 is a relational diagram (4) between the source program and the object programs before and after the change.

FIG. 8 is a relational diagram (5) between the source program and the object programs before and after the change.

FIG. 9 is a relational diagram (6) between the source program and the object programs before and after the change.

FIG. 10 is a flowchart showing an embodiment of the present invention.

[Explanation of symbols]

 1 source program 1a, 1b source program 2,25 compiler 2a compilation part 4,4a modification information 5 modification means 5a modification part 6 patch means 6a patch part 8a execution environment file 9a, patch data file 31 first object program 32 second Object programs for 31a, 32a Object programs

Claims (4)

[Claims] 1. A first object program (3) obtained by compiling a source program (1) by a compiler (2).
In the program patch method for emergency correction of 1), the source program described in the source program (1), including the correction data indicating the correction point and the correction content, and the information designating the patch area for storing the correction result. Program (1)
Modify the modification information (4) written in the level and the modification location of the source program (1) based on the modification information (4) so that it has the same size as the load module of the first object program (31). The first object program corresponding to the result
The compiler (31) is replaced with new correction data corresponding to the portion to be corrected, and if necessary, stored in the specified patch area to create the second object program (32). The correction means (5) provided in (2) is compared with the first object program (31) and the second object program (32), and the inconsistent portion is used as patch data for the first object program (31). And a patch creating means (6) for creating patch data to be applied to the program patch method. 2. The correction information (4) includes a patch on the source program (1), a mark indicating a patch correction point, a mark indicating a deletion point, a mark indicating change / correction data, and an area for storing the correction result. 2. The program patch system according to claim 1, wherein the program patch system is coded by adding a mark indicating information to be designated. 3. The modification / modification data of the modification information (4) is coded so as to include an updated modification version each time the modification is made when the same program is modified multiple times. The program patch method according to claim 2. 4. The correction means (5) is configured so that the storage capacity of the second object program (32) is the first object program (3).
The size of the storage area required by the correction result is equal to the size of the area occupied by the portion to be modified of the first object program (31), which is equal to or larger than the storage capacity of 1). a) When they are equal, the modification result is stored in the modified part of the first object program (31), and (b) when small,
The modification result is stored in the modified part of the first object program (31), and a no-operation instruction is applied to the rest of the modified part, or the stored modified result is followed by the modified part. Add a branch instruction to branch to the instruction, (c)
When the value is large, a branch instruction for branching to the patch area is stored in the patched area in addition to a part of the modification result, and the remaining part of the modification result is stored in the patch area, whereby the second object program (32) The program patch method according to claim 1, wherein