JP2000330780A - Software patch data automatic generation device - Google Patents

Abstract

(57) [Summary] [PROBLEMS] To automatically compare patches for software products developed in a high-level language and optimized by a compiler by comparing a high-level language source before correction with a high-level language source corrected by a program corrector. Generated. A means for correcting a master source, a means for comparing a master source with a corrected source and recording comparison information in a function unit in a file, and a method for updating all static variables that have been changed or added to the patch revision Means for generating a synthesized source to be placed in the additional static variable section for use; means for generating a synthesized source object; means for generating a modified load module and a modified static variable area; and modified load module. A means for patching the instruction code at the head of the above-before-change function to an unconditional branch instruction to the head of the function after the change, and a means for using only the patch code section for patch revision and the unconditional branch instruction as patch data; And

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to an apparatus for automatically generating patch data for a software product developed in a high-level language.

[0002]

2. Description of the Related Art Conventionally, when modifying a software product such as an embedded software or a microprogram developed in a high-level language, there are two cases; There are cases where "partial correction (revision up) by applying a patch in assembler language without taking a link". In the case of large general-purpose computers, in order to reduce the time required to correct programs when the system is operating, and to minimize the inspection time required to confirm that the corrected software operates without degrading, program modification using patches is usually performed. Do.

Conventionally, the above-mentioned patches have been manually created. However, the productivity is lower than that of high-level languages, and bugs such as erroneous stack operations are frequently introduced. Recently, the optimization technology of compilers has advanced remarkably, and RISC (Reduced I
nstruction Set Computer) In order to make a processor execute instructions efficiently, the compiler generates an instruction execution order different from the CPU instruction execution order intended by the software developer. It's getting harder.

[0004] From the above background, instead of manually modifying the software using the assembler language,
There has been proposed a device that only manually corrects a high-level language source and automatically generates patch data from the corrected source.

For example, in Japanese Patent Application Laid-Open No. 5-73292,
When updating a ROM program, a method has been proposed in which the updated subroutine is stored in a patch area, the address is written in a jump table, and the updated subroutine is called according to the jump table instead of the CPU calling the subroutine. ing.

In Japanese Patent Application Laid-Open No. 10-3383, a part where a difference is detected between a source file before correction and a source file after correction is divided into units of variables and functions, and the divided source files are compiled. There has been proposed a method of generating a patch from difference information between a generated object and an object before correction.

[0007]

SUMMARY OF THE INVENTION The above-mentioned Japanese Patent Laid-Open No. 5-73 is disclosed.
In a method of storing only an updated function in a patch area as in the conventional method described in JP-A-292-292, means for automatically detecting an updated function is not provided.
If a static variable is added in an updated function, the address of the static variable will be shifted, causing a difference in the program code that refers to the static variable, resulting in a huge patch data. was there.

[0008] In addition, there is a problem that the patch cannot be applied during the operation of the system due to the deviation of the address of the static variable. Further, there is a problem that patch data cannot be generated because a case where a function is added is not considered.

Further, as in the conventional method described in the above-mentioned Japanese Patent Application Laid-Open No. H10-3383, a portion where a difference is detected between a source file before correction and a source file after correction is determined in units of variables and functions. In the method of dividing the source file, compiling the divided source files, and generating a patch from the difference information between the generated object and the object before correction, if a static variable in the function is added, the function is added. There is a problem that patch data cannot be generated because the case is not considered.

Therefore, the present invention provides the above-described static variable,
This is done to solve the problem that patch data cannot be generated when a function is added. The only manual operation is to modify the source using a high-level language. Generates a synthesized source that retains all functions before and after modification, allocates all functions including the deleted functions on the master source to the same address as the master load module, and assigns the modified / added functions to each patch revision patch cord Generates a modified load module with the static variables added / changed in the function placed in the section and the patch added static variable section according to the patch revision, and patches the first instruction code of the function before the change. Load module after unconditional branch instruction patched to unconditional branch instruction to function after change in code area and master load module And the difference information, that is, the patch code section for the patch revision (where the function changed and renamed in the correction source and the added function are located) and the unconditional branch instruction (the head of the function before the change) (In which the instruction code is patched to the unconditional branch instruction to the beginning of the function after the change) is used as the patch data to automatically generate a patch even if the program code is optimized by the compiler. The purpose of the present invention is to enable efficient operation of patch management.

[0011]

In order to achieve the above object, an automatic patch generation apparatus according to the present invention firstly corrects a master source and sets it as a post-correction source (1 in FIG. 1).
Source file correction means) and means for comparing the master source with the corrected source to record information of the added / changed / deleted function in a function / static variable comparison result storage file (FIG. 1: 2: source comparison)・ Recording means and composite source (All functions before and after modification are retained, and all functions on the master source are allocated at the same address as the master load module.
Allocated functions / added functions are placed in the patch code section for the patch revision, all static variables used in the master source are located at the same address as the master load module, and all modified / added static Means for generating variables (source for allocating variables to the additional static variable section for the patch revision) (3 in FIG. 1), means for compiling the synthesized source to generate a synthesized source object (4 in FIG. 1), and modification Means (5 in FIG. 1) for linking the master object and the synthesized source object for the unmodified source to generate a modified load module and a modified static variable area, and the head of the pre-change function on the modified load module Patch code to the unconditional branch instruction to the beginning of the post-change function, and load module after patching the unconditional branch instruction The resulting unit (6 in FIG. 1),
The master load module and the unconditional branch instruction are compared with the post-patch load module, and the difference information, that is, the patch code section for the patch revision (functions whose names have been changed and added by the correction source and added functions are located) Means for using unconditional branch instructions (the instruction code at the head of the pre-change function is patched to the unconditional branch instruction to the head of the post-change function) as patch data (7 in FIG. 1);
An automatic patch generation device is provided.

According to the present invention, in order to generate a synthetic source, a master source is copied to set an initial value of the synthetic source (31 in FIG. 3: synthetic source initial value setting means).
And the function / static variable comparison result storage file 220 is referenced, and no processing is performed for functions that have not been changed / deleted, and changes have been made for functions that have been changed in the source after correction. No processing is performed on the caller of the modified function, and the modified function body is added with a patch revision at the beginning of the name, etc., renamed, added to the synthesis source, and added with the modified source Means for adding the function to the synthesized source without changing the name (3 in FIG. 3).
2: Addition / change function addition means) and functions added to the synthesized source (functions whose names have been changed and changed in the source after correction,
And a pseudo-instruction that places the program code of the modified source in the patch code section for the patch revision is added to the synthesized source, and no processing is performed on all dynamic variables of the modified function. Pseudo-instructions to be placed in the additional static variable section for the patch revision are added to the synthesized source for the changed static variables / added static variables of the changed function, Means for performing no processing on the variable and adding a pseudo-instruction to be allocated to the additional static variable section for the patch revision to the synthesis source for all static variables used in the additional function (FIG. 3) No. 33: No processing is performed on pseudo-instructions (section change instructions) adding means) and all dynamic and static variables used in the function before change, and static Strange change In the meantime, nothing is performed on the deleted static variable, and the static variable that has not been changed is allocated to the same address as the variable of the master static variable section in the master variable area (34 in FIG. 3). : Static variable identical address arrangement means).

[0013]

Next, embodiments of the present invention will be described in detail with reference to the drawings.

FIG. 1 is a block diagram showing the configuration of the first embodiment of the present invention. FIG. 2 shows a first embodiment of the present invention.
FIG. 9 is a block diagram illustrating a hardware environment that is assumed in the second embodiment. FIG. 3 is a block diagram showing the configuration of the second embodiment of the present invention.

First, a first embodiment of the present invention will be described.

As shown in FIG. 2, the first embodiment comprises an input device 51 such as a keyboard, an arithmetic device 52 for executing a program, a storage device 53 for storing information, and an output device such as a display / printer. It is realized by a computer system configured.

In the storage device 53 of FIG. 2, the source file correcting means 1, source comparing / recording means 2, composite source generating means 3, composite object generating means 4, modified load module generating means 5, unconditional branch of FIG. Instruction patch means 6, load module comparison / patch data generation means 7,
The master object generating means 14 and the master load module generating means 15 are stored. Also, the master source 111, corrected source 121, function / static variable comparison result storage file 220, composite source 221, other master objects 103, pre-correction master object 113, composite source object 223, and master load module 114 of FIG. , Modified load module 224,
After the unconditional branch instruction patch, the load module 228 and the patch data 1229 are stored.

1, the file comparing means 1, the source comparing / recording means 2, the synthetic source generating means 3, the synthetic object generating means 4, the corrected load module generating means 5, the unconditional branch instruction patching means 6, the load module comparing.・ Patch data generation means 7, master object generation means 1
4. The master load module generating means 15 operates on the arithmetic unit 52 of FIG.

As shown in FIG. 1, the first embodiment comprises a source file correcting means 1, a source comparing / recording means 2,
It is composed of a synthesized source generating means 3, a synthesized source object generating means 4, a modified load module generating means 5, an unconditional branch instruction patching means 6, and a load module comparing / patch data generating means 7.

The source file correcting means 1 is for manually correcting the master source 111 written in a high-level language in a high-level language to generate a corrected source 121, and usually uses a text editor. The input is performed by an input device 51 such as a keyboard shown in FIG.

The source comparing / recording means 2 compares the master source 111 with the corrected source 121, detects addition / change / deletion of a function for each function, and detects the added / changed / deleted function name, addition / change .Deletion of deletion, master source 111
Start line / end line of target function above, source 12 after correction
1, the function / static variable comparison result storage file 22 stores the target function start line / function end line, changed / added static variables, etc.
Store the result in 0.

The synthetic source generating means 3 refers to the function / static variable comparison result storage file 220, and stores the synthetic source (all functions before and after modification, and makes all functions on the master source 111 identical to the master load module 114). And the function after the change and the added function are arranged in the patch code section 225 for the patch revision, and all the static variables used in the master source 111 are arranged in the same address as the master load module 114. , A source 221 for arranging all the static variables changed and added in the modified source 121 in the additional static variable section 227 for the patch revision. Details will be described in a second embodiment.

The synthesis source object generation means 4 compiles the synthesis source 221 to generate a synthesis source object 223, and a normal compiler is used.

The modified load module generating means 5 transmits the master object 10 to the unchanged source.
3 and the synthesized source object 223, and the modified load module 224 and the modified static variable area 2
26, and a linker capable of specifying an object file for each object is used.

In the post-modification load module 224, functions not changed in the post-modification source 121, deleted functions, and pre-change functions, that is, all functions on the master source, are stored in the program code section 115 of the master load module 114. The function that is located at the same address as above and that has been renamed by the source 121 after modification and that has been renamed / added function is located in the patch code section 225 for the patch revision.

That is, the master load module 114
The only difference between the modified patch module 224 and the modified load module 224 is the patch code section 225 for the patch revision.

In the post-modification static variable area 226, all static variables used in the pre-change function changed in the post-correction source 121 are arranged at the same address as the master static variable section 117 in the master variable area 116. Among the static variables used in the functions whose names have been changed and changed in the source 121 after the correction, the static variables that have not been changed are the master variable area 1
The modified static variables and the added static variables are arranged at the same address as the 16 master static variable sections 117, and the additional static variable section 22 for the patch revision is used.
7 and all the static variables used in the function added in the source 121 after the correction are placed in the additional static variable section 227 for the patch revision.

The static variables which are not changed even in the function changed in the source 121 after the correction are stored in the master variable area 116.
Is allocated at the same address as the master static variable section 117, the value of the static variable without change can be inherited even when a patch is applied during operation of the system.

The unconditional branch instruction patch means 6 includes a master load module 114 and a corrected load module 224.
And the function / static variable comparison result storage file 220, and transfers the instruction code at the head of the function before the change on the load module 224 after the correction to the head of the function after the change on the patch code section 225 for the patch revision. , And generates a post-patch unconditional branch instruction load module 228.

The load module comparison / patch data generation means 7 compares the master load module 114 with the unconditional branch instruction post-patch load module 228, and generates difference information as patch data 1229.

As described above, the first embodiment of the present invention comprises:
After manually modifying the master source, the master source is compared with the modified source, and the changed function / added function is placed in the patch code section for the patch revision.
In the static variables of the change function, place the static variables that have not been changed at the same address as the master static variable area,
Load the modified static variables and the added static variables in the additional static variable section for the patch revision, and place all static variables in the additional static variable section for the patch revision in the added function. A module is generated, the unconditional branch instruction in which the instruction code at the head of the pre-change function is patched to the unconditional branch instruction to the head of the post-change function is compared with the post-patch load module, and the difference information is compared. By automatically generating patch data, patch data can be generated accurately and efficiently even for code optimized for a compiler.

Further, in the case where a patch is added when a function is added and a case where a static variable is added in a function, it is impossible or unclear in the prior art, but the present invention can automatically generate patch data.

Next, a second embodiment of the present invention will be described.

As shown in FIG. 2, the second embodiment is the first embodiment.
As in the case of the first embodiment, the present invention is realized by a computer system including an input device 51 such as a keyboard, an arithmetic device 52 for executing a program, a storage device 53 for storing information, and an output device such as a display and a printer.

In the storage device 53 of FIG. 2, the source file correcting means 1, the source comparing / recording means 2, the synthesized source initial value setting means 31, the adding / changing function adding means 32, the pseudo instruction (section changing instruction) of FIG. The disabling means 33 and the static variable same address arranging means 34 are stored.

The synthetic source initial value setting means 31, the adding / changing function adding means 32, the pseudo instruction (section changing instruction) disabling means 33, and the static variable same address allocating means 3 shown in FIG.
4 operates on the arithmetic unit 52 of FIG.

As shown in FIG. 3, in the second embodiment, the source file correcting means 1, the source comparing / recording means 2,
It comprises a synthesized source initial value setting means 31, an addition / change function addition means 32, and a pseudo instruction (section change instruction) addition means 33.

The source file modifying means 1 is the same as the source file modifying means 1 of the first embodiment, and has been described for explanation. The master source 111 written in a high-level language is manually corrected in a high-level language, and a corrected source 121 is generated.

The source comparing / recording means 2 is the same as the source comparing / recording means 2 of the first embodiment, and has been described for explanation. The master source 111 is compared with the corrected source 121 to detect addition / change / deletion of a function in function units, and the names of the added / changed / deleted functions, types of addition / change / deletion, and objects on the master source 111 The start line and end line of the function, the start line and end line of the target function on the corrected source 121, and the changed / added static variables are stored in the function / static variable comparison result storage file 220.

The synthesis source initial value setting means 31 copies the master source 111 and sets the initial value of the synthesis source 221.

The addition / change function addition means 32 refers to the function / static variable comparison result storage file 220 and performs no processing on the function which has not been changed or deleted in the source 121 after the correction. In addition, for the function changed in the source 121 after the correction, the caller of the changed function does nothing, so that no compilation error occurs for the body of the changed function, and the changed patch revision In order to identify the function, a patch revision is added to the beginning of the name or the like, the name is changed, the name is added to the synthesis source, and the function added in the corrected source 121 is added to the synthesis source 221 without changing the name. . As a result, the synthesized source 221 is composed of the master source 111 and the corrected source 121.
In, all functions before and after the change are duplicated only for the changed function, and only one function is retained for the others.

The pseudo instruction (section change instruction) adding means 33 refers to the function / static variable comparison result storage file 220 and adds the function added to the synthesis source 221, that is, the program of the function added or changed in the corrected source 121. A pseudo instruction for arranging the code in the patch code section for patch revision (115 in FIG. 1) is generated by the synthesis source 22.
The pseudo instruction for adding the modified / added static variable in the function changed in the source 121 after the modification to the additional static variable section for patch revision (227 in FIG. 1) is added to the synthesized source 221. A pseudo-instruction for placing all the static variables of the added function in the patch additional static variable section 227 for the patch revision is generated by the synthesis source 22.
Add to 1.

The static variable same address allocating means 34 refers to the function / static variable comparison result file 220 and stores the unchanged static variables in the function changed in the corrected source 121 in the master variable area. It is located at the same address as the master static variable section (117 in FIG. 1).

By the same static variable address allocating means 34, even when a patch is applied during the operation of the system, the value of the static variable without any change can be taken over.

As described above, the second embodiment of the present invention
All functions before and after correction are retained, and the added / changed functions are stored in the patch code section for the patch revision (1 in FIG. 1).
In the modified load module (224 in FIG. 1) obtained by compiling and linking the synthesized source by adding the pseudo-instruction placed in (15) to the synthesized source, the program code section (115 in FIG. And the code of the function changed / added in the source 121 after the correction can be all arranged in the patch code section for patch revision (225 in FIG. 1).

Also, the unchanged variables in the function after the change in the corrected source 121 are stored in the master static variable section (11 in FIG. 1) in the master variable area (116 in FIG. 1).
A pseudo-instruction to be allocated at the same address as the variable in 7) and added to the changed / added variable is added to the additional static variable section for patch revision (227 in FIG. 1).
By adding a pseudo instruction to be placed in the additional static variable section for patch revision (227 in FIG. 1) to all static variables of the additional function, the static variables used before the patch can be used as they are. Only the changed / added variables can be used in the additional static variable section for patch revision (227 in FIG. 1). That is, the value of a static variable that does not change even when a patch is applied during operation of the system can be inherited.

[0047]

As described above, according to the present invention,
To automatically generate patch data from the master source file described in the high-level language and the corrected source file corrected in the high-level language, the same as when the source is corrected in the high-level language and the link is redone to completely correct (version upgrade) The same quality as productivity can be provided.

The reason is that the patch data which has conventionally been manually created in the assembler language is automatically generated from the source file described in the high-level language by the apparatus of the present invention. Patches in assembler language are:
Frequent bugs such as incorrect stack operation. This is because if the compiler generates an instruction execution order that is different from the CPU execution order that is not intended by the software developer due to the development of compiler optimization technology, a very difficult patch can be automatically generated. .

According to the present invention, an accurate patch can be generated even when a function is added.

Further, according to the present invention, an accurate patch can be generated even when a static variable is added.

The reason is that when a function is added, the program code of the function is generated in the patch code section for the patch revision, and when a static variable is added, the additional static variable for each patch revision is also generated. This is to add it to the section.

Further, according to the present invention, a patch can be applied while the system is operating.

The reason is that even if the function is changed,
This is because a static variable that has not been changed is located at the same address as the static variable of the master.

[Brief description of the drawings]

FIG. 1 is a block diagram illustrating a first embodiment of the present invention.

FIG. 2 is a block diagram illustrating a hardware environment based on the first and second embodiments of the present invention.

FIG. 3 is a block diagram illustrating a second embodiment of the present invention.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 Source file correction means 2 Source comparison and recording means 3 Synthetic source generation means 4 Synthetic source object generation means 5 Modified load module generation means 6 Unconditional branch instruction patch means 7 Load module comparison and patch data generation means 14 Master object generation means 15 Master load module generating means 103 Other master object 111 Master source 113 Master object before correction 114 Master load module 115 Program code section 116 Master static variable area 117 Master static variable section 121 Source after correction 220 Function / static variable comparison result Storage file 221 Synthetic source 223 Synthetic source object 224 Modified load module 225 Patch code section for the patch revision 226 Modified static variable area 227 Additional static variable section for the patch revision 228 Unconditional branch instruction post-patch load module 1229 Patch data 51 Input device 52 Arithmetic device 53 Storage device 54 Output device 31 Synthetic source initial value setting means 32 Addition -Change function adding means 33 Pseudo instruction (section change instruction) adding means Static variable same address allocating means

Claims (2)

[Claims] 1. A means 1 for modifying a source program (hereinafter, a master source) in a master source file (hereinafter, a modified source is hereinafter referred to as a modified source), and comparing the master source with the modified source to add / change / delete the source program. Means 2 for recording function information (function name, comparison result, function start line, function end line, comparison result of static variables, etc.) in a file (hereinafter referred to as function / static variable comparison result storage file); By referring to the function / static variable comparison result storage file, the synthesis source (all functions before and after modification are retained, all functions on the master source are located at the same address as the master load module, and the modified functions and added Place the function in the patch code section for the patch revision, place all static variables used in the master source at the same address as the master load module, and change A means 3 for generating a source for arranging all the added static variables in the additional static variable section for the patch revision, and a means 4 for compiling a synthesized source to generate an object (hereinafter referred to as a synthesized source object) Link the master object and the composite source object for the source that is not
Means 5 for generating a load module (hereinafter, a post-modification load module) and a static variable area (hereinafter, a post-modification static variable area); Patch the unconditional branch instruction to the beginning of the function.
Means 6 to load module after unconditional branch instruction patch)
Is compared with the master load module and the unconditional branch instruction after-patch load module, and the difference information, that is, the patch code section for the patch revision (functions whose names have been changed and added by the correction source and added functions are located) And an unconditional branch instruction (an instruction code at the head of the function before change is patched to an unconditional branch instruction to the head of the function after change) as patch data. Automatic patch generation device. 2. A means for copying a master source to generate an initial value of a synthesized source for realizing the means 3.
And refer to the above function / static variable comparison result storage file, perform no processing for functions that have not been changed / deleted, and have no effect on functions that have been changed in the source after modification. No processing is performed on the caller of the changed function. For the function body, the patch revision is added to the beginning of the name, the name is changed, the name is added to the composite source, and the modified source is added in the source. Means 32 for adding the function to the synthesized source without changing the name, and the program code of the function added to the synthesized source (that is, the function changed in the source after correction / added function) for the patch revision. Pseudo-instructions to be placed in the patch code section are added to the synthesized source, and among the static variables used in the changed function, the changed static variables / added static variables are added to the patch revision. A pseudo-instruction to be placed in the additional static variable section for the revision is added to the synthesis source, and a pseudo-instruction to place all the static variables used in the additional function in the additional static variable section for the patch revision is added to the synthesis source. Means 33 and static variables used in the post-change function,
2. The automatic patch generation device according to claim 1, further comprising means for allocating static variables that are not changed at the same addresses as the variables of the master static variable section in the master variable area.