JP2001051872A - Program debugging device and recording medium where program is recorded - Google Patents

Abstract

PROBLEM TO BE SOLVED: To easily perform return debugging. SOLUTION: This debugging device executes instructions 3 of each step constituting a program 1 by using the execution results of instructions 3 which are temporarily stored in a work memory 6 and executed in last steps and overwrites the execution results in the work memory. This device is equipped with means 11 to 13 which store and hold the execution results of the instructions written to the work memory in a trace file 14 together with step numbers, a means 16 which extracts the execution results of the step numbers of the instructions executed right before the step numbers stored in the trace file and writes them to the work memory 6, and a means 5 which executes the instruction of specified step numbers after the mentioned means writes the execution results 18 to the work memory.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program debugging device for debugging a created program, and a recording medium which is incorporated in the program debugging device and records a program for program debugging.

[0002]

2. Description of the Related Art A program debugging apparatus for debugging a created program is configured, for example, as shown in FIG. In the created program 1, an instruction 3 is written for each step number 2. The program counter 4 counts step numbers. The program execution unit 5 executes the instruction 3 of the step number 2 specified by the count value (count value) of the program counter 4, and writes the execution result to the work memory 6. In this case, the next instruction 3 is often executed using the execution result of the instruction 3 executed immediately before. Since the work memory 5 has a function of temporarily storing the execution result of each instruction 3, when a new execution result of the instruction 3 occurs, the execution result overwrites the execution result of the previously executed instruction. Is done.

In the course of executing the instruction 3 of each step, the program execution section 5 receives, via an input / output I / O 7,
Data is written to the external memory 8 or data is taken from the external memory 8.

Further, the counting operation of the program counter 4 is temporarily stopped at the step number 2 designated by the operator via the operation unit 9 and the execution result of the instruction 3 of the step number 2 is displayed on the display unit 10. be able to.

[0005] As described above, the operator suspends the debugging operation at an arbitrary step number 2 in the debugging operation of the created program 1, and displays the execution result of the instruction 3 at that time on the display unit 10. You can check.

[0006]

However, the program debug device shown in FIG. 5 still has the following problems to be improved.

That is, the operator can confirm the execution result of the program 1 at an arbitrary position in the debugging operation process. However, in this debugging operation, since each instruction 3 is executed in ascending order of the step number in the program 1, it is possible to specify the step number 2 of the unexecuted instruction 3 and confirm the execution result of this instruction 3. It is.

However, the result of execution of the instruction 3 at the executed step number cannot be displayed. The reason is that the execution result of each instruction 3 in each step is temporarily stored in the work memory 6, but the instruction 3 in the next step is stored.
Is executed, the execution result is overwritten by the execution result and is erased from the work memory 6. Therefore, even if the instruction 3 is specified by the step number 2, the execution result of the instruction 3 immediately before the instruction 3 Is unknown, and the corresponding instruction 3 cannot be executed.

Therefore, if an abnormal point is found in the result of the debugging after the first debugging process for the created program is completed, a step number is specified in order to investigate the cause of the abnormality, and the corresponding position is designated. Must be re-executed. In such a case, program 1
Needs to be restarted from the beginning of step number 2.

[0010] Therefore, when the program to be debugged is long, if the debugging operation is executed from the beginning of the program each time, a large amount of labor and time are required for the debugging operation, and the debugging operation for the program using this program debugging apparatus is required. Efficiency is greatly reduced.

Incidentally, in the word processing software, in order to cancel the erroneous key operation when the operator erroneously operates the key, an "UNDO" function for returning the execution state of the program to the immediately previous key operation state is provided. It is built in.

However, in the "UNDO" function, a past execution state is stored in a memory for each key input. Since a plurality of instructions are frequently executed by one key operation, even if this "UNDO" function is incorporated in the program debugging device, the operator must obtain an execution result for each instruction. Can not.

Further, in the "UNDO" function, the executed key operations are traced back one by one, so that the execution state of the target key operation cannot be reproduced by one operation.

The present invention has been made in view of such circumstances, and by executing and storing the execution results of the instructions in each step, it is possible to independently execute an instruction at an arbitrary position in a debug-executed program. It is an object of the present invention to provide a program debugging device and a recording medium on which a program for performing program debugging is recorded, which can greatly improve a debugging operation efficiency of the program.

[0015]

According to the present invention, an instruction of each step constituting a created program is executed using an execution result of an instruction executed in the immediately preceding step temporarily stored in a work memory. Then, this execution result is applied to a program debugging device that overwrites the previous execution result in the work memory and outputs this execution result as necessary.

In order to solve the above-mentioned problems, in the program debugging apparatus of the present invention, each time an instruction of each step is executed, the execution result of the instruction written in the work memory is traced together with the step number. Extracts the execution result of the step number of the instruction executed one step before the corresponding step number stored in the trace file in response to the means for storing and holding in the file and the debug re-execution command specifying the step number And a means for executing an instruction of a designated step number after the execution result is written to the work memory by this means.

In the program debugging apparatus thus configured, every time the instruction of each step in the created program is executed, the execution result of the instruction written in the work memory is stored in the trace file together with the step number. It is stored.

As described above, the fact that the execution result of each executed instruction is not discarded but is stored and held in the trace file means that the execution result of the immediately preceding instruction at the arbitrary position is also stored and held. Will be. As a result, an instruction at an arbitrary position can be immediately executed using the execution result of the immediately preceding instruction.

Therefore, debugging of an instruction at an arbitrary position in a debugged program can be re-executed. After the first debugging process for a created program is completed, an error is detected when an abnormal point is found in the debugging execution result. The efficiency of the cause investigation work can be improved.

Further, in the program debugging device of another invention, every time the instruction of each step is executed, the execution result of the relevant instruction written in the work memory is stored and held in the trace file together with the step number and the relevant instruction. In response to a debug re-execution instruction specifying one instruction included in the program, the execution result of the instruction executed immediately before the corresponding instruction stored in the trace file is extracted and the work is performed. There are provided means for writing to the memory, and means for executing the designated instruction after the execution result is written to the work memory by the means.

In the program debugging apparatus thus constructed, each time an instruction of each step in the created program is executed, the execution result of the instruction written in the work memory is traced together with the step number and the instruction. Stored in a file.

Therefore, similarly to the program debugging device of the invention described above, debugging of an instruction at an arbitrary position in a debugged program can be re-executed. Further, according to the present invention, it is possible to re-execute debugging in which an instruction is specified.

According to still another invention, an instruction of each step constituting a created program is executed using an execution result of the instruction executed in the immediately preceding step temporarily stored in the work memory, and the execution is executed. This is a recording medium that records a program incorporated in a program debugging device that overwrites the result with the immediately preceding execution result in the work memory and outputs the execution result as necessary.

The program stored in the recording medium stores the execution result of the corresponding instruction written in the work memory together with the step number in a trace file every time the instruction of each step is executed. In response to the debug re-execution command specifying the step number, the execution result of the step number of the instruction executed immediately before the corresponding step number stored in the trace file is extracted and written to the work memory. After the execution result is written in the work memory, the instruction of the designated step number is executed.

[0025]

DESCRIPTION OF THE PREFERRED EMBODIMENTS One embodiment of the present invention will be described below with reference to the drawings. FIG. 1 is a block diagram showing a schematic configuration of a program debugging device according to the embodiment. The same parts as those of the conventional program debugging apparatus shown in FIG. 5 are denoted by the same reference numerals, and detailed description of the overlapping parts will be omitted.

In the created program 1, an instruction 3 is written for each step number 2. The program counter 4 counts step numbers. The program execution unit 5 executes the instruction 3 of the step number 2 specified by the count value (count value) CN of the program counter 4 and writes the execution result to the work memory 6. The work memory 5 has a function of temporarily storing an execution result of each instruction 3. When a new execution result of the instruction 3 is generated, the execution result is stored in the work memory 6 of the previously executed instruction. Overwritten with the execution result.

In the course of executing the instruction 3 of each step, the program execution unit 5 receives, via the input / output I / O 7,
Data is written to the external memory 8 or data is taken from the external memory 8.

Further, the counting operation of the program counter 4 is temporarily stopped at the step number 2 designated by the operator via the operation unit 9, and the execution result of the instruction 3 of the step number 2 is displayed on the display unit 10. be able to.

Further, in the program debugging device of this embodiment, the data fetching unit 11, the execution result buffer 12, the execution result writing unit 13, the trace file 14,
A return position designation unit 15 and an execution result extraction unit 16 are provided.

The program execution unit 5 and the data acquisition unit 1
1. The execution result writing unit 13 and the execution result extraction unit 16
It is realized by a program recorded in a storage medium such as M or ROM.

As shown in FIG. 2, in the trace file 14, each instruction 3 of the program 1 executed by the corresponding program execution unit 5, each step number 2, Each execution result 18 is written. The reason why the execution number 17 does not match the step number 2 is that the instruction 3 is a branch instruction or the like, and the instruction 3 to be executed next is not necessarily the instruction 3 of the next step number 2.

The data fetching unit 11 includes the program execution unit 5
Is executed and written in the work memory 6
Along with the execution number 17, the step number 2, and the instruction 3, and writes them into the execution result buffer 12.

When the execution result buffer 12 becomes full with the execution result 18, the execution result writing unit 13 writes the execution result 18 stored in the execution result buffer 12 into the trace file 14.
Move to

When the operator inputs a debug re-execution command specifying the step number 2 or the command 3, the return position specifying unit 15 converts the input step number 2 or the command 3 into the program execution unit 5 and the execution result extraction. At the same time, the input step number 2 is set to the count value CN of the program counter 4.

The execution result extraction unit 16 is provided with the return position designation unit 1
The execution result 18 of the instruction 3 executed immediately before (immediately before) the step number 2 or the instruction 3 designated from 5 is written in the work memory 6.

The program debug device having such a configuration executes the first debug processing operation for the program 1 created according to the flowchart shown in FIG.

First, the count value CN of the program counter 4
Is set to the initial value of "0" (S1). Next, the program execution unit 5 is activated and the count value C of the program counter 4 is calculated.
The instruction 3 of the step number 2 indicated by N is read and executed (S2). Then, the execution result 18 is stored in the execution number 17,
The data is written into the work memory 6 together with the step number 2 and the corresponding instruction 3 (S3). During the execution of this instruction 3, if necessary
The execution result of the previously executed instruction 3 stored in the work memory 6 is used.

Next, the data fetching unit 11 is activated, and the execution result 18 written this time in the work memory 6 is stored in the execution number 1
7, along with the step number 2 and the instruction 3, are written into the execution result buffer 12 (S4).

When the execution result buffer 12 becomes full (S
5), the execution result writing unit 13 is activated, reads the execution result 18 stored in the execution result buffer 12, and additionally writes it to the trace file 14 shown in FIG. 2 (S6). Thereafter, the count value CN of the program counter 4 is updated by 1 (S7).

CN = CN + 1 When it is confirmed that the updated count value CN does not exceed the maximum value CNmax determined by the final number of steps of the program 1 (S8), the process returns to S2 and reads the instruction 3 of the next step number. Run.

When the updated count value CN exceeds the maximum value CNmax, the first debug processing operation for the created program 1 ends.

Although the flowchart of FIG. 3 shows a case where no branch condition is included in each instruction 3 of the created program 1, if a branch instruction is included, it is determined based on the execution result of the branch instruction. , The count value CN of the program counter 4
Shifts to the step number of the branch destination. However, even if the step number 2 moves discontinuously, the execution number 17 of each instruction 3 executed by the program execution unit 5 maintains a series of consecutive numbers.

Also, 1 for the created program 1
When the operator inputs a debug re-execution command specifying the step number 2 from the return position specifying unit 15 after the end of the second debug processing operation, the debug re-execution processing is executed according to the flowchart shown in FIG.

When a debug re-execution command designating step number 2 is input (Q1), the execution result extraction unit 16 is started up and immediately before the step number (CNa) designated by the return position designation unit 15. (Immediately before) step number (CNa-
The execution result 18 of the instruction 3 of 1) is read from the trace memory 14 (Q2) and written to the work memory 6 (Q3).
Next, the count value CN of the program counter 4 is matched with the designated step number CNa (Q4).

CN = CNa Then, the program execution unit 5 is started, and the instruction 3 of the step number 2 designated by the count value CN of the program counter 4 is read and executed. In this case, if necessary, the execution result of the previously executed instruction written in the work memory 6 by the execution result extraction unit 16 is used (Q5). And
The new execution result 18 is written to the work memory 6 (Q6). Thereafter, the current execution result 18 is displayed on the display unit 10 (Q7).

If the instruction to continue the debugging is not input from the operation unit 9, a predetermined ending process is executed (Q9), and the current debugging re-execution process is ended.

When an instruction to continuously execute debugging is input from the operation unit 9, the flow shifts to S7 in FIG. 3, updates the count value CN of the program counter 4 by 1, returns to S2, and returns to S2. Instruction 3 of step number 2 is read and executed. That is, the debug operation of the program 1 is started from the designated step number.

In the program debugging apparatus thus configured, in the first debugging operation of the created program 1, each step number 2
Each time the instruction 3 is executed by the program execution unit 5, the execution result 18 of the instruction 3 written in the work memory 6 is stored in the trace file 14 in chronological order along with the execution number 17, the step number 2, and the instruction 3. Will be kept in memory.

After the first debug processing operation for the created program 1 is completed, if an abnormal point is found in the debug execution result, a debug re-execution instruction is input with the step number 2 specified. The instruction 3 of the step number 2 is immediately executed using the execution result of the instruction 3 immediately before.

Therefore, debugging of the instruction 3 at an arbitrary position in the debugged program 1 can be re-executed. After the first debugging process for the created program 1 is completed, an abnormal point is found in the debugging execution result. In this case, the efficiency of the work for investigating the cause of the abnormality can be improved.

Note that the present invention is not limited to the above embodiment. In the embodiment device, the instruction 3 to be debugged again is designated by the step number. However, since the instruction 3 corresponds to the step number 2, the instruction 3 can be directly specified.

The apparatus described in the above embodiment can be realized by causing a computer to read a program stored in a recording medium.

Here, as the recording medium in the present invention,
Magnetic disk, floppy (registered trademark) disk, hard disk, optical disk (CD-ROM, CD-R, D
VD or the like, a magneto-optical disk (MO or the like), a semiconductor memory, or the like, as long as it is a recording medium that can record a program and that can be read by a computer.

An OS (Operating System) running on the computer based on the instructions of the program installed in the computer from the recording medium,
MW for database management software, network software, etc.
(Middleware) or the like may execute a part of each process for realizing the present embodiment.

Further, the recording medium in the present invention is not limited to a medium independent of a computer, but also includes a recording medium in which a program transmitted via a LAN, the Internet or the like is downloaded and recorded or temporarily recorded.

Further, the number of recording media is not limited to one, and the case where the processing in the present embodiment is executed from a plurality of media is also included in the recording medium of the present invention, and the medium may have any configuration.

The computer according to the present invention executes each process in the present embodiment based on a program recorded on a recording medium.
Any configuration such as a single device, a system in which a plurality of devices are connected to a network, or the like may be used.

The computer in the present invention is
It is not limited to a personal computer, but also includes a processing device, a microcomputer, and the like included in an information processing device, and generically refers to a device and a device capable of implementing the functions of the present invention by a program.

[0059]

As described above, in the program debugging apparatus and the recording medium on which the program is recorded according to the present invention, the execution result of the instruction of each step is traced in the first debugging operation of the created program. Stored in a file.

As a result, the execution result of the immediately preceding instruction is known, so that the instruction at an arbitrary position in the debug-executed program can be executed independently, and the debugging work efficiency in the program can be greatly improved.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a schematic configuration of a program debugging device according to an embodiment of the present invention;

FIG. 2 is a view showing storage contents of a trace file formed in the program debugging device;

FIG. 3 is a flowchart showing a first debug processing operation for a program performed by the program debug device.

FIG. 4 is a flowchart showing a debug re-execution processing operation for a program performed by the program debug device.

FIG. 5 is a block diagram showing a schematic configuration of a conventional program debug device.

[Description of Signs] 1 ... Program 2 ... Step number 3 ... Instruction 4 ... Program counter 5 ... Program execution unit 6 ... Work memory y ... Input / output I / F 8 ... External memory 9 ... Operation unit 10 ... Display unit 11 ... Data Acquisition unit 12 Execution buffer 13 Execution result writing unit 14 Trace file 15 Return position designation unit 16 Execution result extraction unit 17 Execution number 18 Execution result

Claims (3)

[Claims] An instruction of each step constituting a created program is executed using an execution result of an instruction executed in a previous step temporarily stored in a work memory,
A program debugging device that overwrites the previous execution result with the previous execution result of the work memory and outputs the execution result as needed. Means for storing and storing the execution result of the corresponding instruction written in the trace file together with the step number in the trace file; and responding to the debug re-execution command specifying the step number, Means for extracting the execution result of the step number of the instruction executed immediately before and writing the result in the work memory; and after the execution result is written in the work memory by this means, the specified step number And a means for executing the instruction. 2. An instruction of each step constituting the created program is executed using an execution result of the instruction executed in the immediately preceding step temporarily stored in the work memory,
A program debugging device that overwrites the previous execution result with the previous execution result of the work memory and outputs the execution result as needed. Means for storing and storing in a trace file the execution result of the corresponding instruction written in the program together with the step number and the corresponding instruction; and responding to a debug re-execution instruction specifying one instruction included in the program, and Means for extracting the execution result of the instruction executed immediately before the corresponding instruction stored in the file and writing the result in the work memory; and after the execution result is written in the work memory by the means, Means for executing a specified instruction. 3. An instruction of each step constituting the created program is executed using an execution result of the instruction executed in the immediately preceding step temporarily stored in the work memory,
The execution result is overwritten on the previous execution result in the work memory, and is incorporated in a program debugging device that outputs the execution result as necessary. The instructions of the respective steps are executed on a computer. Each time the execution result of the corresponding instruction written in the work memory is stored in the trace file together with the step number, and in response to the debug re-execution command specifying the step number, the corresponding result stored in the trace file is stored. The execution result of the step number of the instruction executed immediately before the step number is extracted and written in the work memory. After the execution result is written in the work memory, the instruction of the specified step number is written. Recording medium on which a program for executing the program is recorded.