JPH0764820A - Debug processor - Google Patents

Abstract

(57) [Summary] [Purpose] To provide a debug processing device in which a pointer is returned to a specified position and re-execution is possible from the pointer [Configuration] Debug main body 1 that performs debug processing for a given program The state saving mechanism unit 3 is connected to, and each time a command is generated during the debugging process, it is determined whether or not the current state should be saved. When saving is necessary, the saving unit 4 stores the variables in the program at that time. Pass the state of.
The storage unit stores the information (state) sent from the state storage mechanism unit together with the command history index. Further, when a re-execution command is given to the debugger body from the input unit 2, the start position for re-execution is sent to the back command processing unit 5, and based on the re-start position given there, the information stored in the storage unit is rewritten. Use to reproduce the state of the program at the specified start position.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a debug processing device.

[0002]

As is well known, during program development,
In order to detect a bug existing in a source level or assembler level program and correct it to complete the program, the program under development is input to a debug processing device called a debugger, debugging system, etc. It's supposed to run from the beginning.

[0003]

However, in the conventional device, although the program can be continued from the pointer of the debugger (the position where the execution of the program is temporarily stopped by the debug processing device) in the program, the program can be continued.
When the program cannot be returned to an arbitrary position and is repeatedly executed by changing some conditions of the program, the program must be restarted from the beginning each time, which complicates the work.

That is, in the program development environment, the program up to a certain line number X is completed (no bug), and there are many cases where the correction is performed from the Xth line onward. However, in such a case, after breaking at a predetermined line number on and after the X-th line, some conditions of the program cannot be changed and the program cannot be restarted from the X-th line. Therefore, for example, when it is necessary to input various conditions from an input device such as a keyboard as an initial condition before executing the program, the above input work must be performed each time the program is re-executed from the beginning. Becomes

The present invention has been made in view of the above-mentioned background, and its purpose is to return a pointer to a designated position in a program which has already been executed, and to make it re-executable from the pointer. It is to provide a processing device.

[0006]

In order to achieve the above object, in a debug processing device according to the present invention, a debug main body for performing a debug process on a given program, and a predetermined timing during the debug process. In at least the state saving means for storing the state of the value of the variable in the program in the storage means, and the re-execution start position for returning to the arbitrary position already executed in the program, from the re-execution start position And a back command processing means for returning the state of the program to the state of the re-execution start position based on the information on the predetermined state stored in the previous storage means.

[0007]

Function: The debug main body is operated for the given program to perform the debug processing. At this time, the state storage means extracts the state of the program (variable value or the like) at a predetermined timing and sequentially stores it in the storage means. Then, when the user wants to return to the predetermined location that has already been executed, the re-execution start position is given. Then, the back command processing means reads a predetermined state (usually the closest one) before the given re-execution start position from the states stored in the storage means, and puts the program in the read state. Set. If the re-execution start position and the read state do not match, the program is sequentially executed up to the re-execution start position. Then, after that, the debug process is executed from that position.

[0008]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS A preferred embodiment of a debug processing device according to the present invention will be described in detail below with reference to the accompanying drawings. FIG. 1 shows a first embodiment of the present invention. As shown in the figure, reference numeral 1 denotes a debugger body, which has the same basic function as a conventional so-called debugger that executes a given program while sequentially executing a given program. Then, a program set, various conditions such as commands and variables, and a start position for re-execution are input to the debugger main body 1 via the input unit 2.

According to the present invention, the state saving mechanism unit 3 is connected to the debugger body 1, and every time a command is generated in the debugger body 1 during a debugging process, the debugger body 1 sends a command to the state saving mechanism unit 3. This state saving mechanism section 3
Then, after judging whether to save the current state based on the given command, the command is returned to the debugger body 1. Further, when it is necessary to save the data, the states of variables and the like in the program at that time are passed to the storage unit 4 in the next stage.

That is, in order to return the pointer to the designated position, it is necessary to reproduce the state of the value of the variable when the position was being executed, so each state is saved at a predetermined timing. There is a need.

As such a timing, for example, there is a method of storing a state each time a program instruction is executed, that is, each time the processing of each line number at the source level or the assembler level is executed.

In the method (1), the desired line number (start position) can be suddenly returned when re-executed.
A large capacity of the storage unit 4 is required. Therefore, in consideration of the fact that the state of a variable value or the like is changed when a command is executed, there is also a method of saving the state before execution of the command each time the command is executed.

Further, in order to further reduce the used capacity of the storage unit 4, one of the above-mentioned methods is basically used, and the state before each processing is stored every M times of commands or N times of commands. May be.

Further, in order to further reduce the used capacity based on the method based on the command, the content of the command is judged, and even if the command is executed, for example, "break command", before and after the command execution. In the case of a command whose state does not change, the number of times of N times may not be counted.

In the present invention, the state saving timing may be any of the above-mentioned methods, and the present invention is not limited to these, and the state saving may be performed at any timing. However, in the present example, the above-mentioned method is adopted. . Then, specifically, the processing is performed according to the flowchart shown in FIG.

That is, a command to be executed is received from the debugger body 1 and the command is registered in the history memory of the storage unit 4 (ST1, 2). Then, it is judged whether or not the command is a command for changing the state (ST
3) In the case of a command such as a break command in which the state of the value of a variable does not change before and after the execution of the command, the command is returned to the debugger body 1 as it is and the command is executed (ST8). ).

If it is determined in step 3 that the command changes the state, i is incremented and the i is incremented.
Is determined to be N (ST4, 5). Then, when i is less than N, the process directly jumps to step 8,
Execute the command. On the other hand, when the value of i becomes N, the state of the value of each variable on the program before command execution and the command history index are sent to the storage unit 4 and stored in the storage unit (ST6). After that, the value of i is reset (ST7) and the command is executed (S
T8).

The storage unit 4 is adapted to store the information sent from the state storage mechanism unit 3. Further, a history memory is provided in the storage unit 4, and the command executed regardless of whether the above information is stored is registered in the history memory together with the execution location (line number etc.). When the above information is registered, the state and the index of the history memory in which the command executed at that time is stored are also stored together. Further, the storage unit 4 is adapted to send predetermined data based on the start position information requested by the bag command processing unit 5.

Further, the bag command processing unit 5 reproduces the state of the designated start position using the information stored in the storage unit 4 based on the start position given from the debugger body 1 based on the re-execution command. It is supposed to do.

The function of the bag command processing section 5 is as shown in FIG. That is, the re-execution start position is given from the input unit 2 via the debug body 1 (S
In step T9, the information stored in the storage unit 4 is accessed to find the position closest to the start position and previously saved (ST10).

That is, as shown in FIG. 4, line number 10
If the command a of 00 is the Nth command, the state before execution of the line number 1000 is saved. When the pointer at the start position is 1110, the line number 1000, which is the closest position before 1110, is detected.

Next, the state before the command a is executed is read from the storage unit 4, and the values of the variables in the program are returned to that state (ST11). Since the specified start position and the position of the saved state do not normally match, the history memory stored in the storage unit 4 is referred to and the program is executed line by line while considering the registered commands. Then, when it reaches the start position, it stops (ST12).
Then, the debug main body 1 operates after waiting for a debug processing start command from the user to perform normal debugging.

That is, in the example of FIG. 4, the instructions described in each line are executed, and the commands a to d are executed at appropriate positions between them. When the line number 1110 is reached, the execution is stopped and the input is awaited.

[0024]

As described above, in the debug processing apparatus according to the present invention, since the program state (information necessary for reproduction) is stored in the storage means at an appropriate timing during the debug processing, it has already been executed. When returning to a predetermined place and trying to execute from there, it is possible to deal with it by reproducing the program in the saved state. As a result, when re-executing debug processing, it is not necessary to always start from the beginning as in the past, and it is not necessary to repeatedly input initial conditions, etc., and it is possible to partially execute the program and improve the efficiency of debug processing. To do.

[Brief description of drawings]

FIG. 1 is a block diagram showing an embodiment of a debug processing device according to the present invention.

FIG. 2 is a flowchart illustrating the function of a state storage mechanism unit.

FIG. 3 is a flowchart illustrating the function of a back command processing unit.

FIG. 4 is a diagram illustrating an example of an operation.

[Explanation of symbols]

 1 Debug main body 2 Input section 3 State saving mechanism section 4 Storage section 5 Back command processing section

Claims (2)

[Claims] 1. A debug main body for performing a debug process on a given program, and a state saving means for storing at least a state such as a value of a variable in the program in a storage means at a predetermined timing during the debug process. Receiving a re-execution start position for returning to an arbitrary position already executed in the program, and changing the state of the program on the basis of information on a predetermined state stored in the storage means before the re-execution start position. A debug processing device comprising a back command processing means for returning to the state of the re-execution start position. 2. The debug processing device according to claim 1, wherein the predetermined timing detects a command whose state is changed by execution and performs the command every N detected commands.