JP2010287120A - Debugging device, debugging method, and debugging support program - Google Patents

Abstract

[PROBLEMS] To investigate whether or not a program passes on a specific route in an environment close to the actual environment while avoiding disadvantages when the program is actually executed.
[Solution]
When the start point (P _S ) is reached during the execution of the program, the execution of the program is temporarily stopped and virtual execution is started. In virtual execution, a value is not directly written to the memory register of the target device. In the virtual execution, when the prediction point (P _P ) is reached (S104: false, S106), the execution is stopped and a dialog indicating that the prediction point (P _P ) has been reached is displayed. When the predicted point (P _P ) is not reached (S104: true, S105), the program execution is resumed from the start point (P _S ) once stopped.
[Selection] Figure 7

Description

  The present invention relates to a debugging device that supports a debugging operation that searches for an error in a program and solves the error, and particularly relates to a program execution stop (break).

Conventionally, in debugging work, a breakpoint is set for forcibly stopping a running program.
Breakpoint setting conditions include, for example, (1) program execution has reached a specific position, (2) execution has reached a specific function, and (3) execution has reached a specific memory address. (See Non-Patent Document 1).

By stopping at a breakpoint, the user can check the operating state of the program, such as the value of the variable when stopped.
However, depending on the type of error in the program, there is an error (an error that is not reproducible) that makes it difficult to completely reproduce an event that has occurred once.
In this regard, in Patent Document 1, data stored in a write area is saved immediately before a write instruction to a register or memory, and when execution of a program is stopped due to a bug, the saved data is used. The reproducibility can be improved by tracing one step at a time in the reverse direction from the stopped position.

Japanese Patent Laid-Open No. 9-6647

"Breakpoints", Visual Studio Developer Center, Microsoft Corporation, [accessed May 28, 2009], Internet <URL: http://msdn.microsoft.com/en-us/library/aa291561(VS.71 ) .aspx>

  By the way, in the case of a program having a branch, when a breakpoint is set on a specific route at a branch destination and the program is stopped at this breakpoint, the program flows toward this breakpoint according to the branch condition. It is necessary to adjust the value. Adjustment of such values is troublesome, and the adjusted program tends to be different from the original behavior and has a problem that it is not useful.

  Also, if a breakpoint is set on the path that passes when an exceptional event occurs, the system may malfunction due to the effect of this exceptional event, and recovery (especially a program with hard control) In some cases, it may take time and cost. For this reason, there is a demand for avoiding a situation where breakpoints are encountered simply by running the program.

  The present invention has been made under such a background, and it is possible to examine whether a program passes on a specific path in an environment close to the actual environment while avoiding a disadvantage when the program is executed. An object of the present invention is to provide a debugging device that can be used.

  A debugging device according to the present invention is a debugging device for debugging a program to be executed on a target device, wherein a first point indicating a position on the program and a position on the program different from the first point are set. A setting means for setting a second point to be indicated; an execution means for executing the program while writing a value in a first storage unit provided in the target device; and a position of the program being executed by the execution means is When the first point is reached, the copying means for copying the value stored in the first storage section at that time and storing the copied storage contents in the second storage section; and the execution means, after copying, While writing a value to the second storage unit with the first point as a starting position, the program is executed without writing a value to the first storage unit. Is characterized in that the position of the program where the execution unit is performed after the copying and a determination means whether or reaches the second point.

  According to the debugging device of the present invention, after reaching the first point, it is possible to determine whether or not the second point is reached by executing the program without writing a value in the first storage unit. Moreover, since the execution of the program after reaching the first point is an execution in which a value is not written in the first storage unit included in the target device, it is possible to avoid disadvantages when the program is actually executed.

The execution unit may stop the execution of the program when the determination unit determines that the second point has been reached.
According to this configuration, the execution of the program is stopped when the second point is reached. For example, it is possible to analyze a factor that reaches the second point after the stop.
Further, an output unit that outputs a value written in the second storage unit when the execution unit stops executing the program may be provided.

According to this configuration, for example, it is possible to provide useful information to the user who performs debugging by displaying and outputting the value written in the second storage unit.
Further, the setting means sets the state of the program when the second point is reached, the determination means determines the state of the program when the second point is reached, and the execution means When it is determined by the determination means that the second point has been reached and it is determined that the set program state matches the determined program state, the execution of the program is stopped, and the determination means If it is not determined that the second point has been reached, or if it is determined that the set program state does not match the determined program state, the execution of the program may not be stopped.

According to this configuration, for example, if a conditional expression of a value in the data is set as the program state, execution of the program is stopped when the conditional expression is satisfied, and is not stopped when the conditional expression is not satisfied. Detailed settings are possible, and it is possible to control whether or not to stop the program according to user needs.
When it is determined that the second point has not been reached, the execution means terminates the execution of the program after the copying, and sets the value in the first storage unit with the first point as a start position. You may resume the execution of the program while writing.

According to this configuration, for example, when there is a situation where it is desired to avoid reaching the second point, execution of the program can be resumed from the first point under the guarantee of not reaching the second point, Contributes to efficient debugging work.
The debugging method according to the present invention is a debugging method executed in a debugging device for debugging a program to be executed on a target device, wherein the first point indicating a position on the program, and the first point A setting step for setting a second point indicating a position on a different program, a first execution step for executing the program while writing a value in a first storage unit included in the target device, and the first When the position of the program being executed in the execution step reaches the first point, a copy step of copying the value stored in the first storage unit to the second storage unit at that time, and after copying, the first While writing a value to the second storage unit using the point as a starting position, no value is written to the first storage unit, A second execution step of executing the ram, the position of the running program in the second execution step is characterized in that it comprises a determining step whether reaches the second point.

  The debugging support program according to the present invention is a debugging support program for causing a debugging device to execute debugging processing of another program to be executed on a target device, and the debugging processing is performed at a position on the other program. A setting step for setting a first point to be displayed and a second point indicating a position on the other program different from the first point, and the other program to be stored in the first storage unit included in the target device When the position of the other program being executed in the first execution step reaches the first point, it is stored in the first storage unit at that time. A copying step of copying the value to the second storage unit, and after copying, writing the value to the second storage unit with the first point as the start position The second execution step for executing the other program without writing a value in the first storage unit while the position of the program being executed in the second execution step is set to the second point. And a determination step for determining whether or not it is reached.

  The debug device according to the present invention is a debug device for debugging a program to be executed on a target device, and shows a first point indicating the execution position of the program and an execution position different from the first point. A setting means for setting a second point; an execution means for executing the program; and when the execution position of the program by the execution means reaches the first point, the execution is stopped when the second point is further reached. And an execution control means for stopping the execution if the second point is not reached after reaching the first point.

  According to this configuration, for example, when the program has a branch and the second point is on a specific path of the branch destination, the aim is to follow the execution path from the first point to the second point. You can stop the program.

Functional block diagram showing the configuration of the debug system 1 The figure which shows the source code 21 of the source program 20 A flowchart showing a flow of processing in the debugger 10 The figure which shows the window 40 of a point detailed setting menu A flowchart showing a flow of processing related to virtual execution in the debugger 10 The figure which shows the window 80 A flowchart showing the execution path and flow of the source program 20

(Embodiment)
This embodiment will be described with reference to the drawings.
<Configuration>
FIG. 1 is a functional block diagram showing the configuration of the debug system 1.
The debug system 1 includes a debugger 10 and a target device 100 to be debugged by the debugger 10.

The debugger 10 includes a control unit 12, an input receiving unit 14, a setting unit 16, a display control unit 18, a source program 20, an execution unit 22, an execution position determination unit 24, a state determination unit 26, a virtual execution unit 28, and an I / F unit. 30, a setting storage unit 36, and a storage unit 38.
The control unit 12 includes, for example, a CPU, a RAM, and a ROM, and controls each block according to a control program stored in the ROM.

The input receiving unit 14 receives input from the user 2 via the keyboard 14a and the mouse 14b.
The setting unit 16 displays (1) the start point P _S , (2) the predicted point P _P , and (3) a point detailed setting menu (FIG. 4) for accepting the setting of the program state on the display 18 a via the display control unit 18. Display. The setting unit 16 stores the setting content received by the input receiving unit 14 in the setting storage unit 36.

The display control unit 18 causes the display 18a to perform various displays.
The execution unit 22 executes the source program 20. During execution, values are read from and written to the memory 104 and the register 106 of the target device 100.
The virtual execution unit 28 executes the source program 20. Unlike the execution unit 22, values are read and written in the storage unit 38 (information in the memory 104 and the register 106 is copied to the storage unit 38 in advance before execution) during execution.

Executing position determination unit 24 monitors the program counter indicating the position of the program being executed by the execution unit 22 or the virtual execution unit 28 (PC), or the program counter reaches the starting point P _S or prediction point P _P Determine if.
The state determination unit 26 monitors the storage unit 38 while the virtual execution unit 28 executes the program, and determines whether the state of the storage unit 38 matches the state of the program set in the setting storage unit 36. .

The I / F unit 30 is an interface for exchanging data, and exchanges various data with the I / F unit 108 of the target device 100.
The setting storage unit 36 includes, for example, an HDD (Hard Disk Drive), and stores (1) a start point Ps, (2) a predicted point P _P , and (3) a program state as setting contents.

The storage unit 38 includes, for example, a RAM, and stores memory information copied from the memory 104 and the register 106 of the target device 100 (including the address of the memory 104 and a value corresponding to the address) and register information.
The target device 100 includes an MPU (Micro Processing Unit) 102, a memory 104, a register 106, and an I / F unit 108 that serves as an interface.

Specific examples of the target device 100 include a circuit board mounted on an embedded system (for example, a mobile phone, a television, a digital television, etc.).
FIG. 2 is a diagram showing the source code 21 of the source program 20.
This source code 21 is written in C language, declares a function with a, b, and c as arguments (line 101), and outputs a value a if a = 3 (lines 103-105). Line).

If b = 4, the value b is output. If b = 4 is not satisfied (if b ≠ 4), the value c is output (lines 107 to 112).
Thus, the source code 21 includes an if, if else statement that branches the program path (processing flow).
<Operation>
FIG. 3 is a flowchart showing the flow of processing in the debugger 10.

The setting unit 26 displays a point detail setting menu on the display 18a via the display control unit 18 (S11).
The setting unit 16 receives (1) the start point Ps, (2) the predicted point P _P , (3) the setting of the program state (S12), and stores the received content in the setting storage unit 36 (S13). .

FIG. 4 shows a point detail setting menu corresponding to steps S11 to S13.
Window 40 includes box 50 to set the starting point _{P S,} Box 60 to set the prediction point _{P P,} the box 70 to specify the state of the program.
Box 50 is a box for setting the starting point P _S, the box 52 of the event specified type, and a row type specified in box 54.

Box 52 has eight check boxes from event 1 to event 8. By the selection / non-selection of this check box, an event should be the starting point P _S can be set. Each event is previously defined in the source program 20.
Box 54 includes a text box 56. Setting unit 26 receives the row number to be set in the Numbers entered this text box 56 the starting point P _S. In the example of FIG. 4, the number "101" in the text box 56 is entered, setting unit 26 sets a line number of the start point P _S 101 line.

Box 60 is a box for setting a prediction point P _P, including a text box 62. Setting unit 26 sets the Numbers entered this text box 62 as the row number of the prediction point P _P. In the example of FIG. 4, line 111 is set as the prediction point P _P. Instead of designating the source code line, a mnemonic code line may be designated.

The box 70 includes a check box 71, a state list box 72, and a state addition / change box 73.
While the check box 71 is selected, the setting unit 26 keeps the boxes 74 and 76 settable. On the other hand, during the non-selection, the setting unit 26 displays the boxes 74 and 76 in a dimmed state so that they cannot be set. In this way, whether or not to specify the program state is arbitrary.

Each state in the box 72 of the state list includes “start address” and “end address” indicating memory addresses, and “data” indicating value specification.
The box 73 includes an add button 78 for accepting addition of a state list and a change button 79 for accepting a change. In the case of adding a state, when the setting unit 26 accepts pressing of the add button 78, the values input in the text boxes 77 to 79 of “start address”, “end address”, and “data” are changed to the new state. Are stored in the setting storage unit 36 and added to the state list in the box 72.

When the state is changed, the setting unit 26 sets each value of the selected state in the text boxes 77 to 79 in the box 73 when one of the state lists in the box 72 is selected. Are read and displayed, and after the value is changed, the change is accepted by pressing the change button 76.
Returning to FIG. 3, after the setting of the input content is completed, the execution unit 22 starts executing the source program 20 (S14). The start trigger is based on an instruction from the user 2, for example.

Then, after the start, when the execution position determination unit 24 determines that the program counter (PC) has reached the start point PS (S15: Yes), the control unit 12 once executes the source program 20 by the execution unit 22. Stop (S16). Then, the virtual execution unit 28 shifts to virtual execution (S17).
As shown in FIG. 5, in the virtual execution, the virtual execution unit 28 prepares by copying (1) the start point Ps, (2) the predicted point P _P , and (3) the program state from the setting storage unit 36. (S31).

Then, the control unit 12 copies (acquires) the memory information and the register information from the memory 104 and the register 108 of the target device 100 and stores them in the storage unit 38 (S32).
Subsequently, the control unit 12, the virtual execution unit 28, to start the virtual execution program 18 from the starting point _{P S} (S33).

After starting the virtual execution, the program counter (PC) it is determined to have reached the predicted point _{P P} by executing the position determining unit 24 (S34: Yes), determines the presence or absence of setting of the programmed state (S37).
If there is no setting (S37: No), the state determination unit 26 sets a condition satisfaction flag (S39).

  If there is a setting (S37: Yes), the state determination unit 26 determines whether the state of the set program is satisfied (S38). This determination is made based on whether the memory information or register information in the storage unit 38 matches the state of the program stored in the setting storage unit 36. Specifically, for example, if the state of No. 1 in FIG. 4 is set, a value in which the addresses from the start address “0x000000” to the end address “0x000FFF” are added in the memory information in the storage unit 38. If there is a value satisfying a = 1, it is determined that the set program state is satisfied.

If it is determined that the state set by the state determination unit 28 is satisfied (S38: Yes), a condition satisfaction flag is set (S39).
After the start of virtual execution (S33), if the PC is not determined to have reached the predicted point _{P P} (S34: No), the continues virtual run to satisfy the end requirements (S35).
As the termination requirement, for example, it is a requirement that the prediction point P _P escapes from the specified function (has reached the end of the function).

When the processing of the condition satisfaction flag (S36, S39) is completed, the control unit 12 ends the virtual execution by the virtual execution unit 28.
If the condition satisfaction flag is 1 (S18: 1), the control unit 12 interrupts (breaks) the execution of the program and stops the execution of the source program 20 by the execution unit 22 (S20). At the same time, the control unit 12 causes the display control unit 18 to display a window indicating the result display (S21).

FIG. 6 is a diagram showing an example of a result display window corresponding to step S21.
6A and 6B show the window 80 before and after the result display.
The source code from the 100th line to the 112th line is displayed in the window. Line 101 is the starting point P _S, 111 line of the prediction point P _P is a color different background color to another, so that it is clear both points at a glance.

The dialog 90, "because it reached a prediction point P _P, it suspends execution value:. A = 1, b = 2 " message is displayed. The user 2 who sees this message knows that the prediction point _PP has been reached. Further, the source code of the program can be corrected with reference to the displayed values a = 1 and b = 2.
Incidentally, both points _P S, 101 row corresponding to _{P P,} the left type 111 line, are denoted by _{P S} mark 81, _{P P} mark 82 respectively, mark the mouse cursor 88 81 (or mark 82), the setting of the row number to be the start point P _S (or the prediction point P _P ) can be changed by dragging in the row direction.

In step S18, if the condition flag is 0 (S18: 0), the control unit 12, the execution by the execution unit 22 which has stopped at the starting point _{P S} in the step S16, and resumes from the same starting point _{P S} (S19).
The effect of this embodiment will be described with reference to FIG. FIG. 7 is a flowchart showing the execution path and flow of the source program 20.

Steps S101 to S106 correspond to the 101st to 113th lines of the source code 21 (see FIG. 2).
As described above, according to this embodiment, the starting point _{P S} is set to 101 line (S101), after having set the prediction point _{P P} 111 line (S106), step S104 is false the execution of programmed only when it reaches the predicted point P _P can be stopped.

First, the execution up to the starting point P _S, since it is performed while writing a value to the memory 104 and register 106 of the target device 100 by the execution unit 22, it is possible to obtain the execution result under real environment .
Then, the execution of the starting point _{P S} up to the prediction point _{P P,} a virtual execution by the virtual execution unit 28, the target to write the value in the memory 104, register 106 of the target device 100 without the debugger 10 internal since a storage unit 38, it is possible to suppress the adverse effect on the peripheral devices of the target device 104 and the target device 104 caused when it reaches the predicted point P _P.

Further, "a == 1" (FIG. 4) that specifies the state of the program, such as a condition reached prediction point P _P, and if the state of the program in predicting the point P _P were consistent with those specified Only the program can be stopped. As a result, it is possible to reduce the time and effort required to construct a state of a specific program to be debugged by repeatedly executing the program.

Furthermore, when step S104 is true and the predicted point P _P is not reached (when passing through the point P _X ), the virtual execution by the virtual execution unit 28 is terminated, and the execution unit 22 resumes execution from the start point P _S. Above between the virtual execution by the virtual execution unit 28, the value of the time of the starting point P _S not the value in the memory 104 and the register 106 of the target device is written is secured, smoothly executed by the execution unit 22 Can be resumed, and there is no need to stop the program and stop the debugging work.
<Supplement>
As mentioned above, although embodiment of this invention was described, this invention is not limited to said content, It can implement also in the various forms for achieving the objective of this invention, the objective related to it, or an incidental, for example, It may be the following.

1. In the end requirements embodiment, as the end requirements, but an example that the exit from a function prediction point P _P is specified, for example, it is slipped out from the module to the presence of (1) the prediction point, (2 ) It may be a condition that the line number of the specified source has been reached. Further, (3) the termination requirement is not specified, that is, it may not be stopped even when the predicted point _PP is not passed.

In order to be able to specify these end requirements, a menu such as the point detailed setting menu in FIG. 4 may be displayed and accepted from the user.
2. Starting point _{P S}
In the embodiment, as shown in FIG. 4, as specified with the material of the starting point P _S, it is taken as an example event specified and line number specified is not limited to, or specified by (1) a function name, ( 2) An item may be associated with the point detailed setting menu so that it can be designated by an address (symbol address).

3. Program Status In the embodiment, the status list indicating the program status has the structure of “start address”, “end address”, and “data” (FIG. 4). The specified item (1 byte, 2 bytes, 4 bytes, Don't Care) can be specified, or this "data" can be specified as a conditional expression (for example, (d <= 4) || (e> = 5) And C language style).

In addition, the value of the memory is given as an example of the program status. However, the present invention is not limited to this, and (1) a register value or (2) an I / O (Input / Output Device) status can be designated as the program status. You may do it.
4). Location of Program In the embodiment, the example in which the program stored in the debugger 10 is executed has been described. However, the present invention is not limited to this. For example, the program incorporated in the target device may be run.

5). The language of the program In the embodiment, an example of an if, if else statement has been described as an example of a branch instruction. The language of the program is not limited to the C language, and can be applied to various program languages.
6). In the embodiment, the target of copying is the memory 104 and the register 106 of the target device 100. However, copying may be performed from either the memory or the register. Further, for example, in the memory 104, only addresses in a range that is accessed by a program being virtually executed may be copied, and addresses in a range not accessed may not be copied.

7). Recording medium, program A control program comprising program code for causing the processor of the debugging device and various circuits connected to the processor to execute the operations and processes (FIGS. 3 and 5) shown in the above-described embodiment, It can be recorded on a recording medium, or distributed and distributed via various communication channels.

Such recording media include IC cards, hard disks, optical disks, flexible disks, ROMs, and the like.
The distributed and distributed control program is used by being stored in a memory or the like that can be read by the processor, and the processor executes the control program to perform various functions as shown in the embodiment. It will be realized.

  The debugging device according to the present invention is useful because it can contribute to support of efficient debugging work.

1 Debug System 2 User 10 Debugger (Debug Device)
DESCRIPTION OF SYMBOLS 12 Control part 14 Input reception part 16 Setting part 18 Display control part 18a Display 20 Program 21 Source code 22 Execution part 24 Execution position determination part 26 State determination part 36 Setting storage part 38 Storage part 40, 80 Window 90 Dialog 100 Target apparatus 104 memory 106 registers P _S starting point (prediction starting point)
P _P prediction point

Claims (8)

A debugging device for debugging a program to be executed on a target device,
A first point indicating a position on the program;
Setting means for setting a second point indicating a position on the program different from the first point;
Execution means for executing the program while writing a value in a first storage unit included in the target device;
When the position of the program being executed by the execution means reaches the first point, the value stored in the first storage unit at that time is copied, and the copied storage content is stored in the second storage unit Means,
The execution means, after copying, executes the program without writing a value to the first storage unit while writing a value to the second storage unit with the first point as a start position.
A debugging device comprising: a determination unit that determines whether or not a position of a program executed by the execution unit after the copying reaches the second point. The debugging apparatus according to claim 1, wherein the execution unit stops execution of the program when the determination unit determines that the second point has been reached. The debugging apparatus according to claim 2, further comprising an output unit that outputs a value written in the second storage unit when the execution unit stops executing the program. The setting means sets the state of the program when the second point is reached,
The determination means determines the state of the program at the time when the second point is reached,
The execution means includes
When it is determined by the determination means that the second point has been reached and it is determined that the set program state matches the determined program state, the execution of the program is stopped,
The program execution is not stopped when it is determined by the determination means that the second point has not been reached, or when it is determined that the set program state and the determined program state do not match. The debugging device according to claim 2. If it is determined that the second point is not reached,
The execution means includes
Ending execution of the program after the copying,
The debugging apparatus according to claim 1, wherein execution of a program is resumed while writing a value to the first storage unit with the first point as a start position. A debugging method executed in a debugging device for debugging a program to be executed on a target device,
A setting step for setting a first point indicating a position on the program and a second point indicating a position on the program different from the first point;
A first execution step of executing the program while writing a value in a first storage unit included in the target device;
When the position of the program being executed in the first execution step reaches the first point, a copying step of copying the value stored in the first storage unit at that time to the second storage unit;
A second execution step of executing the program without copying a value to the first storage unit while writing a value to the second storage unit with the first point as a start position after copying;
And a determination step of determining whether or not the position of the program being executed in the second execution step reaches the second point. A debugging support program for causing a debugging device to execute debugging processing of another program to be executed on a target device,
The debugging process includes
A setting step for setting a first point indicating a position on the other program and a second point indicating a position on the other program different from the first point;
A first execution step of executing the other program while writing a value in a first storage unit included in the target device;
When the position of the other program being executed in the first execution step reaches the first point, a copy step of copying the value stored in the first storage unit at that time to the second storage unit;
After copying, a second execution step of executing the other program without writing a value to the first storage unit while writing a value to the second storage unit with the first point as a start position;
And a determination step of determining whether or not the position of the program being executed in the second execution step reaches the second point. A debugging device for debugging a program to be executed on a target device,
A first point indicating the execution position of the program;
Setting means for setting a second point indicating an execution position different from the first point;
Execution means for executing the program;
After the execution position of the program by the execution means reaches the first point, the execution stops when the second point is further reached,
Execution control means for not stopping execution if the second point is not reached after reaching the first point;
A debugging device comprising: