JP2653411B2 - How to set breakpoints - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for setting a breakpoint for stopping execution of an instruction in a program debugging support tool such as a so-called debugger.

[0002]

2. Description of the Related Art Conventionally, many debug support systems have a breakpoint function for instruction execution. In program debugging, the breakpoint function of instruction execution is effective and is incorporated in many debug support systems. This function stops execution at a designated instruction in a program to be debugged. Such a function is useful in debugging a program. When using this function, the user specifies an instruction whose execution is to be stopped in advance, and then executes the program to be debugged. Thus, the execution of the debug target program stops at the designated instruction. At that time, the operator can check or change the values of the registers and memories at the time of the stop, if necessary. After that, the program can be resumed from the point at which it was stopped (for example, "Information Science Dictionary," Iwanami Shoten, First Edition, 1990, p.65
5 See “Breakpoints”). There are the following methods (1) to (3) for realizing the breakpoint function.

(1) Replace a specified instruction with a trap instruction. That is, when a trap instruction is detected, a trap is generated, control is passed to the debug support program via the trap processing routine, and the user is notified of the fact. When execution restart is instructed, the execution of the replaced original instruction is simulated, and then control is returned to the original (for example, Iizuka, Tanaka "Software Oriented Architecture")
Ohmsha, 1st Edition, 1985, p.212, "Indexing for Instruction Execution"). This method has a feature that a plurality of breakpoints can be set.

(2) A breakpoint register is provided in hardware. Breakpoint register (BPR)
Is a register that holds the address of the instruction whose execution is to be stopped. When the instruction specified by this register is detected, a trap is generated, control is passed to the debug support program via the trap processing routine, and the user is notified of the fact. When execution resume is instructed, the control is returned (for example, see “32-bit microprocessor”, Nikkei McGraw-Hill, p. 178). This method
It has the following features (a) and (b). (a) There is no need to change the program to be debugged. (b) There is no need to simulate instruction execution.

(3) A flag for controlling a breakpoint is prepared for each instruction. When an instruction in which this flag is set is detected, a trap is generated, control is passed to the debug support program via the trap processing, and the user is notified of that. When the execution is instructed to resume, the control is returned (for example, “MC68020 User's Manual 2nd Edition”, Motorola Inc., 1989, CQ Publication p.
80). This method has the following features (a) and (b). (a) Multiple breakpoints can be set. (b) There is no need to simulate instruction execution.

[0006]

However, the above-mentioned conventional techniques (1) to (3) have the following problems. That is, (1) has the following problems (a) and (b). (a) The original program needs to be rewritten to set breakpoints. Therefore, when the program is written in a read-only memory or the like and the program cannot be rewritten, a breakpoint cannot be set. (b) To resume the execution of the program from the breakpoint, it is necessary to simulate the execution of the rewritten original instruction. Therefore, there are the following problems (A) and (B).

(A) In the case of an instruction using the program counter relative addressing mode or the like, since the value of the program counter is different from the execution state of the original program, many instructions are required to correctly simulate. (B) If the state of the processor such as the privileged mode is different from the execution state of the original program, it cannot be detected in the original program state even if execution of the instruction is not permitted.

[0008] In addition, (2) has the following problem.
Since the number of breakpoint registers that can be prepared by hardware is limited, it is not possible to set more breakpoints. For example, when the number of breakpoint registers is four, only four breakpoints can be monitored at the same time. And (3) had the following problems (a) and (b). (a) It is necessary to rewrite the flag of the instruction in the original program to set a breakpoint. Therefore, (1)
As in (a), when the program is written in a read-only memory or the like and the program cannot be rewritten, a breakpoint cannot be set. (b) It cannot be applied to processors other than special processors having a flag for controlling a breakpoint in an instruction.

The present invention has been made in view of the above points, and solves the problems of the conventional methods (1) to (3) and has the following features (A) to (D). It is an object of the present invention to provide a breakpoint setting method in which a debug support system can realize a breakpoint of instruction execution while keeping the same. (A) Any number of breakpoints can be set. (B) There is no need to rewrite the debug target program. (C) There is no need to simulate instruction execution. (D) There is no need to provide a special mechanism in the instruction itself.

[0010]

According to the present invention, there is provided a method for setting a breakpoint, comprising preparing a plurality of breakpoints in a program comprising a plurality of instructions for stopping execution of the program at each designated instruction. One register arbitrarily selected from a plurality of registers holding any of the addresses of the breakpoints, and a breakpoint for requesting an interrupt in response to execution of an instruction at an address held in the register In addition to providing a detection mechanism, if a branch instruction that branches to another discontinuous address appears during the sequential execution of instructions existing at consecutive addresses in the program, an interrupt occurs after the execution of the branch instruction. A branch trace mechanism that requests the execution of the program is provided for debugging the program. In this case, when the address of the break point that is equal to or more than the execution start address and is closest to the execution start address is set in the register, and after the program is stopped at the break point, execution of the program is resumed. Sets an address of a breakpoint that is greater than the execution resuming address and is closest to the execution resuming address in the register. If a branch is detected by the branch tracing mechanism during the execution of the program, By setting the address of a breakpoint that is equal to or greater than the destination address and closest to the branch destination address in the register, it is possible to sequentially set instructions to be executed in the register during the execution of the program. It is a feature.

[0011]

In the breakpoint setting method of the present invention, first, the breakpoint setting routine predicts a breakpoint to be detected next at a specific timing of program execution among a plurality of designated breakpoints. , And set the address in the breakpoint register. That is, a breakpoint that will appear next is predicted according to the execution of the program, and its address is replaced with a breakpoint register. This gives 1
Support multiple breakpoints with one breakpoint register. Here, the timing of predicting the breakpoint and setting the breakpoint register is as follows.
This is performed immediately before the execution of the debug target program starts, when a breakpoint is detected, and when a branch is made. The branch is detected by a branch trace mechanism.

The prediction of a breakpoint is performed by utilizing the following properties. That is, unless a branch occurs, the address of the instruction to be executed increases sequentially. Therefore, the address of the next breakpoint has the smallest address among the breakpoint addresses larger than the current instruction execution address. This prediction is applied immediately before the start of program execution and when a breakpoint is detected. When a branch occurs, the one having the smallest breakpoint address among the breakpoint addresses higher than the instruction address of the branch destination is predicted as the next breakpoint.

[0013]

Embodiments of the present invention will be described below in detail with reference to the drawings. FIG. 1 is a block diagram of an embodiment of an apparatus to which the method of the present invention is applied. An apparatus for implementing the method of the present invention includes a breakpoint register 1, a breakpoint detection mechanism 2, a branch tracing mechanism 3, and a breakpoint setting routine B. One breakpoint register 1 is provided. The breakpoint register 1 is one register arbitrarily selected from a plurality of registers, and there may be any two or more candidate registers as long as hardware resources permit. The breakpoint detection mechanism 2 requests an interrupt when the instruction specified by the breakpoint register 1 is detected or executed. The branch trace mechanism 3 is a mechanism that requests an interrupt when a branch occurs. The breakpoint setting routine B is a routine for setting a breakpoint address in the breakpoint register 1.

In FIG. 1, an interrupt processing routine T debugs a target program P by a debug support program D. The target program P is a program to be debugged, and includes breakpoints BP1 and BP1.
It has P2 and BP3. Breakpoint BP1, BP
2, BP3 indicates an address at which debugging is stopped halfway. These addresses are stored in a predetermined storage area.

On the other hand, the debug support program D is a set of various routines for debugging. This includes a breakpoint setting routine. The breakpoint setting routine B is a routine for setting breakpoints BP1, BP2, and BP3 on the target program P. This breakpoint setting routine includes a subroutine executed in the debug support program D.

The above-mentioned break points BP1, BP
2, BP3 is specified by a user who is debugging the target program P using the debug support program D. All specified breakpoints BP1, BP
2. It is assumed that the address of BP3 is stored in a storage area used by the debug support program D. For example, it is assumed that three breakpoints BP1, BP2, and BP3 are set, and the addresses increase in this order. Next, the operation of the above-described device will be described.
First, the user inputs breakpoints BP1, BP2, B
After setting P3, the debug support program D is instructed to execute the target program P. Then, the interrupt and branch trace function by the breakpoint set in the breakpoint register 1 is enabled, and the control is transferred from the debug support program D to the target program P via the interrupt processing routine T.

When the breakpoint BP1, BP2 or BP3 specified by the breakpoint register 1 is detected, the control is passed to the debug support program D via the interrupt processing routine T. When the user instructs the debug support program D to resume execution of the target program P, the breakpoint setting routine B is executed, and then the target program P is passed through the interrupt processing routine T.
Is passed to. When a branch is detected by the branch tracing mechanism 3, control is passed to the breakpoint setting routine B via the interrupt processing routine T, and after execution, the target program P is transmitted via the interrupt processing routine T.
Is returned to

Here, when a breakpoint specified by the breakpoint register 1 is detected, control is transferred to the interrupt processing routine T before executing the instruction. Therefore, execution is resumed from the instruction at the breakpoint. When a branch is detected by the branch tracing mechanism 3, control is transferred to the interrupt processing routine T after the execution of the instruction that caused the branch is completed. Therefore, execution is restarted from the instruction at the branch destination. If the instruction specified by breakpoint register 1 causes a branch, the breakpoint has priority. The execution resume address when returning from the interrupt processing routine T is stored in a special register or stack.
It can be known from the debug support program D. Next, a processing procedure in the breakpoint setting routine will be described.

FIG. 2 is a flowchart for explaining a processing procedure when the execution of the target program P is resumed. First, the number of breakpoints is checked (step S1,
S2). If the number of breakpoints is neither "0" nor "1", the interrupt and branch trace function by the breakpoint register is activated when program execution is started ([1]-(1)). It is made valid (step S3, [1]-(1)). Next, a breakpoint that is equal to or more than the execution start address and is closest to the execution start address is searched for in the breakpoint register (step S).
4). In the case of FIG. 1, this is the breakpoint BP1
It is. Therefore, the address of the breakpoint BP1 is set in the breakpoint register (step S1).
5, [2]-(1), (2)).

On the other hand, when a breakpoint is not specified, the interruption by the breakpoint register and the branch trace function are disabled (step S8). If only one breakpoint is specified, only the interrupt by the breakpoint register is enabled, and the branch trace is disabled (step S6). Then, the break point is set in the break point register (step S
7).

FIG. 3 is a flowchart for explaining a processing procedure when the execution suspended at the breakpoint is resumed. First, an execution restart address is obtained (step S1).
1, [2]-(3), (4), (5)). Next, a breakpoint larger than the execution resuming address and closest to the address is searched (step S12). Next, it is checked whether there is a corresponding breakpoint (step S13). Then, the address of the break point is set in the break point register (step S14). For example, when resuming execution from the breakpoint BP1, a breakpoint BP2 is set. If the corresponding breakpoint is not found, the breakpoint register is not changed.

FIG. 4 is a flowchart for explaining a processing procedure when a branch is detected. First, an execution resuming address is obtained (step S21, [2]-(3), (4), (5)). In this case, since the execution resuming address is the branch destination address, a breakpoint that is equal to or larger than the execution resuming address and closest to the execution resuming address is searched (step S22, [3]-(1), (2) ), (3), (4)). Next, it is checked whether there is a corresponding breakpoint (step S2).
3). Then, the address of the break point is set in the break point register (step S24).
For example, as shown in FIG. 1, a branch instruction is executed between breakpoints BP1 and BP2, and breakpoint B is executed.
Assuming that the process branches to an address L located between P2 and BP3, a breakpoint BP3 is set at this time. On the other hand, if the corresponding breakpoint is not found, the breakpoint register is not changed.

[0023]

As described above, according to the breakpoint setting method of the present invention, a plurality of breakpoint addresses are sequentially set in one register arbitrarily selected from a plurality of registers. Therefore, the following effects are obtained. (A) Since it is not necessary to rewrite the program to be debugged, a breakpoint can be set for a program on a read-only memory. (B) Since it is not necessary to simulate the instruction at the breakpoint, a routine and a data area for simulating the instruction can be eliminated. (C) Any number of breakpoints can be set. (D) The execution state of the program can be made the same as in the normal operation. Therefore, there is no need to provide a mechanism such as a special flag in the instruction itself.

[Brief description of the drawings]

FIG. 1 is an explanatory diagram of an embodiment of a breakpoint setting method according to the present invention.

FIG. 2 is a flowchart illustrating a processing procedure when starting execution of a target program P;

FIG. 3 is a flowchart illustrating a processing procedure when resuming suspended execution.

FIG. 4 is a flowchart illustrating a processing procedure when resuming suspended execution.

[Explanation of symbols]

 1 Breakpoint register 2 Breakpoint detection mechanism 3 Branch tracing mechanism P Target program T Interrupt handling routine D Debugging support program BP1, BP2, BP3 Breakpoint

 ──────────────────────────────────────────────────続 き Continuation of the front page (72) Inventor Osamu Yamashita 1-7-12 Toranomon, Minato-ku, Tokyo Oki Electric Industry Co., Ltd. (56) References JP-A 1-211129 (JP, A)

Claims (1)

(57) [Claims] In a program including a plurality of instructions, a plurality of breakpoints for stopping execution of the program at each designated instruction are prepared, and one of the addresses of the breakpoint is held.
One register arbitrarily selected from a plurality of registers and a breakpoint detection mechanism for requesting an interrupt in response to execution of an instruction at an address held in the register are provided. When a branch instruction that branches to another discontinuous address appears during the sequential execution of instructions existing at consecutive addresses, a branch trace mechanism that requests an interrupt after execution of the branch instruction is provided, and the program When the execution of the program is started for debugging, the address of the breakpoint that is equal to or higher than the execution start address and closest to the execution start address is set in the register, and the program is stopped at the breakpoint. Later, when the execution of the program is resumed, it is larger than the execution resume address and Setting the address of the breakpoint closest to the execution resuming address in the register, and if a branch is detected by the branch tracing mechanism during the execution of the program, the address is equal to or higher than the branch destination address and by setting the address of the nearest break point before address in the register, in the course of execution of the program, then the breakpoint
Instruction addresses that may be detected
Breakpoint setting characterized by setting
Method