JPH1021067A - How to dynamically modify programs - Google Patents

Abstract

(57) [Summary] [Problem] To enable dynamic modification of a program to be performed rationally. In a program change of a multitask data processing device for holding an execution program including a program to be processed by moving to a subroutine by a subroutine call (SUB-CALL) in a main memory, when replacing the subroutine, replacing a new and old subroutine A replacement processing routine and a new subroutine for monitoring the processing and execution of the SUB-CALL are written in a required address area of the main memory, and the replacement processing routine is set to an execution state. Was changed to an instruction to move to the execution of the above replacement processing routine, and as a result of monitoring the execution of the SUB-CALL, when the execution of the SUB-CALL was changed, the SUB-CALL was rewritten to an instruction to call the new subroutine. Then, the process can be shifted to the new subroutine with a jump instruction. The features.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to dynamic updating of computer software, and more particularly to an environment in which it is difficult to stop a service to a terminal and modify software of the computer such as a server. The present invention relates to a computer software change method that enables software to be modified while a computer is in an operating state.

[0002]

2. Description of the Related Art In the case of a computer system in which a processor executes a program stored in a main memory,
Often, programs need to be partially modified or changed.

In such a case, in a large-scale system,
It was common to stop the running program once and restart it again. However, this often takes a lot of time and effort. Also, if the computer system is a server, etc., the service to the terminal must be temporarily suspended, so stopping the running program, changing to a modified program, and then restarting the system is a problem. It's hard to implement unless it's a serious bug fix.

Therefore, in the case of multitask processing, a technique has been proposed in which a program on a main memory of a computer system is partially rewritten while the computer system is executing the program without restarting. , Has also been implemented.

[0005] For example, at the 50th National Convention of the Information Processing Society of Japan, "Dynamic OS Upgrade, Miura, Hirayama" has been proposed. By loading a new subroutine into memory that is equivalent to the entire subroutine, with necessary modifications, and then writes an instruction to transfer control to the address of the new subroutine at the beginning of the subroutine to be replaced,
Thereafter, the call of the subroutine will be replaced by the newer one.

[0006]

However, in the above-described method, the execution of a program, which conventionally required only one subroutine call, is replaced with the original subroutine call and the execution of a new subroutine based on the call. After going through the two-step procedure of transferring control,
Since the number of instructions is increased, the performance is degraded due to an increase in the number of instructions.-The hit rate of the cache is degraded. Therefore, development of a more rational method is desired. Therefore, an object of the present invention is to realize the initial target of dynamically updating software without causing the above-mentioned problem of performance degradation.

[0007]

To achieve the above object, the present invention is as follows. That is, first, a program to be executed in a data processing device including a processor and a main memory is loaded into the main memory, and the execution is started by the processor.
First subroutine SUB1 included in the above program
00 is called, the first subroutine SUB10
0 instead of executing a second subroutine SUB10
1 is a method of dynamically modifying the above program so as to execute Step 1. When a subroutine SUB100 is called, an address ADR300 on the main memory where the called instruction CODE201 exists is calculated,
Subroutine S stored at address ADR300
After rewriting the instruction CODE200 for calling the UB100 on the main memory to the instruction CODE201 for calling the subroutine SUB101, the subroutine SUB101 is rewritten.
Jump to the beginning of

According to such a dynamic program modification method, in the first execution of the instruction stored in the address ADR 300, (1) the call of the subroutine SUB 100, and (2) the instruction stored in the address ADR 300 (3) Jump to the head of subroutine SUB101 (4) Return from subroutine SUB101
Execution is continued by returning to the instruction following the instruction stored at address ADR300. Address ADR300
In the second and subsequent executions of the instruction stored in the subroutine SUB101, the subroutine SUB101 is called.
Returning to the instruction following the instruction stored at address ADR300, execution is continued. That is, the address AD
Execution of the instruction stored in R300 from the second time is faster than in the past. Therefore, it is possible to realize the initial target of dynamically updating software without causing performance degradation.

Secondly, in the above-described method for correcting a program, further, the instruction stored in the address ADR 300 calls an instruction at an address indicated by the contents of a certain register REG of the processor. (That is, when it is not possible to call the subroutine SUB101 by rewriting the instruction of the address ADR300), the instruction (column) CODE for setting a value in the register REG existing before the address ADR300.
The subroutine SUB101 is called by executing the instruction stored in the address ADR300 by finding the instruction 202 and modifying the instruction (column) CODE202.

In this case, in the first execution of the instruction sequence before the address ADR300, (1) the register REG is set so as to call the subroutine SUB100. (2) the subroutine SUB100 is called based on the address stored in the register REG. (3) An instruction sequence corresponding to the above (1) is converted into a subroutine S
Modify so that register REG is set to call UB101. (4) Jump to beginning of subroutine SUB101. (5) Return from subroutine SUB101.
Returning to the instruction following the instruction stored in the address ADR 300 and continuing the execution are performed. In the second and subsequent executions of the instruction sequence before address ADR300, (6) register 400 is set to call subroutine SUB101 (7) subroutine SUB101 is called based on the address stored in register REG (8) By return from subroutine SUB101,
Returning to the instruction following the instruction stored in the address ADR 300, the execution is continued.

That is, the speed of execution of the instruction stored in the address ADR 300 from the second time is higher than in the conventional case. Therefore, it is possible to realize the initial target of dynamically updating software without causing performance degradation.

Third, in a data processing device including a processor and a main memory, a program to be executed is loaded into the main memory, and the first subroutine included in the program is started when the execution is started by the processor. When the SUB100 is called, the subroutine SUB100 is executed according to the conditions determined during execution.
Subroutine SUB101 and subroutine SUB10
2 and the first subroutine SUB10
0 instead of executing a second subroutine SUB10
1 or a method of dynamically modifying the above program to execute SUB102, the subroutine SUB1
When 00 is called, the instruction C that made the call
Address AD on main memory where ODE 201 exists
Instruction CODE for calculating R300 and calling subroutine SUB100 stored at address ADR300
After rewriting 200 on the main memory with an instruction CODE201 for calling the subroutine SUB101 under the above conditions, or after rewriting on the main memory an instruction CODE202 for calling the subroutine SUB102,
It is characterized by jumping to the head of the subroutine SUB101.

Conventionally, in the subroutine SUB100, the condition is determined, and then the subroutine SUB101 or SUB102 is transferred. By this method, the SUB101 or SUB102 can be directly called.

Fourthly, there is provided a method for dynamically modifying the first and second programs, the method comprising:
Subroutine SU instead of subroutine SUB100
When it becomes necessary to execute B101, a subroutine SUB101 and an instruction sequence CODE500 for dynamically modifying an instruction (or a sequence) of the address ADR300 (or immediately before) are loaded from the secondary storage device or the like into the main memory. Then, the head instruction of the "subroutine SUB100" is corrected to a jump instruction to the head of the "instruction sequence CODE500".

In this way, as an example of "need to execute" subroutine SUB101 "instead of" subroutine SUB100 "after the start of program execution, for example, assuming that there is a floating point processor The "subroutine SUB100" for performing an operation using the same may actually load a "subroutine SUB101" for emulating the operation in a software manner by a processor because there is no floating point processor.

In this case, when it is determined that there is no floating-point processor, an instruction sequence CODE 500 for modifying the instruction (column) of “subroutine SUB101” and “address ADR300 (or just before)” is loaded on the main memory. Is done.

The head instruction of the "subroutine SUB100" is corrected to a jump instruction to the head of the instruction sequence CODE500. The method of dynamically modifying the program performed thereafter is the same as the first and second methods. As a result, it is possible to achieve rational and dynamic updating of software that can avoid unnecessary processing.

[0018]

DESCRIPTION OF THE PREFERRED EMBODIMENTS (Specific Example 1) Hereinafter, a specific example will be described with reference to the drawings. First, the concept of the present invention will be described with an example.

In the method, four parts of the program operate in conjunction. In order to explain the contents of these programs, first, a virtual CPU instruction is defined. "CALL xxxx": Calls a subroutine in xxxx. When "RET" is executed at the call destination, execution starts from the next instruction where "CALL" is present.

"RET": When executed in the subroutine read from "CALL", returns to the instruction following "CALL".

"JMP xxxx": Control is transferred to xxxx. Unlike “CALL”, “R
"ET" has no meaning in "JMP".

"SOME1"... "SOMEn": CP other than "JMP", "CALL", "RET"
The instruction of U, that is, the mnemonic “CALL xxxx xx
“x” is an instruction part where “CALL” indicates a subroutine call, and “xxxxxxx” following this is a call address, and “CALL xxxx” is “xxxx”.
Means calling a subroutine.

"RET" is an instruction indicating the return from the subroutine to the main routine. When the "RET" instruction in the subroutine is executed during execution of the subroutine, "branch instruction to the subroutine in the main routine" is issued. CALL "is executed from the instruction described next. In other words, the execution of "CALL xxxx" calls the subroutine at "xxxx". When "RET" is executed at the call destination of this subroutine, the position next to the position where "CALL" is described in the program is displayed. Move to the instruction described in, and execute from here.

The mnemonic “JMP xxxx” is “x
The control is transferred to the instruction at the address "xxx." Unlike "CALL,""RET" has no meaning for "JMP." The mnemonics "SOME1".
These are CPU instructions other than “JMP”, “CALL”, and “RET”. An example of dynamic modification of a program using these will be introduced here.

Each of them is expected to operate on a writable main memory in a computer system. FIG. 1 shows four parts of a dynamic modification which is a key element of the present invention. That is, the following elements [I] to [IV] shown in FIG.

Element [I]. Caller This is the caller's program in the running program and is not specifically considered for replacement. This is a program that calls a simple subroutine [SUB1]. This program starts from an address “1000”, and the address “1000” includes “CAL”
L 2000 ”, the address“ 100 ”
"1" has a "SOME1" instruction.

Element [II]. Subroutine to be replaced This is a subroutine [SUB old] in the running program, and this subroutine [SUBol]
It is assumed that there is an inconvenience in d) and the program contents need to be changed. This subroutine [SUB old]
However, it is not necessarily a program that specifically considers replacement. It is a simple subroutine program. It is assumed that the program starts at address 2000 and ends with "RET".

Element [III]. Replacement subroutine This is a new subroutine [SUB new] in which the inconvenience of the subroutine [SUB old] is corrected. [I
This is a new subroutine to be replaced with the subroutine [SUB old] shown in [I]. No special preparation is required to replace the old subroutine, it is a normally programmed subroutine program. In this example,
The content starts from the address 3000 and ends with “RET”.

Element [IV]. Conversion processing routine This is a routine for realizing processing for replacing an old subroutine with a new subroutine, and is a main program embodying the present invention, and is a replacement processing function program.

In this example, the replacement processing function program is described starting from an address 4000. However, it is sufficient to use an address area that does not overlap an area where another program is located, such as a main routine or another subroutine. It is not limited to this example. This program is treated as a subroutine and operates as follows.

(A) Find the address of the caller.
(In the case of a general-purpose CPU, the address from which the subroutine is called is stored in a register or the stack memory. Therefore, the address is obtained by referring to the contents stored in the register or the stack memory.) (B) The obtained address is obtained. The contents (machine language instruction) of the memory at the corresponding address are read from the address of the caller, and if the instruction is “CALL 2000”,
Rewrite it as "CALL 3000".

(C) Execute "JMP 3000".
Now, in a multitasking computer system (data processing device), as shown in FIG. 2, elements [I] and [I
[I] is stored in the main memory, and it is assumed that the CPU is occasionally executed as one of the operating programs. Among them, the subroutine [SUB old] which is [II] has a program disadvantage.
You want to fix it. In this case, in the present invention, the corrected subroutine program is prepared as a subroutine [SUB new]. This is [III]. Then, the subroutine [SUB new] which is [III] is stored in the main memory so that the head address becomes "3000", and the replacement processing function program which is [IV] is stored in the main memory with the head address " It is stored in the main memory so that the address becomes 4000 ".

Thus, the above-mentioned element [I]
To [IV] are placed on the main memory of the computer system (see FIG. 3 [State A]). In this state, in order to realize the replacement of the old and new subroutines according to the present invention, the replacement processing function program of the IV firstly executes the instruction "SOME2" stored at the address 2000 on the main memory.
Rewrite to "JMP 4000".

The state immediately after this is [State B] shown in FIG. Then, if there is an execution from the address 1000 thereafter (ST1). Call subroutine 2000.

(ST2). As a result, the aforementioned [IV]
"JMP" to the conversion routine. This can be done because the contents of the address 2000 were previously rewritten to "JMP 4000".

(ST3). In the conversion processing routine,
Rewrite the contents of address 1000 to "CALL 3000". This state is [State C] (see FIG. 5B).

(ST4). The conversion processing routine ends with “JMP” described in the conversion processing routine.
The instruction "3000" is executed, thereby jumping to the address "3000" and executing the address "3000".
Is executed, and the old subroutine [SUB old] is not executed.

As described above, in the method of the present invention, when it is desired to change the contents of the subroutine called by this subroutine call in the subroutine call, the changed subroutine is arranged in another address area and the old and new subroutines are replaced. Is placed in a required address area, and the instruction at the start address of the old subroutine is changed to a jump execution instruction (“JMP”) of the routine of the replacement processing function. At the stage where the call has not been executed even once, the old subroutine is skipped by jumping to the replacement processing routine even if the old subroutine is called for the time being,
When a normal subroutine "CALL 2000" (call to address 2000) is executed, the routine of the replacement processing function functions, and the address "1000" is obtained.
In the subroutine call, "2000" is replaced with "3000" to become "CALL 3000", and the content of the address "1000" is "CALL 30".
00 ", and thereafter, the address" 3000 "is directly subroutine called from the address" 1000. "Thus, the address" 1000 "of the subroutine call instruction for calling the old subroutine. Is changed to an instruction that directly calls a new subroutine in place of the old subroutine according to the present invention, so that the new subroutine is executed in a short processing step without waste compared to the conventional method in which the contents of the address “1000” are not rewritten. And efficient program execution processing can be performed.

(Specific Example 2) A specific system to which the present invention is applied will be described. FIG. 6 is a block diagram showing a configuration example of a computer system to which the present invention is applied. In the figure, 1 is a CPU (processor), 2 is a main memory, 3 is a display device (display, etc.), 4 is an operation device (keyboard, mouse, etc.), 5 is an external storage device (hard disk, magneto-optical disk, floppy disk, etc.) ), 6 is an output unit (printer, serial input / output interface, etc.),
Reference numeral 10 denotes a program dynamic correction processing function.

In this system, the main memory 2 has a program dynamic correction processing function as a program.
Is executed, the contents of the address of the main memory 2 in which the target subroutine call instruction is written can be changed so that the subroutine to be corrected is switched to the corrected subroutine and the subroutine call is performed.

That is, program dynamic correction processing function 1
0 is a program dynamic correction processing function main part shown in FIG.
The replacement processing function unit shown in FIG. 8 is a replacement processing function program that is loaded into the main memory 2 as needed and used. When the corrected subroutine is written in the main memory 2, the replacement processing function unit is used by loading it into an unobstructed address area in the main memory 2, and is erased from the main memory 2 when it is no longer needed. .

Now, when it becomes necessary to modify a subroutine (old subroutine) for a certain subroutine call, as shown in FIG.
1. When the function of the main part of the program dynamic correction processing function is started and executed according to 1, the function of the main part of the program dynamic correction processing function first enters the input mode (S1), and the corrected subroutine (new (S2). Then, in this state, when the programmer or the operator operates the operation device 4 to input the head address and the corrected subroutine program, for example, the programmer or operator inputs the head address and the corrected subroutine program and transfers the corrected subroutine program from the designated head address position to the main memory 2 and store (S
3).

When the input of the corrected subroutine is completed and the programmer or the operator performs the operation of terminating the input mode, the function of the main part of the program dynamic correction processing function waits for the designation of the target subroutine call. Then, the programmer or the operator inputs to register the instruction content description of a certain subroutine call. As a result, the contents of the subroutine call are registered (S5), and this becomes comparison data (S5).
6). When this is completed, the function of the main part of the program dynamic correction processing function determines that the routine of the replacement processing function next specifies a predetermined address area in the main memory 2 or a programmer or an operator specifies an address area from the operation device 4. Then, the data is loaded into the specified address area. Then, the loaded replacement processing function routine is started (S7).

When activated in the replacement function routine, first, the above-described subroutine head instruction to be changed (the old subroutine head instruction) is rewritten to the "JMP" instruction for the replacement function routine (S2 in FIG. 8).
1). Since the storage address of the replacement processing function routine on the main memory 2 is determined, the "JMP" instruction to the replacement processing function routine can be uniquely executed.

Next, the process proceeds to monitoring of a subroutine call (S22 in FIG. 8). Here, a plurality of programs are executed by the multitask, and a routine of the replacement processing function is also executed by the multitask. Then, in the routine of the replacement processing function, it is monitored whether or not the CPU 1 has executed the subroutine call, and if the subroutine call is executed, the address of the subroutine call calling source is obtained (S23 in FIG. 8). In the case of a general-purpose CPU, the caller address of the subroutine is stored in a register or a stack memory. Therefore, it is determined by referring to the contents stored in the register and the stack memory.

Next, the contents of the corresponding address of the main memory 2 are read from the address (S24 in FIG. 8). Then, it is compared with the comparison data to check whether they match (S25 in FIG. 8). The comparison data is the instruction content of the subroutine call obtained by the main part of the program dynamic correction processing function (see S6 in FIG. 7).

As a result of the comparison, if they match, it is a target subroutine call, so the top instruction of the calling subroutine call is rewritten to an instruction to perform "JMP" to the corrected subroutine (new subroutine) (S2 in FIG. 8).
6). Then, "J" is added to the head address of the corrected subroutine.
MP ”(S27 in FIG. 8).

A specific example will be described. Now, there is a program starting from the address “1000” as shown in FIG. 2, and the content of the address “1000” is “CALL 20”.
The subroutine call is “00”, and the address “2000” of the main memory is “SOME2”,
There are subroutines such as "SOME3" and "RET".

When it is necessary to modify the subroutine (old subroutine) starting from the address "2000", as shown in FIG.
1. When the function of the main part of the program dynamic correction processing function is started and executed according to 1, the function of the main part of the program dynamic correction processing function first enters the input mode (S1), and the corrected subroutine (new (S2). Then, in this state, the programmer or the operator operates, for example, the operation device 4 to input the head address and the corrected subroutine program. For example, suppose that the start address is "3000" and the program content is "SOME4", "SOME5", "RET", as shown by reference numeral III in FIG. The main part of the program dynamic correction processing function fetches this, writes the corrected subroutine program from the designated start address position "3000" on the main memory 2 and stores it (S
3).

When the input of the corrected subroutine is completed and the programmer or the operator performs the operation of terminating the input mode, the function of the main part of the program dynamic correction processing function waits for the next specification of the target subroutine call. Then, the programmer or the operator inputs to register the instruction content description of a certain subroutine call.

As a result, the contents of the subroutine call are registered (S5), which becomes comparison data (S5).
6). When this is completed, the function of the main part of the program dynamic correction processing function is that the routine of the replacement processing function indicated by the reference numeral IV is set to a predetermined address area in the main memory 2 or a programmer or an operator If an address area is specified, the data is loaded into the specified address area. In the case of this example, the data is loaded in an area starting from the address “4000” in the main memory 2. The arrangement state of the programs in the main memory 2 at this stage is [State A] shown in FIGS. 3 and 4A.

Then, the function of the main part of the program dynamic correction processing function activates the loaded replacement processing function routine (S7). When activated in the replacement processing function routine, first, the first instruction of the subroutine to be changed as described above (the first instruction of the old subroutine, in this case,
"SOME2" at the address "2000") is rewritten into a "JMP" instruction for the replacement processing function routine (S21 in FIG. 8). Since the storage address of the replacement processing function routine on the main memory 2 is determined, the "JMP" instruction to the replacement processing function routine can be uniquely executed. That is, the replacement processing function routine is executed in the main memory 2.
Since the above address is “4000”, the address “20”
00 is rewritten to an instruction “JMP 4000.” This state is shown in FIGS.
This is [State B] shown in FIG.

Next, the replacement processing function routine shifts to monitoring of a subroutine call (S22 in FIG. 8). Here, a plurality of programs are executed by the multitask, and a routine of the replacement processing function is also executed by the multitask. In the routine of the replacement processing function, the CPU 1
Monitors whether the subroutine call has been executed, and if the subroutine call is executed, the subroutine call source address is obtained (S23 in FIG. 8). In the case of a general-purpose CPU, since the subroutine call source address is stored in a register or a stack memory, the address is obtained by referring to the contents stored in the register or the stack memory.

Next, the contents of the corresponding address in the main memory 2 are read from the address (S24 in FIG. 8). Then, it is compared with the comparison data to check whether they match (S25 in FIG. 8). In this case, the comparison data is "CALL 2000" which is the instruction content of the subroutine call obtained by the main part of the program dynamic correction processing function (S in FIG. 7).
6).

As a result of the comparison, if they match, it is a target subroutine call. Therefore, an instruction to "JMP" the head instruction of the calling subroutine call to the corrected subroutine (new subroutine), that is, in this example,
Since the corrected subroutine is stored at address “3000”, “CALL 200” at address “1000” which is the first instruction of the calling subroutine call is used.
0 ”to“ CALL 3000 ”(S in FIG. 8).
26). This state is [State C] shown in FIG.

Then, the routine of the replacement processing function makes "JMP" to the address "3000" which is the head address of the corrected subroutine (S27 in FIG. 8). As a result, the address jumps to the address “3000” and the address “300”
The new subroutine III stored in "0" is executed, and thereafter, the old subroutine II starting from the address "2000" is not executed.

As described above, in the system of the present invention, when it is desired to change the contents of the subroutine called by this subroutine call in the subroutine call, the changed subroutine is arranged in another address area and the old and new subroutines are replaced. The replacement processing function routine that manages the
Change the instruction at the start address of the old subroutine to the jump execution instruction (“JMP”) of the replacement processing routine,
After this change, if the subroutine call has not been executed even once, the old subroutine is skipped by jumping to the routine of the replacement processing function even if the old subroutine is called. When the subroutine "CALL 2000" (call to the address 2000) is executed, the routine of the replacement processing function operates, so that the address "100"
For the subroutine call of "0", "2000" becomes "300".
0 is replaced with “CALL 3000”, and the content of the address “1000” is “CALL 3000”.
L 3000 ”, and thereafter, the address“ 10 ”
From "00", a subroutine call is directly made to the address "3000".
Since the address "1000" of the subroutine call instruction for calling the old subroutine is changed to the instruction for directly calling the new subroutine instead of the old subroutine according to the present invention, compared with the conventional method in which the content of the address "1000" is not rewritten The new subroutine can be executed in a short processing step without waste,
An efficient program execution process can be performed.

(Example 3) Example 3 is an example in which the subroutine called by the subroutine is a conditional branch. Once the subroutine has been executed, the conditions are known, and thereafter, This is the most suitable method when there is no need to determine conditions.

In the specific examples 1 and 2, for example, the subroutine program starting from the address “2000” is
It is assumed that the instruction is a “conditional branch instruction”. Then, it is assumed that the “conditional branch instruction” is a condition determined after the execution of the subroutine program and has a content that branches to either the address “2500” or the address “2600”.

Assume that it is necessary to change the contents of the subroutine starting from address "2500" and the contents of the subroutine starting from address "2600". In this case, a subroutine (new subroutine) to be replaced with a subroutine (old subroutine) starting from address "2500" is held in an address area starting from address "3000", and replaced with a subroutine (old subroutine) starting from address "2600". Subroutine (new subroutine) is held in an address area starting from address "3100".

Then, in the routine of the replacement processing function which is a routine from the address "4000", "CALL 2000" is replaced with "CALL 300" under the above-mentioned conditions.
0 "or" CALL 3100 ". Then, by executing the same operations as in the specific examples 1 and 2, when the old and new subroutines are replaced, it is assumed that there is a condition judgment in the subroutine call of the caller. However, after the replacement of the old and new subroutines is completed, there is no need for unnecessary condition determination, and the program can be optimized.

After the execution of the program is started, "subroutine SUB10" is used instead of "subroutine SUB100".
For example, a program using a floating-point processor can be considered as a specific example of “1 needs to be executed”. The program assumes that there is a floating-point processor and uses it. It is assumed that the program has a "subroutine SUB100" for performing the arithmetic operation, and that this program is actually run on a computer system having no floating-point processor.

In this case, since the computer system does not have a floating-point processor, it is necessary to load and use a "subroutine SUB101" for emulating the operation by software on the processor.

In this case, when it is determined that there is no floating point processor, an instruction sequence CODE 500 for modifying the instruction (column) of “subroutine SUB101” and “address ADR300 (or just before)” is loaded on the main memory. I do.

The head instruction of the "subroutine SUB100" is corrected to a jump instruction to the head of the instruction sequence CODE500. In this way, even if there is a determination routine that determines whether there is a floating point processor and loads a floating point emulation program when it is determined that there is no floating point processor,
After executing this routine once, the condition determination part is eliminated, so that there is no unnecessary condition determination, and the program can be optimized.

Although various examples have been described above, in short, the present invention can be applied to a case where it is necessary to modify a part of a program without stopping the computer system, instead of stopping the computer system. Write the modified partial program to another address area, and at the stage of executing the program of the part that needs to be modified, so that the modified partial program is executed,
The replacement process is performed. Therefore,
Of the system software, software that is difficult to stop in general can be partially updated, and execution can return to the instruction at the address of the original partial program that is no longer needed. Since there is no such processing, a new program can be executed in the shortest execution step without using unnecessary processing, so that there is an effect that the program can be rational dynamically modified.

The present invention is not limited to the above-described example, but can be implemented with various modifications. In addition, the above-described method described in the embodiment includes a magnetic disk (floppy disk, hard disk, or the like), an optical disk (C
D-ROMs, DVDs, etc.) and storage media such as semiconductor memories for distribution.

[0068]

As described above, according to the present invention, when a part of a program needs to be reworked, the program of the part that needs to be reworked is corrected without stopping the computer system. Can be replaced and executed. Therefore, among the system software, it is generally difficult to stop the software. In general, the program can be partially updated.
Moreover, since the execution is not returned to the instruction at the address position of the original partial program that is no longer needed, the new program can be executed in the shortest execution steps without unnecessary processing. This has the effect of enabling rational dynamic modification of the program.

[Brief description of the drawings]

FIG. 1 is a diagram for explaining the present invention, showing a first state of the present invention.

FIG. 2 is a diagram for explaining the present invention, showing a program arrangement state before correction in a main memory.

FIG. 3 is a diagram for explaining the present invention, showing a program allocation state in a main memory in a first stage [state A] of the present invention.

FIG. 4 is a diagram for explaining the present invention, wherein a first stage [state A] to a second stage [state B] by the processing of the present invention;
The figure which showed the arrangement state of the program in the main memory in the state advanced to, and the program content at that time.

FIG. 5 is a diagram for explaining the present invention, in which a program is arranged in a main memory in a state where the process proceeds from a second stage [state B] to a third stage [state C] of the present invention, and The figure which showed the content of a program. The figure which showed the first state.

FIG. 6 is a diagram for explaining the present invention, and is a block diagram showing a configuration example of a computer system according to the present invention.

FIG. 7 is a diagram for explaining the present invention, and is a flowchart showing a processing procedure of a main part of a program dynamic correction processing function of the computer system according to the present invention.

FIG. 8 is a diagram for explaining the present invention, and is a flowchart showing a processing procedure of a replacement processing function routine of a program dynamic correction processing function of the computer system according to the present invention.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 ... CPU 2 ... Main memory 3 ... Display device 4 ... Operating device 5 ... External storage device

Claims (5)

[Claims] 1. A data processing apparatus including a processor and a main memory, wherein the multitask data processing apparatus has a main memory storing an execution program including a program for processing by moving to a subroutine by a subroutine call. In replacing the subroutines, the replacement processing routine for monitoring the replacement processing of the old and new subroutines and the execution of the subroutine call and the new subroutine are written in a required address area of the main memory. In the processing routine, the first instruction of the old subroutine is changed to an instruction to shift to execution to the replacement processing routine, and as a result of monitoring the execution of the subroutine call, when the execution shifts to the subroutine call, the subroutine call is changed to After rewriting the call instruction of the subroutine, the dynamic correction method program for causing shift processing by a jump instruction in the new subroutine. 2. In a data processing apparatus including a processor and a main memory, a program to be executed is loaded into a main memory, and a first subroutine included in the program is called in a state where the execution is started by the processor. When the first subroutine is called, when the first subroutine is called, the call is dynamically modified to execute the second subroutine instead of executing the first subroutine. After calculating the address on the main memory where the executed instruction exists, and rewriting the instruction for calling the first subroutine stored at the calculated address on the main memory to the instruction for calling the second subroutine , Let me jump to the top of the second subroutine to fix it A method for dynamically modifying a program, characterized in that: 3. The method according to claim 2, wherein the instruction stored at the address is:
In the case where the instruction of the address indicated by the contents of a certain register of the processor is to be called, an instruction for setting a value in the register existing before the address (column).
And modifying the instruction (column) to execute the instruction stored at the address so as to call the second subroutine. Method. 4. In a data processing apparatus including a processor and a main memory, a program to be executed is loaded into a main memory, and a first subroutine included in the program is called in a state where the execution is started by the processor. When the first subroutine is executed, the second subroutine is executed according to the conditions determined during execution.
A method of dynamically modifying the program so as to execute the second or third subroutine instead of executing the first subroutine, wherein the first subroutine is executed. When the subroutine is called, an address on the main memory where the first command that called the subroutine is present is calculated, and the second command for calling the first subroutine stored at the address is calculated according to the above condition. After rewriting in the main memory to an instruction for calling the second subroutine, or after rewriting in the main memory to an instruction for calling the third subroutine, a jump to the head of the second subroutine is performed. How to dynamically modify the program. 5. The dynamic correction method of a program according to claim 2, wherein the second subroutine has to be executed instead of the first subroutine after the execution of the program. An instruction sequence for dynamically modifying the second subroutine and its address or the instruction (column) immediately before the second subroutine is loaded from the storage device or the like into the main memory, and the first instruction of the “first subroutine” is replaced with the “instruction”. A dynamic modification method of a program, characterized in that the program is modified to a jump instruction to the head of a column.