JPH05216717A - Tracing function for debugger - Google Patents

Abstract

PURPOSE:To find out failure due to the mis-operation of a stack, etc., by checking return to a call origin with a returning instruction in the subroutine of a program to be debugged as the function of a debugger. CONSTITUTION:When the program 100 to be debugged is executed at a single step processing part 120 by one instruction and a subroutine call instruction is executed, an address when it is returned from the subroutine is preserved in a returning address preservation part 140 in advance. Then, the program 100 is executed by one instruction and when an operation is restored from a subroutine, the address returned actually is compared with the address preserved in advance by a returning address checking part 180. Thereby, it is possible to confirm whether or not the address is going to return to the one to be returned originally.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a debugger trace function, and more particularly to a subroutine return address check function.

[0002]

2. Description of the Related Art A conventional trace function has a single step function for executing only one instruction of a debugged program and a breakpoint function for interrupting the execution of the debugged program at an arbitrary position.

[0003]

Since the conventional trace function is a function that simply executes instructions one by one or specifies a place where the execution is interrupted in advance and executes the instructions, a return instruction is issued due to an error in the staff operation. In the case of a program including a subroutine that does not return control to the caller and goes out of control on the way, there is a problem that it is difficult to find the location of the error.

[0004]

The trace function of the debugger of the present invention includes means for allowing the operator to specify the range to be traced for the debugged program and means for executing the debugged program in the specified range one instruction at a time. , A means for disassembling the instruction to be executed next to the debugged program, a means for saving the return address in the debugged program, and whether the disassembled instruction is a routine call instruction, a return instruction, or another instruction. There is a means for judging whether there is any, a means for outputting the address of the instruction next to the routine call instruction of the program to be debugged, a means for reading the return address in order from the most recently saved one, and executing one instruction of the program to be debugged. The value of the instruction pointer register after saving the return address Means for determining if it matches more read return address, and a means for notifying to that effect to the operator only if they do not match.

[0005]

The present invention will be described below with reference to the drawings.

FIG. 1 is a block diagram of an embodiment of the present invention.

Reference numeral 100 is a program to be debugged.
The operator uses the trace range specifying unit 110 to specify the range in which the debugger traces. The single-step processing unit 120 that executes the debugged program 100 one instruction at a time causes the debugged program in the range designated by the trace range designating unit 110 to be executed one instruction at a time. Each time one instruction is executed, the next instruction disassembler 130 disassembles the next instruction and analyzes what the next instruction is. The instruction determination unit 150 determines which of the routine call instruction, the return instruction, and the other instructions the analyzed instruction is.

The return address output unit 160 outputs to the return address storage unit 140 the address at the time of returning from the instruction following the routine call instruction of the program to be debugged, that is, the subroutine, which is executed at the routine call instruction.

The return address storage unit 140 stores return addresses each time a routine call instruction is executed.

The return address reading unit 170 is executed when the instruction determining unit 150 determines that the disassembled result is a return instruction. The return address reading unit 170 reads the most recently stored return address from the return address storage unit 140.

When the data is read once in the return address storage unit 140, the data is erased. The return address read by the return address reading unit 170 is passed to the return address checking unit 180.

The return address check unit 180 causes the debugged program 100 to execute one instruction by the single step processing unit 120. In this case, the return instruction is always executed. Then, the value of the instruction pointer register after execution is compared with the address passed from the return address reading unit 170. If the return instruction returns normally, the above comparisons match.

If there is a defect in the staff operation in the processing in the subroutine, there may be a mismatch here. At this time, the error output unit 190 notifies the operator that a failure has occurred and the execution of the debugged program 100 is stopped.

FIG. 2 is an example of a source list of a program including a malfunction of staff operation.

The main program 200 is the subroutine 2
10 and subroutine 220 is called. The subroutine 220 does not execute the POP command before executing the RET command 224, and thus contains a defect.

Next, the operation when the program 200 of FIG. 2 is used as the program to be debugged 100 will be described in detail. The operator inputs 200 programs as a trace range by the trace range designation unit 110. The single-step processing unit 120 executes 200 from the beginning. Next instruction disassembler 130 and instruction determiner 1
50 sequentially analyzes the program to be debugged.
When step 201 is reached, the instruction determination unit 150 determines that the analysis result is a subroutine call instruction, and the return address output unit 160 is executed.

As a result, the address of the NOP instruction of step 202, which is the next instruction of step 201, is stored in the return address storage section 140.

Then, steps 211 to 214 are executed one after another.

When step 215 is reached, since this instruction is a return instruction, the instruction control unit 150 causes the return address reading unit 170 to execute, and the return address stored earlier is returned to the return address storage unit 140.
Will be read. Then, the return address check unit 180 causes the single-step processing unit 120 to execute, so that Step 215 is executed, and Step 20 is executed.
The address of 2 is loaded into the instruction pointer register. Then, it is compared with the value read from 140. In this case, since they match, the processing continues.

Similarly in step 203, step 2
The address 04 is stored in the return address storage unit 140. When the step 224 is reached in the same procedure as described above, the return instruction is executed in the same manner, and the return addresses are compared, but the POP instruction is not executed and the subroutine 220 has a problem.
The error output unit 190 is executed, the fact is notified, and the trace is stopped.

[0021]

As described above, according to the present invention, whether the address to be returned when the return instruction is executed in the subroutine in the program to be debugged is the address next to the call instruction that called the subroutine is automatically determined by the debugger. Since it checks automatically, it is possible to find defects in stack operation without much effort.

[Brief description of drawings]

FIG. 1 is a block diagram of an embodiment of the present invention.

[Fig.2] Example of program source that includes a defect in staff operation

[Explanation of symbols]

100 Debugged program 110 Trace range specification section 120 Single step processing section 130 Next instruction disassemble section 140 Return address storage section 150 Instruction judgment section 160 Return address output section 170 Return address read section 180 Return address check section 190 Error output section 200 Target Example of debug program source list 210, 220 Example of subroutine to be debugged 201 to 204, 211 to 215, 221 to 224 Steps to be debugged program

Claims (1)

[Claims] 1. A means for causing an operator to specify a trace range of a debugged program, a means for executing the debugged program in the specified range one instruction at a time, and an instruction executed next to the debugged program. A means for disassembling, a means for storing the return address in the program to be debugged, a means for determining whether the disassembled instruction is a routine call instruction, a return instruction, or another instruction, and a routine call for the debugged program A means for outputting the address of the instruction next to the instruction, a means for reading the return address in order from the most recently stored one, and a value of the instruction pointer register after executing one instruction of the program to be debugged Judgment whether it matches the read return address Trace function of the debugger, which is provided with means for notifying the operator of the fact that the means does not match.