JP3379675B2 - Reverse execution debugging system - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a reverse execution debug system used when debugging or evaluating a program operating on a microcomputer.

[0002]

2. Description of the Related Art Generally, when a program is debugged or evaluated, the program is actually operated on a microcomputer and the operation is traced. In such operation trace, conventionally, various tools have been used to perform the following work. For example, at a certain address of a program, a breakpoint is set in the middle of the program when it is desired to stop the operation of the program or confirm the passage. If you want to trace a few instructions from a breakpoint, use a step instruction,
The instructions were executed step by step. For trace information that cannot be confirmed by these functions, such as measurement of the execution frequency of a specific instruction or measurement of the number of accesses to an address in memory, install a mechanism such as a counter or flag in the program itself or the debug evaluation tool. I was doing.

Further, in a highly functional debug evaluation tool such as ICE (In Circuit Emulator), a certain amount of history of signal pins of a microcomputer can be held in a trace memory. Then, more trace information can be obtained from the history of these signal pins. By analyzing this trace information, it was possible to know the history of execution instructions and the status of data access. In all of these conventional techniques, a program is executed from a program entry to obtain necessary information at the time of execution.

[0004]

However, the above-mentioned conventional techniques have the following problems. First,
In the case of tracing the operation of the program, in order to reproduce the portion that has passed once, it is necessary to execute again from the program entry, which is not efficient. This situation often occurs when debugging a program. This is because a bug in a program appears as a malfunction on the surface in many cases after a certain time has passed after passing through the bug part. In this case, it is necessary to re-execute the breakpoint many times to re-execute the program from the program entry in order to grasp the previous situation little by little after the malfunction.

Secondly, the execution of a program usually differs depending on the contents of input data and the input timing, and it is often impossible to reproduce an event that has occurred once. Therefore, when an erroneous operation occurs for some reason, the erroneous operation cannot be reproduced and debugging cannot be performed in many cases, and often the executed program processing cannot be reproduced in evaluation. Third, even when using ICE, it was a very difficult task to trace the execution of the program by referring to the history of the signal pins of the microcomputer. Fourth, it was virtually impossible to completely recreate the register and memory values at a particular point in execution, even with ICE. This is because in order to know the register and memory values that are overwritten during program execution, the entire history from the start of program execution must be retained.

[0006]

The reverse execution debug system of the present invention is characterized by the following points in order to solve the above-mentioned problems. (1) 1. A compiler is provided for generating the following trace program based on the program stored in the user source file. That is, this compiler first detects each write instruction that rewrites data in a storage unit such as a register or a memory in a program. Then, a save instruction for saving the data in the storage means immediately before the execution of the write instruction is added immediately before the write instruction. These save instructions are store instructions or a combination of load and store instructions.
A program for trace with these save instructions added is used.

2. A user execution file is provided for storing the trace program generated by the compiler. 3. A trace memory for storing data saved by execution of save instructions in the trace program stored in the user execution file and an instruction address history of the execution process of the trace program is provided. 4. When the execution of the trace program is stopped, based on the trace program stored in the user executable file,
An instruction conversion tool for generating the following reverse execution program is provided. That is, this instruction conversion tool converts each instruction in the trace program from the instruction of the latest instruction address stored in the trace memory into an instruction for sequentially performing reverse data processing, and makes this an inverse execution program.

(2) In (1), the instruction conversion tool has the following features. 1. Convert each load instruction in the trace program into a store instruction. 2. Convert each store instruction in the trace program into a load instruction. 3. Convert each instruction that updates the address when saving data to the trace memory into an instruction that returns to the previous address. 4. Instructions other than the above are ignored.

[0009]

When debugging, a compiler compiles a debugging program in which an instruction to save the data stored in the write area to the trace memory is inserted immediately before the instruction to write to the register or the memory. Then, the debugging program is stored in the user execution file and executed to proceed with the debugging. When a debug program is executed, if a bug exists, its execution will stop due to its effect. Trace memory contains
The address of the position where execution has stopped and the contents of the register and memory at that time are stored. Then, the instruction conversion tool converts the debug program into an instruction sequence for performing the reverse operation on the data in the register and the memory.
As a result, by executing this instruction sequence step by step, it is possible to trace the operation of returning the execution operation in the reverse direction from the position where the execution was stopped.

[0010]

Embodiments of the present invention will now be described in detail with reference to the drawings. FIG. 1 is a block diagram of an embodiment of a reverse execution debugging system of the present invention. FIG. 1 shows the overall configuration of a system including a debugger for debugging a user program operating on a microprocessor (hereinafter abbreviated as MPU) on a target system from a host, a compiler, and an instruction conversion tool. In FIG. 1, in the host 100, the memory 103 and the hard disk 10
5 and a central processing unit 101 (hereinafter abbreviated as CPU)
The CRT 106 and the target I / F unit 104 are connected by the internal bus 102. Also, CP
The U107 has a keyboard 107 for input by the user.
And the mouse 108 are connected.

On the hard disk 105 of the host 100, the source files of the compiler 1 which is a program operating on the CPU 101 of the host 100, the debugger 110, the instruction conversion tool 4, and the user program operating on the target MPU 301. 112, and the user execution file 2 generated by compiling it with the compiler 1 are stored. Target system 300
Is the R0M30 to which the debug monitor 309 was written
4, a memory 305, an MPU 301 that operates the user executable file 2, a trace memory 3a and a trace memory 3b that store the execution history of the user executable file 2, and a memory management unit 310 (hereinafter abbreviated as MMU).
Equipped with. I / F unit 30 of target system 300
3 is the host 10 through the debugger interface 200
0 I / F unit 104 is connected.

MPU 301, ROM 304, memory 305, trace memory 3a, trace memory 3b
And the I / F unit 303 are connected by the internal bus 302 of the target system 300. The trace memory 3b receives M through the instruction address trace circuit 308.
It is connected to the PU 301. As a result, the instruction address trace circuit 308 stores M in the trace memory 3b.
The execution instruction address history of the PU 301 is held.

In this case, the instruction address trace circuit 30
8 uses the trace memory 3b in a loop for holding the history of execution instruction addresses. That is, when the last address of the trace memory 3b has been used, the history is held again from the first address. In this way, the execution instruction address history before the program is stopped can be always held for the capacity of the trace memory 3b. Trace memory 3 that holds the execution instruction address when the program is stopped
The address of b is as shown in FIG.
It is held in the address register 311 of b.

The debugger 110 inputs a command from the keyboard 107 or mouse 108 and CRs the result.
Display at T106. The debugger 110 also loads the user execution file 2 into the memory 305 on the target system 300 by reading the user execution file 2 according to the user's program load command and communicating with the debug monitor 309 through the debugger interface 200. Then, the user command is executed by communicating with the debug monitor 309 through the debugger interface 200.

Next, the operation of the above system will be described. The compiler 1 can add an instruction to write a value at the time of execution by the user execution file 2 operating on the microcomputer, and to save a value before writing in a storage unit such as a register or a memory by an operator's selection. The details of this operation will be described below. For example, the following register addition instruction is defined. add% r1,% r2,% r3 This instruction is an instruction to add the value of% r1 and the value of% r2 and store the result in% r3. Here,% r1 is MPU30
1 shows a register inside 1. This instruction is an instruction that involves writing to a register.

The following instructions are defined. sw% r1, [% r2] This instruction is an instruction to store the value of% r1 in the memory address of the value of% r2, and is an instruction that involves writing to the memory 305. The compiler 1 adds an instruction to save the previous value of the storage means to be written in the trace memory 3a immediately before such an instruction according to the user's selection. For example, when compiling the user source file 112 and the user does not select "add save instruction", the compiler 1 generates the following instruction sequence.

(A1) add% r1,% r2,% r3 (a2) sw% r1, [% r2] On the other hand, when the user selects “add save instruction”, the compiler 1 selects “add save instruction”. In addition to the case where "" is not selected, the processing shown in FIG. 3 is performed. As a result, the following instruction sequence is output. (B1) sw% r3, [% wr1] (b2) add% wr1, 4,% wr1 (b3) add% r1,% r2,% r3 (b4) 1w [% r2],% wr2 (b5) sw% wr2, [% wr1] (b6) add% wr1, 4,% wr1 (b7) sw% r1, [% r2]

Here,% wr1 and% wr2 are work registers which are not used by the user program.
"Lw [% r2],% wr2" is an instruction to load the contents of the memory address having the value of% r2 into% wr2. In addition,% wr1 always indicates the address of the trace memory 3a, and the MMU 310 indicates the start address when the address is further incremented from the last address.

In the above case, the compiler 1 determines the instruction (b3) corresponding to (a1), and this instruction is registered in the register%.
Since it is an instruction that involves writing to r3, an instruction that saves the register value to be written to the trace memory 3a (bl)
Then, an instruction (b2) for updating the saved address is added. Similarly, the instruction of (b7) corresponding to (a2) is determined, and since this instruction involves writing to the memory,
Instructions (b4) and (b5) for saving the written memory value in the trace memory 3a and an instruction (b6) for updating the saved address are added. As described above, it is possible to selectively add an instruction to write a value at the time of execution by a program operating on the microcomputer and to save a value before writing in a storage unit such as a register or a memory.
That is, the save instruction can be added by the option designation by the user.

Next, a debug operation by reverse execution will be described. The instruction conversion tool 4 is used together with the user execution file 2 compiled by selecting "add save instruction" in the compiler 1. After executing the user executable file 2, the instruction conversion tool 4 uses the execution instruction history stored in the trace memory 3b and the value before writing in the storage means such as the register and the memory saved in the trace memory 3a. A user execution file for executing the reverse operation of the user execution file 2 is automatically generated, starting from the time when the user execution file 2 is stopped. The details of this processing will be described below. It is assumed that the user source file 112 is compiled by the compiler 1 so as to "add a save instruction", and as a result, the user executable file 2 including the following instruction sequence is generated.

[0021]   (C1) 0x0fc sw% r1, [% r2]   (C2) 0x100 b label               ...               label:   (C3) 0x200 sw% r5, [% wr1]   (C4) 0x204 add% wr1,4,% wr1   (C5) 0x208 add% r3,% r4,% r5   (C6) 0x20c lw [% r7],% wr2   (C7) 0x210 sw% wr2, [% wr1]   (C8) 0x214 add% wr1,4,% wr1   (C9) 0x218 sw% r6, [% r7]

Here, 0xfc, 0x100, etc. are the addresses of the instructions, and "b label" is the label la.
This is a branch instruction to bel. This user executable file 2
As a result, the MPU 301 sets the instruction address 0x21.
Stop at 8 and target system 300 at that time
It is assumed that the contents of the trace memory 3a and the trace memory 3b are as follows. Contents of the trace memory 3a (d1) 0x12345678 (d2) 0x98765432

[0023] Contents of trace memory 3b (E1) 0xfc (E2) 0x100 (E3) 0x200 (E4) 0x204 (E5) 0x208 (E6) 0x20c (E7) 0x210 (E8) 0x214 (E9) 0x218

Here, it is assumed that% wr1 indicates (d2) and the address register 311 of the trace memory 3b indicates (e9). The contents of the trace memory 3a and the trace memory 3b can be stored in the hard disk 105 by the debugger 110. Instruction conversion tool 4
Trace memory 3a stored in hard disk 105
Using the contents of the trace memory 3b and the user execution file 2, a reverse execution program of the user execution file 2 is generated according to the algorithm of FIG. In the case of the example of FIG. 4, the following reverse execution program is generated. here,
The reverse execution program means a program that causes a state transition opposite to the state transition of the storage means such as the register and the memory when the user program is operated.

[0025] (F1) lw [% r7],% r6 (F2) sub% wr1, 4,% wr1 (F3) lw [% wr1],% wr2 (F4) sw% wr2, [% r7] (F5) sub% wr1, 4,% wr1 (F6) lw [% wr1],% r5 (F7) lw [% r2],% r1

This generation process will be described with reference to FIG.
First, when the instruction of (c9) is read from (e9) in step S41, since this is a store instruction, the opposite load instruction (f1) is generated (steps S42, S4).
3). Next, when the instruction of (c8) is read from (e8) in steps S44 and S41, since this is an instruction to update the address to be saved, an instruction (f2) for returning the saved address by one is generated (step S46). . Then (e
The instruction of (c7) is read from 7), and since this is a store instruction, a load instruction (f3) of the opposite is generated. The reverse execution program is generated in this way. This reverse execution program causes the contents of the memory 305 and the trace memory 3a to be in a state at the time when the user program execution is stopped, and if this reverse execution program is loaded and operated, the state of the storage means such as a register and a memory is changed. The transition can be reversed.

As described above, the compiler 1 and the instruction conversion tool 4 can be used to generate a reverse execution program that performs a reverse operation even when the user program is stopped. , You can do a reverse trace of the program. Reverse tracing of programs is a traditional method, which provides a revolutionary debugging tool. That is, it is possible to reproduce the register and memory values at a specific location of a program that has been executed once, and furthermore, it is possible to carry out reverse tracing by repeatedly executing and stopping the program and referring to the register and memory values. This makes it easier to find the cause of the bug and makes debugging more efficient.

The present invention is not limited to the above-mentioned embodiments, and it goes without saying that various modifications can be made. For example, in the above-described embodiment, the case of the machine instruction close to the hardware has been described, but the present invention can be applied to the debugging of a high-level language program.

[0029]

As described above, according to the reverse execution debug system of the present invention, since the reverse execution program is generated and executed by the predetermined instruction conversion, there are the following effects. That is, when tracing the operation of the program, when reproducing the part that has passed once,
Efficient debugging work can be performed without having to execute again from the program entry. That is,
It is possible to grasp the previous situation step by step from the time when the malfunction occurs, without re-setting the breakpoint many times. Further, even when the execution contents of the program differ depending on the contents of the input data and the input timing, it is possible to reproduce the event that occurred in the past.
Therefore, when a malfunction occurs due to some reason, the malfunction can be reliably reproduced.

[Brief description of drawings]

FIG. 1 is a block diagram of an embodiment of a reverse execution debugging system of the present invention.

FIG. 2 is an explanatory diagram of a configuration of a trace memory.

FIG. 3 is a flowchart illustrating a processing procedure for adding a save instruction.

FIG. 4 is a flowchart illustrating a processing procedure of an instruction conversion tool.

[Explanation of symbols]

1 compiler 2 User executable file 3a, 3b Trace memory 4 Instruction conversion tool

─────────────────────────────────────────────────── ─── Continuation of the front page (56) Reference JP-A-5-108404 (JP, A) JP-A-4-342038 (JP, A) JP-A-2-213946 (JP, A) JP-A-4- 540 (JP, A) JP 50-137544 (JP, A) JP 3-127234 (JP, A) JP 4-153741 (JP, A) JP 63-98031 (JP, A) JP-A-6-222952 (JP, A) JP-A-5-81075 (JP, A) JP-A-4-328644 (JP, A) (58) Fields investigated (Int.Cl. ⁷ , DB name) G06F 11/28-11/34

Claims (2)

(57) [Claims] 1. A trace program in which a save instruction for saving data in a storage means immediately before execution of each write instruction in a program stored in a user source file is added immediately before the write instruction A compiler to generate, a user execution file that stores the trace program generated by the compiler, data saved by the execution of the save instruction in the trace program stored in the user execution file, and the trace program And a trace memory for storing an instruction address history in the execution process of (1), and when the execution of the trace program is stopped, each instruction in the trace program is sequentially reversed from the instruction of the latest instruction address stored in the trace memory. Reverse execution converted to an instruction for data processing A reverse execution debug system comprising an instruction conversion tool for generating a program. 2. The instruction conversion tool converts each load instruction in the trace program into a store instruction, converts each store instruction into a load instruction, and updates each instruction to save an address saved in the trace memory. 2. The reverse execution debug system according to claim 1, wherein the instruction is converted into an instruction for returning to the previous address and instructions other than these are ignored.