JP2715988B2 - Program simulator device and program debugging method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program simulator that can be re-executed by rerunning an already executed program, and a program debugging method for debugging a program using the program simulator.

[0002]

2. Description of the Related Art In general, in a conventional program simulator apparatus, as a program execution method for debugging a program, a normal program in which an executed program is stopped by setting a break point, interrupting from an external terminal, or the like. Execution methods are known. Also, a step execution method is known in which when a program is a machine language, instructions are executed one by one, and when a program is a high-level language, instructions for each line are executed. In each of these methods, when debugging a program, the program is executed in the forward direction.

On the other hand, in recent years, when debugging a program, a program which executes the program in the reverse direction has been proposed. Such a program debugging method,
This is a step execution type return method in which the program is returned one step at a time.

[0004]

When a program is debugged by a program simulator device, a part of the program is obtained by changing the values of resources (that is, addresses of the program and memory, register contents of a CPU executing the program, and the like). You may want to change and re-execute. In such a case, in the conventional simulator apparatus, as described above, a method of re-executing a program in the forward direction from the start address and a method of step-executing in the reverse direction one instruction at a time.
There is a street.

However, in the former case, there is a disadvantage that when a program to be re-executed is located at the end of the program, it takes an enormous amount of time to re-execute the program. In the latter case, no particular problem occurs if the number of steps to be reversed is a few.
In the case of a subroutine call that involves several hundred steps, there is a problem that it takes a considerable amount of time to return to the head address of the subroutine call if the instruction is moved backward by one instruction. Therefore, an object of the present invention is to reduce the debugging work time when re-debugging a part of the program when the program is debugged.

[0006]

SUMMARY OF THE INVENTION In order to solve such a problem, the present invention provides a program executed in a forward direction.
A reverse instruction generating unit for generating a reverse instruction from an instruction, a first stack unit for storing an address of one executed instruction and a corresponding reverse instruction, and an address of this function at a starting address of a function including a plurality of instructions; A second stack unit in which the resource value indicating the memory address and the contents of the register at that time is written, a restoration unit for restoring the resource value of the second stack unit, and a resource value written in the second stack unit If
Executes each instruction in the function based on the value of the resources of the function taken from the second stack portion in the positive direction, the first stack
The first stack part when the reverse instruction is held in the master part
And an instruction execution unit for executing the reverse instruction taken out of the instruction and returning the instruction . When debugging a program, a reverse instruction is created and retained from one instruction of the program executed in the forward direction, and the address of this function and the memory address at that time are stored at the start address of a function composed of a plurality of instructions. If you want to re-debug the program while retaining the values of resources indicating the contents of registers and the like ,
Each instruction of the function from the start address of the function number and the actual <br/> line sequentially in the forward direction, and it retained the inverse instruction executes one instruction at a time Pro
This is a method in which each instruction of the gram is executed in the backward direction .

[0007]

When debugging a program, a reverse instruction is created and retained from one instruction of the program executed in the forward direction, and the address of this function is stored at the head address of the function consisting of a plurality of instructions, and the memory at that time. While re-debugging a program while retaining the values of resources indicating the contents of addresses and registers, etc., when re-debugging the program, the retained inverse instructions are executed one instruction at a time to return to the next instruction, and the correct address is sequentially read from the start address of the function Run in the direction.

[0008]

DESCRIPTION OF THE PREFERRED EMBODIMENTS The present invention will be described below with reference to the drawings. FIG. 3 is a block diagram showing one embodiment of the present invention. In the figure, 1 is a program to be debugged (hereinafter, referred to as a program to be debugged).
The storage unit 2 for storing the program) is a program simulator device for debugging the program in the storage unit 1.

Further, the program simulator device 2 comprises:
It is configured as follows. That is, reference numeral 21 denotes a stack unit in which the address of each instruction of the program fetched from the storage unit 1 and its reverse instruction are stored as data for each instruction and data is first-in, first-out. During execution, the start address information of a function such as a subroutine consisting of a plurality of instructions in this program or an interrupt processing routine, and the address of a memory (not shown) accessed by an instruction execution unit 26 comprising a CPU or the like at that time. The stack unit 23 stores the information such as the contents and the register value of the instruction execution unit 26 as resource value data for each function, and performs a first-in first-out operation of data. This is an inverse instruction creation unit that generates an inverse instruction of each instruction and stores it in the stack unit 21.

Reference numeral 24 denotes a writing unit for storing the resource values of the functions in the program in the stack unit 22; 25, a restoring unit for reading and restoring the resource values of the stack unit 22; An instruction that executes the reverse instruction of the unit 21 step by step and executes the program in the reverse direction, and sequentially executes each instruction of this function in the forward direction (normal direction) based on the resource value of the function restored by the restoration unit 25 The execution unit. In the above-described reverse instruction creating unit 23, for example, if the instruction fetched from the storage unit 1 is an increment (an instruction to increase the value by one), this is decremented (an instruction to decrease the value by one). A reverse instruction is generated.

Next, an outline of the operation of the program simulator device 2 configured as described above will be described. When debugging a program in the storage unit 1, the program simulator device 2 stores the program in the storage unit 1.
Each instruction of this program is sequentially executed in the forward direction by the fetch instruction execution unit 26 for each instruction. In this case, the reverse instruction creating unit 23 generates an inverse instruction of the instruction fetched from the storage unit 1 and sequentially stores it in the stack unit 21.
If the fetched instruction is a function such as a subroutine, the writing unit 24 stores the above-described resource values related to this function in the stack unit 22.

Here, when it becomes necessary to re-debug the program and the debug operator operates a first key (not shown), the instruction execution unit 26 causes the instruction execution unit 26 to execute Fetch and execute the most recently stored reverse instruction. Subsequently, when the first key operation is performed again, the instruction execution unit 26 fetches the next reverse instruction stored in the stack unit 21 and executes it. In this way, the instructions are sequentially executed one step at a time in the backward direction.

When a debug operator operates a second key (not shown) when re-debugging a program, the restoring unit 25 causes the restoring unit 25 to store the most resource value of each function stored in the stack unit 22. The stored new resource value is given to the read command execution unit 26. The instruction execution unit 26 sequentially executes the program of the function corresponding to the resource value in the forward direction from the start address based on the resource value. in this way,
If you want to redo debugging while debugging a program, such as re-debugging the debugged program,
Not only can instructions be executed backwards one instruction at a time, but re-debugging in function units can be performed easily and in a short time. Therefore, when re-debugging a function (subroutine or the like) particularly involving several hundred steps, the time required for the debugging work can be greatly reduced.

Next, the operation of the main part of the program simulator apparatus 2 will be described in detail with reference to the flowcharts of FIGS. First, the operation when the program is executed in the forward direction at the time of program debugging shown in FIG. 2 will be described. When debugging a program in the storage unit 1 as described above, the program simulator device 2 fetches the program one instruction at a time from the storage unit 1 and gives the program to the instruction execution unit 26 for execution. In this case, the simulator device 2 In step S1, it is determined whether the instruction fetched from the storage unit 1 corresponds to the instruction at the start address of the function.

If the fetched instruction is not the instruction at the start address of the function, the reverse instruction creator 23 proceeds to step S2.
This instruction is read in step S3 to generate an instruction reverse to the executed instruction in step S3. Thereafter, the address of the instruction and the generated reverse instruction are pushed and stored in the stack unit 21 by the reverse instruction creating unit 23 in step S4. If the extracted instruction corresponds to the instruction at the start address of the function, the writing unit 24 pushes the value of each resource of this function to the stack unit 22 in step S5 and stores it. Thereafter, in steps S2 to S4, the reverse instruction generation unit 2
3 creates and stores the reverse instruction in the same manner as described above.

After the inverse instruction is stored in the stack unit 21 and each resource value of the function is stored in the stack unit 22, the simulator apparatus 2 determines in step S6 whether there is free space in the stack unit 21 or the stack unit 22. Then, if there is a free space, the extracted instruction is executed by the instruction execution unit 26 in step S7. If there is no free space in the stack capacity, the old data (old command) in the corresponding stack section is deleted in step S8, and the command execution unit 26 is caused to execute the command in step S7.

Next, at step S9, the simulator device 2
Determines whether the instruction has been executed backward. If this is "NO", each instruction of the program in the storage unit 1 is sequentially fetched until the end of the simulation (that is, debugging) in step S10 becomes "YES".
The reverse instruction is generated and stored, the resource value of the function is stored, and the extracted instructions are sequentially executed.

Thus, the program is debugged. Here, it is necessary to re-debug the program executed during program debugging by executing such a program, and when any of a first key or a second key (not shown) is operated by a debug operator, the simulator is activated. The apparatus 2 determines “YES” in the determination of “return the instruction” in step S9. In this case, the instruction return processing shown in the flowchart of FIG. 1 described later is started in step S11.

That is, in step S21 of FIG. 1, it is determined whether or not to return to the beginning of the function by the second key operation, and if this is "YES", it is determined in step S22 whether there is an empty space in the stack unit 22. to decide. And the stack part 22
If there is no free space in step S23,
Then, among the resource values of the functions stored in the stack unit 22, the most recently stored resource value is popped (fetched) and supplied to the instruction execution unit 26. The instruction execution unit 26 sequentially executes the program of the function corresponding to the resource value in the forward direction from the start address based on the resource value.

When the execution of the program of the function is completed, the simulator apparatus 2 proceeds to step S24 through "NO" of "Do you want to end instruction return?"
Return to 21. Here, when the second key operation is performed again, after "NO" of "Is the stack 22 empty?" In step S22, in step S23, a new resource value to be stored is popped from the stack unit 22 and an instruction is issued. The program is given to the execution unit 26 and the program of the function is similarly executed. Thus, the resource values of the stack unit 22 are sequentially taken out, and the programs of the functions based on the resource values are executed, so that the stack unit 22 is completely empty, and the determination in step S22 is “YES”. Then, the simulator device 2 ends the program execution at the time of re-debugging. Also, when the end key (not shown) for terminating the return of the instruction at the time of such re-debugging is operated and the determination in step S24 becomes "YES", the simulator device 2 ends the program execution at the time of re-debugging.

Next, when the first key operation is performed by the debug operator to return the instruction, the determination of "return to the beginning of the function?" In step S21 is "NO".
Becomes In this case, the simulator device 2 performs step S2
At 5, it is determined whether or not the stack unit 21 is empty. If there is no free space in the stack unit 21, the instruction execution unit 26 in the simulator device 2
Is popped and read out of the address of each instruction stored in and the inverse instruction stored therein, and the inverse instruction is executed in step S27.

When the execution of the reverse instruction is completed, "N" of "Do you want to end instruction return?"
After "O", the process returns to step S21. Here, when the first key operation is performed again, the simulator device 2 proceeds to step S25 via “NO” of “Return to beginning of function?” In step S21, and similarly in step S25, the stack unit It is determined whether or not 21 is empty. In this case, if the stack unit 21 is not empty, step S26
Then, the instruction execution unit 26 is caused to pop the next stored reverse instruction from the stack unit 21 and execute it in step S27.

In this way, the inverse instructions of the stack unit 21 are sequentially fetched and executed, so that the stack 21 is completely empty. If the determination in step S25 becomes "YES", the simulator apparatus 2 re-debugs. The execution of the current program ends. Also, when the end key for terminating the retrace of the instruction is operated during such re-debugging and the determination in step S24 becomes "YES", the simulator device 2 ends the program execution at the time of re-debugging.

[0024]

As described above, according to the present invention, when debugging a program, a reverse instruction is created and retained from one instruction of a program executed in the forward direction, and the start address of a function consisting of a plurality of instructions is stored. Holds the address of this function, the memory address at that time, the value of resources indicating the contents of the register, etc., while re-debugging the program, executes the held reverse instruction one instruction at a time to return the instruction, and Are sequentially executed in the forward direction from the start address of the function, so that the time required for the debugging work when re-debugging a program of a function having several hundred steps can be greatly reduced.

[Brief description of the drawings]

FIG. 1 is a flowchart showing an operation of a main part of a program simulator device according to the present invention.

FIG. 2 is a flowchart showing an operation of the apparatus of the embodiment when debugging a program.

FIG. 3 is a block diagram illustrating a main configuration of the apparatus according to the embodiment.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 ... Storage part, 2 ... Program simulator apparatus, 21
22: stack unit, 23: reverse instruction creation unit, 24: writing unit, 25: restoration unit, 26: instruction execution unit.

Continuation of the front page (56) References JP-A-62-85347 (JP, A) JP-A-2-50228 (JP, A) JP-A-3-158937 (JP, A) JP-A-4-342038 (JP) JP-A-4-352245 (JP, A) JP-A-4-1533741 (JP, A) JP-A-4-328644 (JP, A) JP-A-5-61717 (JP, A) JP-A-5-81075 (JP, A) JP-A-5-108404 (JP, A) JP-A-6-222952 (JP, A) JP-A-7-84832 (JP, A) JP-A-59-165106 (JP, A) A) JP-A-63-24424 (JP, A)

Claims (2)

(57) [Claims] An inverse instruction creating unit that creates an inverse instruction from one instruction of a program executed in a forward direction; a first stack unit that holds an address of one instruction to be executed and a corresponding inverse instruction; A second stack section in which start address information of a function including a plurality of instructions in the program, a memory address and register contents corresponding to the start address information are written as resource values of the function, and a second stack section. And a second stack unit for restoring the resource value of
When said resource value is written to execute each instruction of the function on the basis of the resource value of the function restored is Eject from the second stack portion in the positive direction, opposite to the first stack portion
If the instruction is held, it is taken from the first stack.
A program simulator apparatus comprising: an instruction execution unit that executes an issued reverse instruction to return the instruction; and has a function of executing the reverse instruction for each instruction and a return execution function for each function. 2. When debugging a program, a reverse instruction is created and retained from one instruction of a program to be executed in the forward direction, and the reverse instruction is created at the start address of a function consisting of a plurality of instructions in the program. address of a function, while retaining the value of resources that indicates the contents of the address of the memory and registers, etc., when performing re-program debugging, each instruction of the function from the starting address of the previous SL functions sequentially accessed at that time Executes in the forward direction and executes the retained reverse instruction for one instruction.
Execute each instruction of the program in the backward direction
Program debugging method characterized by.