JP2817473B2 - Debug system - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention is used for a debugging system using a host computer, and particularly relates to a debugging system having a target system.

[0002]

2. Description of the Related Art A debug system having a target system is called a cross debug system. The cross debug system is usually connected to a host computer where a debugger program exists by a communication line, and includes an in-circuit emulator controlled by the debug program and a target device to be debugged.

A debugger program on a host computer of a cross debug system is used by a user of a host computer or the like to monitor the flow of operation of a program to be debugged on a target device. It has means for receiving a command for executing one source level line or one machine language instruction, and displaying the current position of the program on the target device at the source level or machine language level after executing one line.

[0004] The target system is a target device including a means for monitoring the operation of the CPU, such as an in-circuit emulator, a CPU to be debugged, a memory device, and the like. The debugger program and the target system transfer commands from the debugger program to the target system and information on the state of the program to be debugged on the target from the target system to the debugger program through a communication line such as an RS232C interface.

For example, the debugger program executes one instruction of a machine language of a program to be debugged on a target device, so that a command for executing one instruction of a machine language is transmitted to an in-circuit emulator in a target system through a communication line such as an RS232C interface. The in-circuit emulator executes one machine language instruction of the program to be debugged on the target device, and transfers the address information of the program to be executed next to the debugger program through the communication line.

Conventionally, in this type of debugging system, a program is created on a host computer, a program is downloaded to an in-circuit emulator through a debugger program on the host computer, and debugging is performed using debugging means of the in-circuit emulator. I was

Further, since the program to be debugged is performed at the machine language level, debugging can be performed only by using the machine language level debugging means of the in-circuit emulator. The in-circuit emulator has machine language-level debugging means. It was enough to have the means.

Recently, however, programs have been described at the source level in high-level languages such as C language and Pascal language.
It is necessary to debug the program at the source level. For this reason, the debugger program on the host computer uses the symbol processing on the source level program and the execution method at the source line based on the source level line information. It has a means for debugging at the source level such as.

In other words, when performing step execution at the source level, a break point may be set at the beginning of the next line in the source program and the program may be executed.

However, what is problematic in debugging is the interrupt function. The interrupt function is a function that is called when a hardware interrupt or a software interrupt occurs regardless of the flow of the source program. In the above-described step execution, the program does not stop in the interrupt function and is not a target of debugging. Therefore, debugging is performed in the following procedure.

(1) Set breakpoints in the entry sections of all interrupt functions.

(2) An interrupt occurs and execution is interrupted at the beginning of the interrupt function.

(3) Debug by performing step execution of an interrupt function.

At present, the number of interrupt factors is increasing due to the enhancement of device functions, and accordingly, the number of interrupt functions is also increasing. In addition, the response time of commands to the debugger user has increased due to an increase in the amount of communication with the in-circuit emulator for setting breakpoints in the entry sections of all interrupt functions.
There is a demand for faster command response time.

[0015]

In the above-described processing method of the language processing program in the conventional debugging system, when debugging an interrupt function, it is necessary to set breakpoints in the entry portions of all interrupt functions. was there.

Since the flow of the program operation of the interrupt function is not continuous, the branch destination cannot be predicted from the source program, and the flow of the program operation cannot be followed. In addition, since the program may end at the branch destination, debugging must be restarted from the beginning.

As described above, according to the processing method of the conventional language processing program, it takes time and effort for debugging, and
In some cases, the operation performed was unexpected, and the usability of the user was not good.

Further, since breakpoints are set in the entry portions of all the interrupt functions of the program to be debugged on the target system, there is a drawback that the response time during execution becomes large.

An object of the present invention is to provide a debugging system capable of effectively debugging a source program including an interrupt function and preventing an erroneous interrupt by eliminating the above-mentioned disadvantages. It is in.

[0020]

According to the present invention, there is provided a host computer including a source program having an interrupt function, a language processing program, an object file, and debugging means, and the debugging means connected to the host computer via a communication line. And a target system in which step execution is controlled by the object file, wherein the object file includes an interrupt function processing unit called from all interrupt functions in the source program. And means for determining whether or not to execute a step including an interrupt function, and means for temporarily stopping the execution of an object by the interrupt function processing unit in the object file at the time of step execution. And

[0021]

The object file includes an interrupt function processing unit which is called from all the interrupt functions in the source program, and the debugging means sets, for example, a breakpoint in the interrupt function processing unit at the time of step execution, thereby setting the object. Pause execution and debug at source level.

Therefore, it is possible to debug a source program having an interrupt function by transmitting the minimum debug information, thereby improving the efficiency of debugging, and preventing an unexpected interrupt from executing an interrupt function and terminating the program. You can eliminate defects.

[0023]

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

FIG. 1 is a block diagram showing an embodiment of the present invention, FIG. 3 is an explanatory diagram showing an example of the source program, and FIG. 4 is an explanatory diagram showing an example of the object.

In this embodiment, a source program 11 having an interrupt function ipsub, a language processing program 12,
A host computer 10 including an object file 13 and a debugging unit 14;
In a debugging system including an in-circuit emulator 40 and a target device 41 as a target system connected via the 2C communication line 30 and controlled by the debugging unit 14 to perform step execution, and a console 20 connected to the host computer 10 The object file 13, which is a feature of the present invention,
All interrupt functions ips in source program 11
The debugging means 14 includes an interrupt function processing unit 13f called from the object file 13 and a means for inputting the object file 13 and determining whether or not to execute a step including the interrupt function ipsub. Means for temporarily stopping the execution of the object by the interrupt function processing unit.

The debugging means 14 is an application program (debugger program) for receiving commands from the user of the debugging means 14 and performing other debugging functions, and also controls source level step execution.

The debugging means 14 receives a step execution command at the source level of the program to be debugged on the target system from the user of the debugging means 14 and sends various in-circuit emulator commands to the in-circuit emulator 40. Receives the result and informs the user of the debugging means 14 of the console 2
Notify via 0.

FIG. 3 shows the contents of an example of the source program 11 which is an input file. In FIG. 3, the numbers on the left side are line numbers in the source program 11 added for explanation.

FIG. 4 shows the object file 13.
3 shows the contents (object program) of the function i.
For psub. Object file 1
Reference numeral 3 denotes a call instruction 13a for an interrupt function, a function preprocessing unit 13b, a function preprocessing unit 13c, a machine language instruction 13c for a statement in a function, a function postprocessing unit 13d and a return instruction 13e, and an interrupt function processing unit 13f. Contains.

Call instruction 13a for interrupt function
Is a call instruction for executing a source level step generated by the language processing program 12 at the beginning of the interrupt function, and calls the interrupt function processing unit 13f. The interrupt function processing unit 13f includes a machine language instruction for setting a breakpoint for step execution.

FIG. 2 is a flowchart showing the details of the processing of the source level step executing means of the program to be debugged on the target system.

The step execution of the function unit at the source level is performed according to the flowchart of FIG. A step execution method of one function unit at the source level will be described with reference to the flowchart of FIG.

(1) The debugging means 14 is a console 20
It is determined whether or not to execute the step including the interrupt function in accordance with the user's instruction through the step (step S1).
When performing the step execution at the function level including the interrupt function, the debugging unit 14 uses the RS232C communication line 30 to input a command for setting a breakpoint at the start address of the interrupt function processing unit 13f on the target device 41. The data is transmitted to the circuit emulator 40 (step S2). Here, a breakpoint is a means for designating a certain memory in a program, executing the program, moving the execution of the program to the specified memory, and stopping the program when the program is executed.

(2) Next, the debugging means 14 transmits the execution command of the program to be debugged on the target device 41 at which the breakpoint is set to the in-circuit emulator 40 using the RS232C communication line 30 (step). S3).

(3) When an interrupt occurs in the program to be debugged, the processing shifts to an interrupt function. At the beginning of the interrupt function, a call instruction 13a of the interrupt function processing unit is executed. Since a breakpoint is set in the interrupt function processing unit 13f, the execution of the debugged program is stopped here. In-circuit emulator 40
RS232 indicates that the debugged program has stopped.
The information is transmitted to the debug unit 14 on the host computer 10 using the C communication line 30, and the debug unit 14 receives the stop information (step S4).

(4) The debugging means 14 transmits a command for releasing the break point of the interrupt function processing unit 13f on the target device 41 to the in-circuit emulator 40 using the RS232C communication line 30 (step S5).

(5) The debugging means 14 obtains, from the target system, the address following the call instruction that called the step execution processing unit, that is, the return address stacked on the stack, which is the stop address information of the program to be debugged. The location where the debugged program is stopped is obtained from the correspondence table between the address and the source program 11, and the user of the debugging means 14 is notified to the console 20 that the source-level step execution has been completed (step S6).

Here, the stack will be described with reference to FIG. If you call a function while the program is running,
The address at which the instruction following the function call instruction, which is the currently executed machine language instruction, is stored, that is, the address to be returned from the function call (hereinafter referred to as a return address) 52 is stored in the stack pointer 51 in the memory 50. From the point where it points, it is stored in the memory in the lower direction (this is called stacking). Next, the stack pointer 51 is updated and points to the position immediately before the return address that is now stacked on the stack. When returning from the function call, the stack pointer 51 is updated to point to the next address on which the return address 52 is stacked, and the execution of the program returns to the return address 52.

When step execution is not performed, no breakpoint is set. Therefore, the debugged program is not stopped in the interrupt function processing unit 13f, and the control of the debugged program returns to the machine instruction following the call instruction 13a for executing the step which previously called the interrupt function processing unit 13f. . Next, a machine language instruction of the function preprocessing unit 13b of the interrupt function is executed. Thereafter, the same processing is repeated until the debugged program ends.

[0040]

As described above, according to the present invention, by setting a breakpoint of the interrupt function processing unit for debugging called from the beginning of an interrupt function,
Not only does it eliminate the need to set and execute breakpoints in the entry sections of all interrupt functions, but it also runs faster than when setting and executing breakpoints in the entry sections of all interrupt functions. There are effects that are performed.

The problem with the communication time is that the debugging means and the in-circuit emulator perform the handshake communication, so that the larger the number of times of communication, the longer the communication time is required. This is because, as the handshake communication transmits information and the number of times of communication is smaller, the communication time becomes shorter as the number of communication becomes smaller.

Further, since the step execution is stopped in all the interrupt functions, an effect that an interrupt function is executed due to an unexpected interrupt, the program is terminated, and it is not necessary to restart debugging from the beginning is obtained. Can be

[Brief description of the drawings]

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

FIG. 2 is a flowchart of one-line step execution at the source level.

FIG. 3 is an explanatory diagram showing an example of the source program.

FIG. 4 is an explanatory diagram showing an example of the object file.

FIG. 5 is an explanatory diagram of the stack.

[Explanation of symbols]

 Reference Signs List 10 Host computer 11 Source program 12 Language processing program 13 Object file 13a Call instruction (for interrupt function processing unit) 13b Function preprocessing unit 13c Machine language instruction (for statement in function) 13d Function postprocessing unit 13e Return instruction 13f Interrupt function Processing unit 14 Debugging means 14a Interruption step execution determining means 14b Object execution suspending means 20 Console 30 RS232C communication line 40 In-circuit emulator 41 Target device 50 Memory 51 Stack pointer 52 Return address S1 to S6 Step

Claims (1)

(57) [Claims] A host computer including a source program having an interrupt function, a language processing program, an object file, and a debug unit; and a step execution control performed by the debug unit, the host computer being connected to the host computer via a communication line. In a debugging system comprising a target system, the object file includes an interrupt function processing unit called from all interrupt functions in the source program, and the debugging unit inputs the object file and includes an interrupt function. A debugging system comprising: means for determining whether or not to execute step execution; and means for temporarily suspending execution of an object by the interrupt function processing unit in the object file during step execution.