JPH1049401A - Method for debugging program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a debugging method with which a register, memory and I/O can be referred to or changed by a break point while providing the function of an on-line debugger. SOLUTION: While utilizing a microcomputer having a debugging function based on the break point, a vector to be used is changed to the processing routine of the on-line debugger by the interruption of the break point and at the point when a program executes the set break point and the break point interruption is generated at the on-line debugger, the contents in all the registers, designated memory and designated I/O are saved (S5-S7). Then, data to be designated for the designated memory and the designated I/O are written (S8 and S9), the break point function is canceled (S10), the vector of the break point is returned to the vector of an off-line debugger (S11), the saved contents are damped (S12), and the execution of the program is restarted from the original instruction (S13, IRET).

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a debugging method for finding and correcting an error in a program in software development of a microcomputer.

[0002]

2. Description of the Related Art In software development of microcomputers, there is a software debugging tool called an in-circuit emulator (ICE). This ICE
Simulates the operation of a computer's processor and memory, interrupting programs, setting breakpoints,
It has functions such as single-step execution, and supports software development.

There is also a debugging tool that enables software testing on a personal computer when there is no target computer.

[0004] After a target exists and a created program is loaded on the target, software called a debugger is used to test software without using ICE.

This debugger is sometimes provided by a microcomputer manufacturer or an OS (operating system) manufacturer.
If you do not use or use a dedicated OS,
You will have to create your own debugger.

[0006] The functions of the debugger are mainly as follows.

(1) Program start / interruption / continuation start by a break point.

(2) Reference and change of register, memory, and I / O space.

Of these functions, the function (1) is used in a test of a program alone, and the function (2) is a function mainly used in a unit test and subsequent development processes.

[0010]

ICE can be used in the entire development process of embedded software.
It is expensive, and requires a probe and a cable for connecting the target and the ICE body when used. Therefore, when the target is tested in the operation state, the ICE may not be used.

When a software test is performed on a personal computer, it is only a unit test, and cannot be used in an online test on a target.

There are several types of debuggers. One type is usually a unit test called an offline debugger, and the other is a type used after a connection test called an online debugger.

The off-line debugger sets a program interruption function called a break point in a program, and when the program executes a break point, the debugger is started (usually by an interrupt), and at that time, registers, memories, I / Os and the like are set. Reference / change. Further, the program suspended at the breakpoint can be continuously activated. Therefore, since the debugger operates by the break point, it cannot be used in the online state.

A normal online debugger has no function of interrupting / continuously starting a program by a breakpoint.
The memory and I / O at the time of key input can be referenced / changed, but the online register cannot be referenced / changed.

That is, the value of the register changes every moment in the program, and it does not make any sense to refer to the contents of the register at the time of key input.

However, when a certain point in the program is executed, such as a break point, the register, memory, I
It is effective if there is a function for referring to / O.

An object of the present invention is to provide a debugging method capable of referring to or changing a register, a memory, and an I / O by a breakpoint while having a function of an online debugger.

[0018]

SUMMARY OF THE INVENTION According to the present invention, in debugging a program using a microcomputer having a debugging function by a breakpoint, a vector used for interrupting the breakpoint is changed to a processing routine of an online debugger and designated. A breakpoint is set at the specified program address, and the contents of all the registers, the specified memory and the specified I / O at the time when the breakpoint interrupt occurs in the online debugger by executing the program at the set breakpoint are saved and specified. Write the specified data to the memory and the specified I / O, release the breakpoint function, return the breakpoint vector to the vector of the offline debugger, dump the saved contents, and resume the execution of the program from the original instruction. Characterized by

Further, the writing of the data specified in the specified memory and the specified I / O can be changed a plurality of times.

[0020]

BEST MODE FOR CARRYING OUT THE INVENTION

(First Embodiment) FIG. 1 shows a process of setting an online breakpoint of a debugger. Usually, a microcomputer is provided with a breakpoint instruction.
Further, some microcomputers having a debug function are provided with a breakpoint function of a hardware configuration.

When a breakpoint is executed by these functions, a breakpoint interrupt is generated and control is transferred to the debugger. However, these functions are usually off-line debuggers, and the operation causes the microcomputer to go off-line.

Therefore, in FIG. 1, the vector (table indicating the interrupt routine) used for the offline breakpoint interrupt is saved (S1), and this vector is set in the interrupt routine of the online debugger (S2).

That is, the vector which is normally suitable for the breakpoint processing routine of the offline debugger is changed to the breakpoint processing routine of the online debugger when the breakpoint operation of the online debugger is performed. The value stored before the change is saved in another memory.

Following the above-described vector set, a function is provided for designating a memory address and an I / O port address to be referred to when an online breakpoint interrupt occurs. Further, a function for designating a value for changing the designated memory and I / O is prepared.

Next, as shown in FIG. 2, a breakpoint is set at a program address specified by the user.
In the case of the breakpoint instruction, the old instruction originally stored is saved (S2), and then the breakpoint instruction is stored (S3).

After performing these functions and processing, an interrupt processing for an online break point is performed. In this processing, when the program executes the breakpoint according to the set breakpoint (see FIG. 1), the processing shown in FIG. 3 is performed when a breakpoint interrupt occurs in the online debugger.

In FIG. 3, the contents of all registers at the time of occurrence of a breakpoint interrupt are saved (S5), the contents of a specified memory are saved (S6), and the contents of a specified I / O are saved (S7). Further, the designated data is written to the designated memory (S8), and the designated data is written to the designated I / O (S9).

Next, the break point function is released (S10). This release returns to the original instruction if the breakpoint interrupt is caused by a breakpoint instruction.

Next, the vector of the break point is returned to the vector of the offline debugger (S11), and the saved register value, memory value, and I / O value are dumped (S1).
2) The interrupt address is decremented by 1 (S13), and the program execution from the original instruction is resumed (IRET).

(Second Embodiment) In the above embodiment,
When the online breakpoint is executed only once, the processing is terminated, but the online breakpoint processing can be continued until specified by the user.

That is, this is realized by leaving the breakpoint function without performing the processes S10 and S11 in FIG. To release the breakpoint function, the processes S10 and S11 are executed according to the user's specification. With this method, it is possible to continuously refer to the register, the memory, and the I / O at a certain point in the program.

In this embodiment, by continuously changing the data and I / O, the data can be forcibly changed to the specified value without modifying the program. this is,
Since the data can be changed without modifying the program, the following applications are possible.

(1) Instruction invalidation: Since the processing result executed before the point designated by the break point is stored in the memory, the result is set to another value, and the instruction before the break point is set. Can be disabled. For example, it can be determined that the operation of the subroutine has not been performed.

(2) Change of input data: By changing the changed data in various ways, it is possible to perform a dynamic test by changing the data even if the data is not actually input.

(3) Effect of Patch Program The program is corrected when there is a bug in the program. If the program is in the ROM or if it takes time to correct the program, a patch program may be created. The patch program is for canceling the bug portion and executing the original program. Therefore, since data can be forcibly changed, setting a breakpoint after a bug has the same effect as in a patch program.

[0036]

As described above, according to the present invention, the vector used in the breakpoint interrupt of the microcomputer is changed to the processing routine of the online debugger.
The online debugger saves the contents of all registers, specified memory, and specified I / O when a breakpoint interrupt occurs, and writes the specified data to the specified memory and specified I / O. Register, memory, I / O at point specified address
And the memory and I / O can be changed.

Further, by using the breakpoint vector as the breakpoint processing routine of the online debugger and returning to the breakpoint processing routine of the offline debugger when the use of the breakpoint is completed, the online debugger and the offline debugger can coexist.

Further, according to the present invention, the writing of the data specified in the specified memory and the specified I / O can be changed a plurality of times, so that the following effects are obtained.

(1) It is possible to refer to a register, a memory, and an I / O of a specified breakpoint in an online state for a long time.

(2) By invalidating the operation result at the break point, the processing performed until the break point occurs can be invalidated.

(3) Even without an actual input, a test can be performed by changing data as if there was an input.

(4) Since the data can be forcibly changed, a test equivalent to the creation of a patch program can be performed.

[Brief description of the drawings]

FIG. 1 is a processing procedure for setting a breakpoint in an embodiment of the present invention.

FIG. 2 is a set processing procedure of an online break point in the embodiment.

FIG. 3 is an online breakpoint interrupt processing procedure according to the embodiment;

Claims (2)

[Claims] When debugging a program using a microcomputer having a debugging function using a breakpoint, a vector used for interrupting the breakpoint is changed to a processing routine of an online debugger, and a breakpoint is set at a specified program address. Then, the program executes the set breakpoint, saves the contents of all the registers, the specified memory, and the specified I / O at the time when the breakpoint interrupt occurs in the online debugger, and specifies the specified memory and the specified I / O. Writing the data to be executed, releasing the breakpoint function, returning the vector of the breakpoint to the vector of the offline debugger, dumping the saved contents, and resuming the execution of the program from the original instruction. 2. The debugging method according to claim 1, wherein writing of data specified in the specified memory and the specified I / O can be changed a plurality of times.