JPH05341981A - Patch area securing device - Google Patents

Abstract

PURPOSE:To secure a patch area at a code part and to enable a program to be corrected even when the program is disabled to be corrected from a source program. CONSTITUTION:A system subroutine 1 consists of the code part, and sufficient size as the patch area can be secured. A COBOL language source program 2 is a source program generated in COBOL language, and a CALL text to read out the system subroutine 1 is included in it. A skip flag 3 is provided so as to perform such control that the CALL text can be prevented from being executed in the ordinary flow of the program. A compile unit 4 displays the complie result of the system subroutine 1. A COBOL compile unit 5 displays the compile result of the COBOL language source program 2. A linker 7 generates a final load module 6 by linking the compile unit 4 with the COBOL compile unit 5.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a patch area securing device, and more particularly to a method of securing a patch area in a code portion when a program is developed in a high-level programming language such as COBOL language.

[0002]

2. Description of the Related Art Generally, as a method of modifying a program in program development, a method of modifying a source program and compiling and linking to recreate an executable load module, and a method of modifying a load module without modifying the source program There is a method of directly rewriting a part of.

In the program development of a high-level programming language such as the COBOL language, the problem is dealt with by correcting the source program when a problem occurs in the program.

Although a high-level programming language such as the COBOL language has an instruction to secure a data area in the data portion, there is no instruction that secures an area in the code portion as a patch area and does nothing. .. For this reason,
It is possible to secure the patch area of the data part in advance,
There is a problem that the patch area of the code part cannot be secured.

Since the code part cannot use the patch area secured in the data part as a code, COBO
When a problem occurs in a program created in a high-level programming language such as the L language, the source program is modified and the compile link is performed, which causes a problem that the program cannot be modified by a patch.

[0006]

SUMMARY OF THE INVENTION The present invention has been made in order to eliminate the above-mentioned problems of the conventional one, and it is possible to secure a patch area in the code portion and to correct the program even if it cannot be modified from the source program. An object of the present invention is to provide a patch area securing device capable of modifying a program.

[0007]

A patch area reserving apparatus according to the present invention is provided in the source program, and a system subroutine for reserving a patch area for storing a correction program for correcting a source program created in a high-level programming language. It is characterized by having a read instruction for reading the system subroutine, and link means for linking the compile result of the source program and the compile result of the system subroutine.

[0008]

An embodiment of the present invention will be described with reference to the drawings.

FIG. 1 is a block diagram showing the configuration of an embodiment of the present invention. In the figure, a system subroutine 1 is created to secure a patch area in the code part of the load module of the executable format of the program created in the COBOL language.

That is, the system subroutine 1 is composed of a code portion, and has a sufficient size to be used as a patch area. Also, the contents of the system subroutine 1 are filled with no-operation instructions that cause no operation even when executed.

However, since such an instruction does not exist in the COBOL language, the system subroutine 1 of this embodiment is used.
Is a source program composed of assembler instructions.
That is, the system subroutine 1 is a source program filled with no-operation instructions in assembler language.

The system subroutine 1 is previously compiled, and the compilation result is the compilation unit 4. Therefore, only the object code exists in the compilation unit 4. Here, a program assembled by an assembler is usually expressed as an assemble, but in this embodiment, it is expressed as a compile for convenience.

The COBOL language source program 2 is CO
It is a source program created in the BOL language and includes a CALL statement for reading the system subroutine 1. The skip flag 3 is provided in the COBOL language source program 2 and is provided to control so that the CALL statement in the COBOL language source program 2 is not executed in the normal program flow. There is.

That is, the COBOL language source program 2 has a call instruction for reading the system subroutine 1 in its code part. However, it is put in a conditional expression such that the system subroutine 1 is not actually executed. Keep it.

In the present embodiment, the value of the skip flag 3 is used as the truth value of the condition, and the system subroutine 1 is programmed by the call instruction when the conditional expression becomes true and is satisfied. That is, by setting the skip flag 3 to a value such that the conditional expression is not true, the system subroutine 1 is not actually called.

The COBOL compilation unit 5 is a COB
It is a compilation result of the OL language source program 2,
It is usually composed of an object data section 51 and an object code section 52.

The linker 7 is a compile unit 4 and a COB.
The final load module 6 is created by linking with the OL compilation unit 5. That is, the linker 7 is CO
Object code part 5 of BOL compilation unit 5
2 is linked to the compile unit 4 consisting only of the object code part of the assembler source module, so that the load module 6 has the system subroutine 1
The patch area 61 of the code portion is secured for the area secured in step 4.

FIG. 2 is a flow chart showing the operation when patch data exists in the patch area 61 of FIG.
The operation when patch data exists in the patch area 61 secured by the embodiment of the present invention will be described below with reference to FIGS. 1 and 2.

When the instructions written in the COBOL language source program 2 are executed (step 2 in FIG. 2).
0) Normal operation, that is, if the instruction does not require the use of patch data in the patch area 61, the skip flag 3 is set to “YES” at an appropriate position before the conditional expression including the system subroutine 1 is executed. (FIG. 2, step 21).

When an instruction for the condition determination including the call instruction for reading the system subroutine 1 is executed (step 22 in FIG. 2), whether the conditional expression of the value of the skip flag 3 = 'NO' is true or not is determined. Judgment is made.

In this case, the skip flag 3 is set to'YE
Since S'is set, the value of skip flag 3 =
Conditional expression of'NO 'is not true (Fig. 2, Step 2)
3). Therefore, the next COBOL language instruction is executed without executing the call instruction for reading the system subroutine 1 (step 24 in FIG. 2).

When the COBOL language command is executed and the patch is reached, an assembler command that jumps to the address where the system subroutine 1 is expanded, that is, the address of the patch area 61 is written at that position. Therefore, the assembler instruction is executed (step 25 in FIG. 2).

When the address of the patch area 61 is jumped by executing the assembler instruction, the assembler instruction written in the patch area 61 is executed (step 26 in FIG. 2).
Necessary processing is performed in the patch area 61. After performing the necessary processing in the patch area 61, post-processing is performed so that the original instruction written in the COBOL language can be executed, and the assembler instruction in the patch area 61 returns to the execution of the COBOL instruction (see FIG. 2). Step 27).

As described above, the system subroutine 1 is constructed so as to secure the patch area in the assembler language or the like.
By linking the compile unit 4 to the object code portion 51 of the COBOL compile unit 5 when the COBOL compile unit 5 is linked by creating the COBOL language source program 2 to call the system subroutine 1. Thus, a patch area can be secured in the code section.
Therefore, even when the program cannot be modified from the COBOL language source program 2, the patch area can be used to modify the program.

Although the source program created in the COBOL language has been described in the embodiment of the present invention, the present invention can be applied to other high-level programming languages and is not limited to this.

[0026]

As described above, according to the present invention, there is provided a system subroutine for securing a patch area for storing a modification program for modifying a source program created in a high-level programming language, and this system subroutine is executed. By providing a read instruction to be read in the source program and linking the compile result of the source program with the compile result of the system subroutine, a patch area can be secured in the code part and the program cannot be modified from the source program. In this case, there is an effect that the program can be modified.

[Brief description of drawings]

FIG. 1 is a block diagram showing a configuration of an exemplary embodiment of the present invention.

2 is a flowchart showing an operation when patch data exists in the patch area of FIG. 1. FIG.

[Explanation of symbols]

 1 System Subroutine 2 COBOL Language Source Program 3 Skip Flag 4 Compile Unit 5 COBOL Compile Unit 6 Load Module 7 Linker 51 Object Data Part 52 Object Code Part 61 Patch Area

Claims (3)

[Claims] 1. A system subroutine for securing a patch area for storing a modification program for modifying a source program created in a high-level programming language, and a read instruction provided in the source program for reading the system subroutine. A patch area securing device having link means for linking a compilation result of the source program and a compilation result of the system subroutine. 2. The patch according to claim 1, further comprising a skip flag provided in advance in the source program, and means for controlling execution of the read instruction according to the content of the skip flag. Area securing device. 3. The patch area reserving apparatus according to claim 1, wherein the system subroutine is constituted by a no-operation instruction that causes no operation at the time of execution.