JP3110391B2 - Program re-execution method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to a program re-execution method for re-executing a program up to an instruction for which debugging has been completed.

[0002]

2. Description of the Related Art During debugging of a program, in a situation where a software defect is found due to a certain process, and after an initial value of a certain variable is changed, debugging is restarted from the beginning and the result is to be confirmed in the corresponding process. Conventionally, there is no debugger capable of automatically performing the reproduction process. Therefore, in order to move to a certain process by using the conventional debugger, the process has to be advanced to a corresponding portion while considering the user.

[0003]

In the prior art debugger "program re-execution processing method" (Japanese Patent Laid-Open No. 5-250208) which is the closest to the present invention, the state at a certain point in time without starting the program from the beginning. Can be reproduced at high speed. However, according to this conventional technique, it is possible to restore the state exactly the same as the previous state, but it is not possible to create an execution state after a certain instruction is changed, as described above. In order to re-execute and stop the processing at the corresponding instruction, it is necessary to know how many times the instruction is to be executed before stopping. As a means for obtaining the number of times, a method of remembering the number of times of execution of all instructions during the first execution and acquiring the number of times of execution of the corresponding instruction from the information can be easily estimated. The flowchart of FIG. 6 is one example.

However, this method has a problem that the data memory used by the debugger becomes enormous. The reason is that a table for holding the number of accesses corresponding to the number of instructions of the program to be debugged is required.

When the program shown in FIG. 3 is executed under the same conditions as those of the embodiment of the present invention, as shown in FIG.
A table for instructions is required. In recent years, the size of programs has become enormous, and some programs have more than 100,000 instructions. At that time, a table for 100,000 instructions is required, which is not practical.

SUMMARY OF THE INVENTION It is an object of the present invention to provide a program re-execution method which makes it possible to re-execute a program up to an instruction for which debugging has been completed with a small memory consumption.

[0007]

A program re-execution method according to the present invention is a program re-execution method for re-executing a program up to an instruction for which debugging has been completed. Creating a table in the storage means in which the value of the program counter, the number of times of execution of the instruction, and the last execution information of the instruction when executing a specific instruction among the instructions are stored in the storage means; Then, the value of the final target program counter, which is the value of the program counter when the last instruction was executed, and the program counter of the latest executed instruction among the instructions corresponding to the value of the program counter in the table. The value of the target program counter, which is the value, and the number of executions corresponding to the target program counter Storing the target number of times in the storage means, and, during re-execution, after executing the program until the current value of the program counter reaches the value of the target program counter by the number of times of the target, the value of the current program counter Executing the program until the value reaches the value of the final target program.

In the program re-execution method according to the present invention, in the above-described program re-execution method, the execution of the program at the time of the re-execution is step execution.

Further, a program re-execution method according to the present invention is characterized in that in the above-described program re-execution method, the specific instruction is an instruction with a label.

Further, a program re-execution method according to the present invention is characterized in that, in the above-described program re-execution method, the specific instruction is an instruction for every predetermined number.

[0011]

DESCRIPTION OF THE PREFERRED EMBODIMENTS According to the present invention, during debugging of a program, a certain process is performed and a defect of the program is detected.
When the debugger is restarted from the beginning after the program is corrected and the result is to be checked in the relevant process, the process up to the relevant process is automatically executed by minimizing the data memory used by the debugger. It provides a means.

In FIG. 1, the execution number storage means 32 includes:
During execution of the program, the number of executions for each instruction is stored.
When execution of the execution state is requested by the command input unit 22, the execution state reproduction unit 42 obtains the instruction of the reproduction position and the number of executions from the contents stored in the execution number storage unit 32, and re-executes the program. To reproduce the execution state. At this time, the number of executions stored in the number-of-executions storage means 32 is limited to only the labeled instruction, and the execution state reproduction means 42 executes the reproduction at the reproduction position with the label closest to the previously executed instructions. The table created by the execution count storage unit 32 is reduced by moving the process to the reproduction position after moving the process up to the instruction whose final execution information is ON among the instructions with the label which is the instruction. Since the target instructions to be stored are limited to labels,
The re-execution process can be performed while keeping the data memory used by the debugger to a minimum.

[Embodiment 1] Referring to FIG. 1, a first embodiment of a re-execution processing method according to the present invention is a processing control means 1 for controlling the entire processing, an input means 2, a storage means 3,
It comprises an execution unit 4 and an output unit 5.

The input means 2 includes a program input means 21 for inputting a target program for debugging, and a command input means 22 for receiving instructions such as step execution.

The storage means 3 comprises a program storage means 31 for storing a target program to be executed, and an execution number storage means 32 for storing and storing the number of executions for each instruction.

The execution means 4 includes a program execution means 41 for executing a target program, and an execution state reproduction means 42 for executing an arbitrary execution position at a time.

The output means 5 includes a result file output means for outputting a result of debugging to a file, and a result display means for displaying the result on a screen.

The target program is a program input means 21
The target program is executed by the program execution unit 41 in accordance with the command read by the command storage unit 31 and received by the command input unit 32. At this time, the execution number storage means 32
The number of executions for each instruction is stored, and an arbitrary execution state is reproduced by the execution state reproduction means 42 based on the stored information.

Next, the overall operation of the present embodiment will be described in detail with reference to the flowcharts of FIGS.

In FIG. 2, first, step S1 is as follows.
Check whether the reproduction specification has been made. If the reproduction has been designated, the process proceeds to step S9, where a reproduction process is performed. If no reproduction is designated, step S
Step 2 checks whether the instruction to be executed is a labeled instruction. If the instruction is not a labeled instruction, one step is executed in step S4, and the process returns to step S2 to check the next instruction. When it is determined in step S2 that the instruction is a labeled instruction, the program counter (in FIG. 2, described as "PC") of the instruction and the information on the number of times are recorded in the execution count registration table T1. If the program counter to be recorded is not yet registered in the execution count registration table T1, the count information is set to 1
And the final execution information is turned ON each time. At this time, the other final execution information is turned off. If it has already been registered, the count information is incremented by one, and the final execution information is turned ON each time. At this time, the other final execution information is turned off. The processing from step S2 to step S6 is performed in step S7.
Repeat until the end of debugging is determined. Step S
When the debug end is determined in step S7, in step S8, the current program counter (final target program counter) and the program of the closest instruction among instructions executed in the past from the program counter are read from the execution count registration table T1. A counter, that is, a program counter (target program counter) for which the corresponding final execution information is ON, and count information (target count) corresponding to the target program counter are output to the log file T2.

Next, a case where reproduction is specified will be described. If it is determined in step S1 that reproduction is designated, in step S9, the "final target program counter", the "target program counter", and the "target number of times" are read from the log file T2.

In step S10, the variable Counter
Is initialized to “1”. Then, at step S11, 1
After executing the step, the current program counter and the target program counter are compared in step S12, and if they do not match, the process returns to step S11 and executes one step again. If they match, the variable Count
ter and the target number of times, and if they do not match, the variable Counter is incremented by 1, and the process returns to step S11.
One-step execution is performed again. If they match, one-step execution is repeated to shift the process from the current program counter to the final target program counter. Specifically, in step S15, the current program counter is compared with the final target program counter. If they do not match, one step is executed in step S16, and the process returns to step S15. Step S
When they match, the reproduction of the process up to the target final program counter ends.

Next, the operation of this embodiment will be described using a specific example.

For example, while debugging the program of FIG. 3, when the instruction 311 is executed three times,
A case where the instruction 301 is changed and then re-executed to the same position will be described.

The program shown in FIG. 3 is read by the input program input means 21 shown in FIG.
Stored by This program is debugged while being executed by the program execution means 41. Step S1 in FIG. 2 checks whether or not reproduction is instructed by the command input unit 22 in FIG. Since no instruction has been given, the process moves to the processing after step S2, and debugging starts. In step S2, it is checked whether the instruction to be executed is a labeled instruction.

The first instruction is labeled instruction 301 in FIG.
Therefore, the result is true, and the process proceeds to step S3. In step S3, the current program counter and the number of executions of the current program counter are stored in the execution number registration table T.
1 is stored. In this case, as shown in the execution count registration table 401 in FIG.
, The number of executions “1” and the final execution information “ON” are stored. The processing from step S2 to step S6 is
As described above, the instruction 311 is repeatedly executed until the instruction 311 is executed three times. At the end of debugging in step S7, that is, the content of the execution count registration table T1 at the time when the instruction 311 is executed three times, as shown in the execution count registration table 402 of FIG.
Execution count “1” and final execution information “OFF”
"3" and the final execution information "ON" for the program counter "0012". Then, in step S8, the current program counter “0017” and the program counter of the closest instruction among the instructions executed in the past from the program counter, that is, the final execution information are “from the execution count registration table T1”. The program counter which is "ON", in this case "0012", and its count information "3" are output to the log file T2. When the debugger starts again,
This time, according to the determination in step S1, the process proceeds to step S7 for performing the reproduction process. First, in step S9, the log file T2
From the final target program counter "0017", the target program counter "0012", and the target count "
3 ". In step S10, the variable Count
ter is initialized to “1”. Next, step S11
After executing one step, in step S12, the current program counter, in this case "0003", is compared with the target program counter "0012". Since they do not match, the process returns to step S11 to execute one step again. Steps S11 and S12 are repeated until the program counter becomes "0012".
When the program counter becomes "0012" for the first time, the process proceeds to step S13, where the variable Counter is used.
And the target number of times. The variable Counter is 1,
Since the target number of times is "3", they do not match, and step S14
As a result, the variable Counter is increased by “1” to “2”, and then returns to step S11 to execute one step. The processing from step S11 to step S14 is repeated until the condition of step S13 is satisfied. The variable Counter becomes “3”, and step S1
When the conditional expression (3) is satisfied, the process moves to step S15, and one-step execution is repeated to move the process from the current program counter to the final target program counter. When the conditional expression in step S15 is satisfied in this way, the program counter becomes "0017", and the reproduction of the process up to the target final program counter ends.

[Second Embodiment] Next, another embodiment of the present invention will be described in detail with reference to the drawings.

Referring to FIG. 5, the present embodiment uses a variable C
Step S1 in FIG. 2 for initializing the counter with "1"
0 is substituted in step S21 for substituting the target count into the variable Counter, and step 13 in FIG. 2 for comparing the variable Counter with the target count is a variable Count
er and “1” are replaced by step 22, and step 1 in FIG.
6 reduces the variable Counter by 1 step 23
3 is different from the first embodiment shown in FIG.

Next, a specific example will be described. The program of FIG. 3 is read by the input program input means 21 of FIG. 1 and stored by the program storage means 31. This program is debugged while being executed by the program execution means 41. Step S1 in FIG. 2 checks whether or not reproduction is instructed by the command input unit 22 in FIG. Since no instruction has been given, step S
The process moves to the second and subsequent processes, and debugging starts. In step S2, it is checked whether the instruction to be executed is a labeled instruction. Since the first instruction is the labeled instruction 301 of FIG. 3, the result is true and the step S
Move to 3. In step S3, the current program counter, the execution count of the current program counter, and the final execution information are stored in the execution count registration table T1. In this case, a program counter “0000”, an execution count “1”, and final execution information “ON” are stored as in the execution count registration table 401 in FIG. The processing from step S2 to step S6 is repeated until the instruction 311 is executed three times as described above. At the end of debugging in step S7, that is, the content of the execution count registration table T1 at the time when the instruction 311 is executed three times is as follows.
As shown in the execution count registration table 402 of FIG. 4, the execution count “1” and the final execution information “OFF” for the program counter “0000”, and the program counter “001”
"3" and final execution information "ON" for "2"
It has become. Subsequently, in step S8, the current program counter “0” is read from the execution count registration table T1.
017 ”, the program counter of the closest instruction among instructions executed in the past from the program counter,
That is, the program counter at the location where the final execution information is “ON”, in this case “0012”, and the number-of-times information “
3 "is output to the log file T2.

When the debugger is started again, the process proceeds to step S9 for performing a reproduction process according to the determination in step S1. First, step S9 reads the final target program counter “0017”, the target program counter “0012”, and the target count “3” from the log file T2. Next, in step S21, the variable Counter
Is substituted for the target number of times “3”. After executing one step in step S11, in step S12, the current program counter, in this case "0003", is compared with the target program counter "0012". Since they do not match, the process returns to step S11 to execute one step again. Steps S11 and S12 are repeated until the program counter becomes "0012". When the program counter first becomes "0012", the process proceeds to step S22, where the variable Counter and "1" are set.
Compare with Since the value of the variable Counter is “3”, they do not match.
Is decreased by “1” to “2”, and then the step S1 is performed again.
Return to step 1 and execute one step. This step S11
Are repeated until the condition of step S22 is satisfied. The variable Counter is "
1 ", and when the conditional expression in step S22 is satisfied,
Moving to step S15, one-step execution is repeated in order to shift processing from the current program counter to the final target program counter.

When the conditional expression in step S15 is satisfied, the program counter becomes "0017", and the reproduction of the processing up to the target final program counter ends.

The method shown in FIG. 2 and FIG.
-A program for causing a computer to execute the procedures included in these methods, which is recorded on a computer-readable recording medium such as a ROM, may be implemented by reading and executing the program.

In the above embodiment, the target program counter is obtained from the program counter corresponding to the labeled instruction. However, the present invention is not limited to this. For example, instead of the labeled instruction, , A predetermined number of instructions can be used.

[0034]

As described above, according to the present invention, the following effects can be obtained.

The first effect is that when a program is debugged and a program is found to be defective due to a certain process, and after the program is corrected, debugging is started again from the beginning and the result is to be checked in the process. That is, the debugger can automatically reproduce the movement up to the corresponding processing.

This is because, during execution of a program, execution number storage means for storing the number of executions for each instruction, and when reproduction of an execution state is requested, an instruction at a reproduction position and its execution are stored based on the stored contents. This is because there is an execution state reproducing means for reproducing the execution state by obtaining the number of times and re-executing the program.

The second effect is that the movement up to the above-mentioned processing can be realized while minimizing the data memory used by the debugger.

The reason is that only the labeled instruction is used as the target instruction for storing the number of executions in the execution number storage means, and the execution state reproducing means is the closest to the reproduction position among the previously executed instructions. This is because the table created by the execution count storage unit is minimized by shifting the processing to the reproduction position after shifting the processing to the labeled instruction.

Generally, about 10% of instructions with a label are present in the entire program. Therefore, the size of the table, that is, the size of the data memory used by the debugger can be reduced to about one tenth of the conventional size.

[Brief description of the drawings]

FIG. 1 is a diagram showing a configuration of an apparatus for executing a program re-execution method according to an embodiment of the present invention.

FIG. 2 is a flowchart for explaining a program re-execution method according to the first embodiment of the present invention.

FIG. 3 is an example of a program to which a program re-execution method according to an embodiment of the present invention and a conventional example is applied.

FIG. 4 is a diagram illustrating a state of an execution count registration table updated by the method according to the first embodiment of the present invention.

FIG. 5 is a flowchart for explaining a program re-execution method according to a second embodiment of the present invention.

FIG. 6 is a flowchart for explaining a program re-execution method.

FIG. 7 is a diagram of an execution count registration table used in the method shown in FIG. 6;

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Processing control means 2 Input means 3 Storage means 4 Execution means 5 Output means

──────────────────────────────────────────────────続 き Continuation of front page (56) References JP-A-56-58199 (JP, A) JP-A-7-191883 (JP, A) JP-A-62-196238 (JP, A) JP-A-60-1985 27037 (JP, A) JP-A-6-139107 (JP, A) (58) Fields investigated (Int. Cl. ⁷ , DB name) G06F 11/28 G06F 11/34

Claims (8)

(57) [Claims] 1. A program Program rerun process to be re-executed until the instruction debugging is complete and during from the start to the end of debugging, the pro
Multiple specific instructions that are part of all instructions in the
The value of the program counter when executing each of the instructions,
The number of executions of each of the instructions, and
Is executed last before the end of debugging
The final execution information indicating whether or not the
And corresponding to the plurality of specific instructions.
A table consisting of such records in the storage means
Step and, at the end of debugging, the plurality of records in the table.
One of the records, which is stored in that record
Is not stored in the record.
Before the end of debugging among the plurality of specific instructions
Record showing that it was the last run of
Number of executions, which is the number of executions stored in the
Of the program counter stored in such records
Is stored in the storage means.
And all instructions in the program at the end of the debugging
Program counter when the last instruction was executed
Means for storing the value of the final purpose program counter which is the value of
And after executing the program until the current value of the program counter reaches the value of the target program counter by the target number of times at the time of re-execution, the value of the current program counter is changed to the value of the final target program. Executing the program until the value becomes a value. 2. The program re-execution method according to claim 1, wherein the execution of the program at the time of the re-execution is a step execution. 3. The program re-execution method according to claim 1, wherein the specific instruction is a labeled instruction. 4. The program re-execution method according to claim 1, wherein the specific instruction is an instruction for every predetermined number. 5. The computer according to claim 1 , further comprising:
Multiple specific instructions that are part of all instructions in the
The value of the program counter when executing each of the instructions,
The number of executions of each of the instructions, and
Is executed last before the end of debugging
The final execution information indicating whether or not the
And corresponding to the plurality of specific instructions.
A table consisting of such records in the storage means
Step and, at the end of debugging, the plurality of records in the table.
One of the records, which is stored in that record
Is not stored in the record.
Before the end of debugging among the plurality of specific instructions
Record showing that it was the last run of
Number of executions, which is the number of executions stored in the
Of the program counter stored in such records
Is stored in the storage means.
And all instructions in the program at the end of the debugging
Program counter when the last instruction was executed
Means for storing the value of the final purpose program counter which is the value of
And after executing the program until the current value of the program counter reaches the value of the target program counter by the target number of times at the time of re-execution, the value of the current program counter is changed to the value of the final target program. A computer-readable recording medium on which is recorded a program for executing the program until a value is reached. 6. The computer-readable recording medium according to claim 5, wherein the execution of the program at the time of the re-execution is a step execution. 7. The computer-readable recording medium according to claim 5, wherein the specific instruction is a labeled instruction. 8. The computer-readable recording medium according to claim 5, wherein the specific instruction is an instruction for every predetermined number.