JPH03129439A - Debugging system - Google Patents

Abstract

PURPOSE:To accelerate the response time of a command in the execution of one step of a function level by setting an address trap with respect to the present function range. CONSTITUTION:A debugger program 102 sends the command to set a range address trap at two memory ranges; the memory range from the leading address to one preceding address of the leading address of the present function of a memory on target equipment 107, and the one from the completion address of the function to the last address of the memory on the target equipment 107, to an in-circuit emulator 106. Next, the debugger program 102 transmits the execution command of a program to be debugged on the target equipment 107 on which the range address trap is set to the in-circuit emulator 106. Thereby, the response time in the execution of the command at the function level can be accelerated.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a debugging method, and particularly to a debugging method having a target system.

[Conventional technology]

A debugging method that has a target system is called a cross-debugging method. Cross-debugging methods are usually
It is connected to the host computer where the debugger program resides via a communication line, and consists of an insert emulator controlled by the debug program and a target device to be debugged.

The cross-debugging method and the debugger program on the host computer allow humans to monitor the flow of operations of the program to be debugged on the target device from the host computer's terminal, etc., so that the source level of the program on the target device is monitored by the debugger user. It has the function of receiving a command to execute one line or one instruction in machine language, and after executing one line, displays the current location of the program on the target device at the source level or machine language level.

The target system is a target device that includes a function to monitor CPU operation such as an in-circuit emulator, a CPU to be debugged, a memory device, and the like. The debugger program and target system transfer commands from the debugger program to the target system and information about the state of the debugged program on the target from the target system to the debugger program through a communication line such as an R3232C interface. For example, the debugger program sends a single machine language instruction execution command to an in-circuit emulator in the target system through a communication line such as an R8232C interface in order to execute a single machine language instruction of the debugged program on the target device. 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 method, a program is created on a host computer, the object data of the created program is downloaded to an in-circuit emulator through a debugger program on the host computer, and debugging is performed using the debugging function of the in-circuit emulator. I was going.

Furthermore, since the program to be debugged was executed at the machine language level, debugging was possible simply by using the machine language level debugging function of the in-circuit emulator. In-circuit emulator) W The debugger program on the host computer displays information from the in-circuit emulator and transfers commands input by the debugger user from the keyboard to the in-circuit emulator. It was sufficient to have the following functions.

However, these days, programs are written at the source level in high-level languages such as C or Pascal, and it is necessary to debug programs at the source level. It has functions for debugging at the source level, such as processing symbols on the program and executing functions at source lines based on source-level line information.

Furthermore, there is a demand for advanced debugging functions such as step execution at the function level.

A function is translated into multiple machine languages by a translation program (compiler). In this case, the machine language address at the beginning of the function and the machine language address at the end of the function are output as debug information to a file on the host computer.

A conventional function-level stepping method is shown.

The debugger program searches for the current function on the host computer based on the stop address of the program to be debugged on the current target system and the above-mentioned function and address information outputted by the translation program.

Next, one instruction step execution is performed at the machine language level from the current address, and after stopping, information on the stop address of the program to be debugged is obtained from the target system. The debugger program searches for the function again from that address and the above-mentioned function and address information, and compares it with the function name it was initially searching for. If it is different, it is assumed that one step execution at the function level has been completed, and the debugger program searches for the function again. The program notifies the user of the end of one function step execution. If the function name that was originally searched is the same as the function name that was searched again, it is assumed that the same function is still being executed, and step execution of one instruction at the machine language level is performed again, and the function name is retrieved from the stop address. Search and compare with the first function name. The debugger program repeats this procedure until the function names are different.

A function may be expanded from hundreds of machine language instructions to thousands of instructions in some cases.

Therefore, in conventional step execution at the function level, it is necessary to send hundreds to thousands of step execution commands at the machine language level to the target system and perform communication to obtain the stop address information. .

Compared to previous debugger programs that were only at the machine language level,
In debugger programs that can handle current high-level languages,
Source-level processing and function-level processing are increasing, and the amount of communication with in-circuit emulators is increasing, so the response time for commands to debugger users is increasing. I have a request.

[Problem to be solved by the invention]

In the debugging method described above, when performing step execution at the function level of the debugged program on the target system, the debugger program and the target system for step execution of machine language instructions included in one function are used. Since communication is required, there is a drawback that the response time when issuing a one-step execution command at the function level to the user of the debugger program is long.

[Means to solve the problem]

Communicate with the target system that has an address trap function, and use debugging means on the host computer.
In a debugging method that performs step execution at the function level of a program, the debugging means sends an address trap to a range of machine language instructions on the target system corresponding to the l function of the source program p-gram outside the range of one line to be executed. It has the function of setting a step-out address trap to enable execution for a range of one function to be set or executed, and performing step execution at the function level.

(Example〕 Next, the present invention will be explained with reference to the drawings.

FIG. 1 shows the constituent countries of an embodiment of the present invention.

FIG. 1 shows a computer device 101 and a debugger program 10.
2. Function-address information correspondence file 103, console 104, R3232C communication line 105. It consists of an in-circuit emulator 106 and a target device 107.

In FIG. 1, the target system corresponds to the in-circuit emulator IO6 and the target device 107, the communication means corresponds to the R3232C communication line 105, and the debug means corresponds to the debugger program 102.

FIG. 2 is a flowchart showing the details of the function of the means for one-step execution at the function level of the program to be debugged on the target system.

FIG. 3 is a diagram showing the internal structure of a function-address information file in which information about the start address and end address of a function output by a translation program that translates a source program is set.

The function-address information file is a set of tables of function names, start addresses, and end addresses arranged in ascending order of addresses.

The debugger program 102 is the debugger program 10
This is a program that receives commands from user 2 and performs other debugging functions, and also controls step execution at the source level.

The debugger program 102 is the debugger program 10
2 receives a one-step execution command at the function level of the program to be debugged on the target system from the user 2, sends various in-circuit emulator commands to the in-circuit emulator, receives the results, and uses the debugger program 102 to that effect. Notify the person.

One-step execution at the function level is performed in accordance with the flowchart in FIG. The one-step execution method at the function level will be explained based on the flowchart in FIG.

First, the address information of the stop position of the program to be debugged on the current target system is obtained from the in-circuit emulator and set to X. (201) Next, search for the function name of the source file corresponding to the stop address (X) from the function-address information file 301 arranged in ascending order of the stop address (X) and L
Set to . (202) Searching for a function name from a stop address indicates that the function whose stop address is within the range of the start address and end address of each function in the function-address information file is the current function.

Start address (Y) and end address information (Z) of the current function
) is searched from the function-address information file 301.

(203) The debugger program 102 moves from the start address of the memory on the target device to the start address (Y) of the current function.
R9232C command to set a range address trap in two memory ranges: the memory range up to the address 1 before the end address of the function, and the memory range from the end address 2 of the function to the final address of the memory on the target device.
It is sent to the in-circuit emulator using the communication line 105. (204) Range address trap means that if you specify a certain memory range within a program, set a range address trap for program execution, and then execute the program, the program execution will move within the specified memory range. This is an address trap that occurs when a program is executed and causes the program to stop.

Next, the debugger program uses the R8232C M line 105 to send an execution command for the program to be debugged on the target device in which the range address trap has been set to the in-circuit emulator. (205) The in-circuit emulator stops the debugged program according to the specified range address trap,
The fact that the program to be debugged has stopped is transmitted to the debugger program 102 on the host computer using the R8232C communication line 105, and the debugger program 102 receives and receives this stop information. (206) By receiving this stop information, the debugger program 102 informs the user of the debugger program 102 that the execution of the debugged program has moved to a function different from the function before step execution at the function level. The console 104 is notified that the l-step execution of the level has been completed.

In this method, even if there is a function call or jump instruction in a source line, the program stops at the jump destination.
Even if the flow of operations within a function of the program to be debugged is not continuous, one-step execution at the function level is possible.

Next, other embodiments of the present invention will be described.

In this embodiment, the basic configuration is the same as that in FIG. 1, but the functions are different as follows.

That is, FIG. 4 is a flowchart showing the details of the function of the means for one-step execution at the function level of the program to be debugged on the target system.

FIG. 3 shows the internal structure of a function-address information file in which function names, their start addresses, and end address information output by a translation program that translates a source program are set.

The function-address information file is a set of tables of function names, start addresses, and end addresses arranged in ascending order of addresses. The debugger program 102 is a program that receives commands from the user of the debugger program 102 and performs other debugging functions, and also controls step execution at the function level.

The debugger program 102 is a debugger program lO
2 receives a one-step execution command at the function level of the program to be debugged on the target system from the user 2, sends various in-circuit emulator commands to the in-circuit emulator, receives the results, and uses the debugger program 102 to that effect. Notify the person.

One-step execution at the function level is performed in accordance with the flowchart in FIG. The one-step execution method at the function level will be explained based on the flowchart in FIG.

First, the address information of the stop position of the program to be debugged on the current target system is obtained from the in-circuit emulator and set to X. (401) Next, the function name corresponding to the stop address (X) is searched from the function-address information file 301 arranged in ascending order of the stop address (X) and set to L. (4
02) When searching for a function name from a stop address, the function whose stop address is within the range of the start address and end address of each function in the function-address information file is the current function.

Start address (Y) and end address information (Z) of the current function
) is also searched in the function-address information file 301.

(403) The debugger program 102 uses a step-out address trap command that allows execution of only a sequence of machine language instructions within the memory range from the start address (Y) of the current function to the end address (Z) of the current function. R8232
C communication line 105 to send to the in-circuit emulator. (404) The above-mentioned step-out address trap is an address trap that allows execution of only a specified address range within a program. When a program with this address trap set is executed, the program is executed at addresses other than the specified address. If you move, a trap will occur and the program will stop.

Next, the debugger program sends the execution command of the program to be debugged on the target device for which the step-out address trap has been set to the R8232C communication line 10.
5 to send to the in-circuit emulator. (405) The in-circuit emulator stops the debugged program according to the specified step-out address trap, and uses the R8232C communication line 105 to notify the debugger program on the host computer that the debugged program has stopped. 102, and the debugger program 102 receives this stop information.

(40B) By receiving this stop information, the debugger program 102 informs the user of the debugger program 102 that the execution of the debugged program has been moved to a function whose name is different from the function name before step execution at the function level. The console 104 indicates that one step of the level has been executed.
to notify.

In this method, even if there is a function call or jump instruction in a source line, the program stops at the jump destination.
Even if the flow of operations within a function of the program to be debugged is not continuous, one-step execution at the function level is possible.

FIG. 5 shows a time chart showing the effects of the debugging method of the present invention.

In the conventional method, when performing step execution of one line at the function level, if one function contains machine language instructions of hundreds to thousands of instructions, the machine language level step of one instruction is executed for the in-circuit emulator. After sending an execution command and stopping, obtain the address of the program's stopping position from the in-circuit emulator, search for the current function name from that address, and continue until it differs from the function before step execution at the function level, that is, by one function. If there is a step of machine language instructions included in the program (several hundred to several thousand instructions) or if there is a jump in the program, perform step execution and function name search at the machine language level up to that jump instruction. As a result, the response time of the step execution command was slow (501).

In the debugging method of the present invention, by setting an address trap for the current number range, a loop of step execution and comparison processing at the machine language level is not performed. The response time becomes faster (502).

The problem with communication time is debugger program 1.
02 and the in-circuit emulator 107 perform handshake communication, the greater the number of communications, the more communication time is required. This is because handshake communication not only transmits information but also includes information for establishing a means of communication.
．． If there are fewer numbers, the communication time will be shorter.

〔Effect of the invention〕

As described above, the present invention has the advantage of being able to speed up the response time of a command for one-step execution at the function level, thereby shortening the overall debugging time for the user of the debugging means.

4,

[Brief explanation of the drawing]

FIG. 1 is a block diagram of an embodiment of the present invention. 101... Computer device, 102... Debugger program, 103... Function-address information file, 104... Console, 105
......R3232C communication line, 106...
- In-circuit emulator, 107...Target device. FIG. 2 is a flowchart of one step execution at the function level in one embodiment of the present invention. FIG. 3 is a diagram showing the internal structure of the function-address information file 103. FIG. 4 is a flowchart of a function-level one-step execution of another embodiment of the present invention. FIG. 5 is a time chart showing the effects of the present invention. 501...Response time of one-step execution command at function level in conventional debugging method, 502.
...Response time of a function-level one-step execution command in the debugging method of the present invention.

Claims (1)

[Claims] In a debugging method that communicates with a target system and performs function-level step execution of a source program using debugging means on a host computer, the debugging means communicates with a machine on the target system corresponding to one function in the source program. setting an address trap outside the range of machine language instructions corresponding to one function to be executed for a range of word instructions, or making it executable for a range of machine language instructions corresponding to one function to be executed; A debugging method characterized by setting an out address trap and performing step execution at the function level.