JPH0353347A - Debugging system - Google Patents

Abstract

PURPOSE:To carry out the steps at a high speed for each function of source levels like each sentence, each line, each function call, etc., by setting a break point at a process part where the steps are produced by a language process program. CONSTITUTION:When the steps of function levels are carried out, a debugger program 2 sends a command to an in-circuit emulator 5 via a communication circuit 4 to set a break point to the head address of a function step execution process part 33 of a target equipment 6. A user decides whether he/she carries out the steps at block levels or not based on the program 2. If so, the program 2 sends a command to the emulator 5 via the circuit 4 to set a break point to the head address of a block step execution process part 34 of the equipment 6. As a result, the response time is shortened to a command for step execution at a source level.

Description

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

[Conventional technology]

A debugging method that has a target system is called a cross-debugging method, and this cross-debugging method usually includes an in-circuit emulator that is connected to a host computer where a debugger program exists via a communication line, and is controlled by the debug program and a target to be debugged. It consists of equipment.

A cross-debugging debugger program on a host computer monitors the operation flow of the program to be debugged on the target device from the terminal of the host computer. It has a function of receiving a command to execute one line or one instruction in machine language, and after executing one line, displaying the current position of the program l8 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 that serves as a debugger, a memory device, and the like. The debugger program and target system then transfer commands from the debugger program to the target system and information about the status of the program to be debugged on the target from the target system to the debugger log via a communication line such as an RF232C interface. are doing.

For example, a debugger program executes instructions in the machine language of a program to be debugged on a target device.
A one-instruction execution command in machine language is transferred to the in-circuit emulator in the target system through a communication line such as an RS232C interface, and the in-circuit emulator executes one of the programs to be debugged on the target device. j instruction is executed, and the address information of the program to be executed next is transferred to the debugger program through the communication line.

Conventionally, in this type of debugging method, a program is created on a host computer, the program is downloaded to an in-circuit emulator through a debugger program on the host computer, and debugging is performed using the in-circuit emulator's debugging function. Ta.

Also, since the program to be debugged was done at the machine language level, it was possible to debug it simply by using the machine language level debugging function of the in-circuit emulator. The in-circuit emulator is equipped with a machine language level debugging function, and the debugger program on the host computer only displays information from the in-circuit emulator and transfers commands input by the debugger user to 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.

One line of the source program is converted into a plurality of machine language instructions by a language processing program. In this case, a correspondence table between the address of the machine language instruction at the beginning of each source line and the number of the source line in the source program file is output as a file on the host computer as debug information.

In the traditional source-level single-line step execution method,
The debugger program searches the post computer for the current source line number based on the stop address of the program to be debugged on the current target system and the correspondence table of source lines and addresses output by the language processing program.

Next, one instruction step execution is performed at the machine language level from the current address, and after stopping, the stop address of the program to be debugged is obtained from the target system. The debugger program searches for the source line number again from the correspondence table of stop addresses, source lines, and addresses, and compares it with the line number that was originally searched. If it is different, one line step execution at the source level has been completed. , the debugger program notifies the user of the end of single line stepping.

If the line number that was originally searched is the same as the line number that was searched again, it is assumed that the same source line is still being executed.
Execute the step of one instruction at the machine language level again, search for the line number where the stop address ends, and compare it with the first line number. The debugger program repeats this procedure until the line numbers are different.

One line at the source level may be expanded into several machine language instructions, in some cases more than ten instructions. Therefore, in the conventional step execution at the source level, it is necessary to send a step execution command for one instruction at the machine language level to the target system several times to more than ten times, and perform communication to obtain the stop address information.

Compared to conventional debugger programs that are only at the machine language level,
In debugger programs that can handle current high-level languages,
Due to the increase in source-level processing and the increase in the amount of communication with in-circuit emulators, the command response time for debugger users is increasing, and there is a demand for faster command response times. .

Also, even if multiple statements are written in one line of the source program or a function call is written in a statement, the target of step execution is only one line of the source program, so the next line or branched destination One step execution ended at the line . If there were multiple statements in a block, either one line was stepped multiple times or a breakpoint was set at the beginning of the next block.

There are two methods for outputting information for source level debugging generated by this post-processing program. One is to output information different from machine language, such as line number information, and the other is to output machine language information such as a call instruction that calls a routine to check whether the stack is available at the beginning of a function. This is a method of outputting information generated as instructions. Another example of the information output by the latter output method is a language processing program that generates a call instruction that calls a special routine for debugging purposes at the beginning of a machine language instruction for one functional unit for step execution. It will be done.

[Problem to be solved by the invention]

In the above-mentioned debugging method, when performing step execution at the source level of a program to be debugged on a target system, a debugger program and a target software system are used for step execution of machine language instructions included in one source line. Since this requires communication with the debugger program, there is a drawback that the response time when issuing a source level single line step execution command to the user of the debugger program is long.

Also, even if multiple statements are written in one line of the source program or a function call is written in a statement, the target of step execution is only one line of the source program, so the next line or branched destination Step execution other than line by line was not possible. For example, it was not possible to step through each statement or function call.

An object of the present invention is to set breakpoints in processing units for step execution generated by a language processing program, so that step execution can be performed in one functional unit at the source level, such as by statement, line by line, or by function call. The purpose of this invention is to provide a debugging method that can be performed at high speed.

[Means to solve the problem]

The configuration of the present invention relates to a debugging method in which step execution of a source program at the source level is performed by a debugging means on a host computer that communicates with a target system using a source program translated by a language processing program. It is characterized in that step execution is performed by one functional unit at the source level by setting breakpoints in a processing unit for step execution generated by a language processing program.

〔Example〕

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

FIG. 1 is a flowchart explaining one embodiment of the present invention;
FIG. 2 is a block diagram of a system that executes the process shown in FIG. In the figure, this system includes a computer device 1, a debugger program 2, a console 3, an RS232C communication circuit 4, an in-circuit emulator 5, and a target device 6. The target system included in this system corresponds to the in-circuit emulator 5 and the target device 6, the communication means corresponds to the RS232C communication circuit 4, and the debug means corresponds to the debugger program 2.

The debugger program 2 is a program that receives commands from the user of the debugger program 2 and performs other debugging functions, and also controls step execution at the source level. This debugger program 2 receives from the user a step execution command for each function at the source level of the program to be debugged on the target system, sends various in-circuit emulator commands to the in-circuit emulator 5, and receives the results. The company using the debugger program 2 is notified of this fact.

The flowchart in FIG. 1 shows details of single line step execution at the source level of the debugged program on the target system.

FIG. 3 is a configuration diagram of machine language instructions output by the language processing program, including a call instruction 31 for step execution at the source level, a machine language instruction 32 for one functional unit of the source program, and a function step execution processor. 33, a block step execution processing section 34, and a step execution processing section 36 including a statement step execution processing section 35.

A call instruction 31 for step execution at the source level is placed at the beginning of each functional unit such as a function call, block, or statement in a source program that can be analyzed by the language processing program. This is a call instruction for step execution, and calls one of the function step execution processing unit 33, block step execution processing unit 34, and statement step execution processing unit 35 corresponding to each functional unit.

The step execution processing unit 33 for functions branches to the step execution processing unit 35 for statements, and the step execution processing unit 34 for blocks branches.
branches to the statement step execution processing section 35. However, if only a function call is written in one statement, only the call instruction that calls the function step execution processing section 33 is output. Furthermore, if a statement is written immediately after the start of a block, only a branching call instruction is output to the block step execution processing section 34.

The machine language instructions 32 for one functional unit of the source program are a collection of a plurality of machine language instructions obtained by translating one functional unit in the source program by a language processing program. The step execution processing unit 33 is a machine language instruction for which a breakpoint is set for step execution.

Step execution of a source level functional unit is performed according to the flowchart of FIG.

(1) First, in step 11, the user uses the debugger program 2 to decide whether or not to perform step execution at the function level. When performing step execution at the function level, in step 12 the debugger program 2 issues a command to set a breakpoint at the start address of the function step execution processing section 33 on the target device via the R communication line 5.
to send to an in-circuit emulator.

(2) Furthermore, in step 13, the user uses the debugger program 2 to determine whether or not to perform step execution at the block level. When performing step execution at the block level, in step 14 the debugger program 2
RS a command to set a breakpoint at the start address of the block step execution processing section 34 on the client device.
The data is transmitted to the in-circuit emulator using the H.232C communication line 5.

(3) Next, in step 15, the user uses the debugger program 2 to determine whether or not to perform step execution at the statement level. When performing step execution at the statement level, step 1
At step 6, the debugger program 2 sends a command to set a breakpoint at the start address of the statement step execution processing unit 35 on the target device to the in-circuit emulator using the RS232C communication line 5.

Here, a breakpoint is a function that specifies a certain memory in a program, and when the program is executed, the execution of the program moves to the specified memory, and when the program is executed, the program stops.

(4) Next, in step 17, the debugger program sends an execution command for the program to be debugged on the target device in which the breakpoint has been set to the in-circuit emulator using the RS232C communication line 5.

(5> Next, when step execution at the statement level is set in step 18, the debugged program executes the machine language instruction 32 for a certain functional unit, and then executes the call instruction 31 for step execution. Step execution The call instruction 31 for the statement branches to the statement step execution processor 35.A breakpoint is set in the statement step execution processor 35, so the execution of the debugged program stops here.Similarly, the block When level step execution is set, the execution of the debugged program is stopped at the block step execution processing unit 34, and when function level step execution is set, the execution of the debugged program is stopped at the function step execution processing unit 33. The in-circuit emulator uses the RS232C communication line 5 to send information that the debugged program has stopped to the debugger program 2 on the host computer, and the debugger program 102 receives this stop information 6 ( 6) When performing step execution only at the statement level for a source program in which only function calls are described in one statement, the execution of the program to be debugged is performed by the step execution processing unit 36 and then by the function step execution processing unit 33. branch to.

However, the breakpoint is step large line processing part 3 for the function.
3, a breakpoint is set in the statement step execution processing unit 35 that branches to the statement step execution processing unit 35 via branch 37, and the debugged program stops here.

(7> When performing step execution only at the statement level for a source program in which a statement is written immediately after the start of a block, the execution of the debugged program is performed by the block step execution processing unit 34 of the step execution processing unit 36. Branches. However, since a breakpoint is not set in the break step execution processing unit 34, the process branches to the statement step execution processing unit 35 via branch 38.A breakpoint is set in the statement step execution processing unit 35. Therefore, the debugged program stops at this point.

(8) The debugger program 2 includes each step execution processing section 33, 3 of the step execution processing section 36 on the target device.
A command for canceling the breakpoints at the start addresses 4 and 35 is sent to the in-circuit emulator using the communication line 5 (step 19).

(9> Next, in step 20, the debugger program 2
The next address of the call instruction that called the step execution processing section, which is the stop address information of the debugged program,
In other words, the return address placed on the stack is obtained from the target system. The position where the debugged program stopped is obtained from the correspondence table between the address and one function unit of the source program, and the user of the debugger program 2 is notified on the console 4 that step execution of one function unit at the source level has ended. .

Here, the stack will be explained based on FIG. 4. When a function is called during program execution, the address where the next instruction of the function call instruction, which is the machine language instruction currently being executed, is stored, that is, the address to return from the function call (referred to as return address 23). , and store it in the memory in the downward direction from the point pointed to by the stack pointer 22 in the memory 21 (this is called stacking). Next, the stack pointer 22 is updated to point immediately before the return address currently placed on the stack. When returning from a function call, the stack pointer 22 is updated to point to the next address where the return address 23 is stacked, and program execution returns to the return address 33.

If step execution is not performed, breakpoints will not be set. For this reason, each step execution processing unit 33,
The debugged program does not stop at 34 and 35,
Control of the program to be debugged returns to the machine language instruction following the call instruction 31 for step execution that previously called each step execution processing unit 33, 34, 35. Next, the RM instruction 32 for the next line of the source program is executed. Thereafter, the same process is repeated until the program to be debugged is completed.

With this method, even if there are function calls or jump instructions in a source line, or multiple statements are written on a single line, the language processing program can analyze function calls, blocks, and statements in the source program. Since the program stops at the beginning of each functional unit such as , etc., step execution of one functional unit at the source level is possible even if the flow of operations in the source program of the program to be debugged is not continuous.

FIG. 5 is a flowchart showing the details of the source-level one-line step execution of the debugged program on the target system according to the second embodiment of the present invention.
Processing is performed in ~50, but processing 41, 43, 4.5,
49, 48.50 are processes 11, 13, 1 of the first embodiment
5.17, 18.20, and processing 42, 44.
4649 are different.

The step execution processing unit 33 is a machine language instruction called by the call instruction 31 for source level step execution, and when the step execution flag is OFF, it does nothing and returns to the machine language instruction 32 for the next functional unit. When the step execution flag is ON, the debugged program is stopped, and the communication line 5 indicates that the debugged program has stopped.
is used to send it to the debug program 2 on the host computer.

Step execution of a source level functional unit will be explained according to a flowchart.

(1) First, in step 41, the user uses the debugger program 2 to determine whether or not to perform step execution at the function level. If step execution is to be performed at the function level, in step 42 the debugger program 2 sends a command to turn on the function level step execution processing flag to the in-circuit emulator using the communication line 5. do.

(2) Next, in step 43, the user uses the debugger program 2 to determine whether or not to perform step execution at the block level. If this executes block-level step execution, in step 44 the debugger program 2 sends a command to turn on the block-level step execution process flag to the in-circuit emulator using the RS232C communication line 5.

(3) Furthermore, in step 45, the user determines whether or not to perform step execution at the statement level using the debugger program 2. If this executes step execution at the statement level, in step 46 the debugger program 2 sends a command to turn on the step execution processing flag at the statement level via RS232C.
The communication line 5 is used to transmit the data to the in-circuit emulator.

Here, the step execution process flag is a flag indicating whether or not to execute step execution of the program to be debugged at present.

(4) Next, in step 47, the debugger program sends an execution command for the debugged program on the target device to the in-circuit emulator using the RS232C communication line 5.

(5> Next, when only step execution at the statement level is set, the debugged program executes the device language instruction 32 for a certain functional unit, and then executes the call instruction 31 for step execution. The call instruction 31 branches to a statement step execution processing section 35.

Since the step execution processing flag at the statement level is set, execution of the debugged program stops here. Similarly, when step execution at the block level is set, the execution of the debugged program is stopped at the block step execution processing unit 34, and when step execution at the function level is set, the execution of the debugged program is stopped by the step execution processing section for functions. It stops at section 33. The in-circuit emulator uses RS23 to indicate that the debugged program has stopped.
The stop information is sent to the debugger program 2 on the host computer using the 2C communication line 5, and the debugger program 2 receives this stop information (step 48).

(6) When performing step execution only at the statement level for a source program in which only function calls are described in one statement, the function step execution processing section 33 of the step execution processing section 36 executes the debugged program. branch to.

However, since the step execution processing flag at the function level is not set, the process branches to the statement step execution processing section 35 at branch 37. Since the step execution processing flag at the statement level is set, the debugged program stops at this point.

(7) When performing step execution only at the statement level for a source program in which a statement is written immediately after the start of a block, execution of the debugged program is performed by the block step execution processing unit 34 of the step execution processing unit 36. Branch out. However, since the step execution processing flag at the block level is not set, the process branches to the statement step execution processing section 35 via branch 38. Since the step execution processing flag at the statement level has been set, the debugged program stops at this point.

(8> In step 4, the debug program 2 uses the RS232C communication line 5 to transmit a command to cancel the step execution processing flag on the target device to the in-circuit emulator.

H9) Next, in step 50, the debugger program 2
The next address of the call instruction that called the step execution processing section, which is the stop address information of the debugged program,
In other words, the return address placed on the stack is obtained from the target system. The position where the debugged program stopped is obtained from the correspondence table between the address and one function unit of the source program, and the user of the debugger program 2 is notified on the console 4 that step execution of one function unit at the source level has ended. .

When step execution is not performed, the step execution processing flag is not set to ON. Therefore, the debugged program does not stop in each step execution processing unit 33, 34, 35, and the debugged program is controlled by the call for step execution that previously called each step execution processing unit 33, 34, 35. Return to the machine language instruction following instruction 31. Next, the machine language instruction 302 for the next line of the source program is executed. Thereafter, the same process is repeated until the program to be debugged ends.

With this method, even if there are function calls or jump instructions in a source line, or multiple statements are written on a single line, the language processing program can analyze function calls, blocks, and statements in the source program. Since the program stops at the beginning of each functional unit such as , etc., step execution of one functional unit at the source level is possible even if the flow of operations in the source program of the program to be debugged is not continuous.

FIG. 6 shows a timing diagram showing the effect of this debugging method.

In the conventional method, when performing step execution of one line at the source level, when one source line contains machine language of several to ten instructions, the in-circuit emulator Until the line number differs from the line number before step execution, that is, the number of machine language instruction steps included in one line (several instructions to more than ten instructions), or if there is a jump in program l8 in the middle, until that jump instruction, It was necessary to perform step execution at the machine language level and search for line numbers, which slowed down the response time of step execution commands.

In the debugging method of this embodiment, by adding a step execution processing section that is always called at the end of one line of the source program, a loop of step execution and comparison processing at the machine language level is not performed, so that step execution commands at the source level are not executed. Command response time is faster.

The problem with this communication time is that the debugger program 2 and the in-circuit emulator 5 perform handshake communication, so 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. The fewer the number of communications, the shorter the communication time. In addition, in this embodiment, even if there are function calls or jump instructions in a source line, or if multiple statements are written on one line, the language processing program can analyze the function calls in the source program. Since the program stops at the beginning of each functional unit such as a block or statement, step execution of a single functional unit at the source level is possible even if the flow of operations in the source program of the debugged program is not continuous. be.

〔Effect of the invention〕

As described above, the present invention has the advantage of being able to speed up the response time of source-level step execution commands, thereby shortening the overall debugging time for the user of the debugging means. Furthermore, it is possible to perform step execution in units of functions, which has the effect of improving usability for the user.

[Brief explanation of drawings]

Figure 1 is a flowchart of one-line step execution explaining the first implementation of the present invention, Figure 2 is a block diagram of a system that executes Figure 1, and Figure 3 is a language processing program used in Figure 1. FIG. 4 is a diagram showing the configuration of the machine language instructions to be output, FIG. 4 is a diagram showing the configuration of the memory used in this embodiment, FIG. It is a characteristic diagram of processing time explaining an effect. 1... Computer device, 2... Debugger program, 3
...Console, 4...RS232C communication line, 5
... In-circuit emulator, 6... Target device, 11-20, 31-40... Processing step,
21...Memory, 22...Stack pointer, 23
...Return address, 31...Call instruction for step execution, 32...Machine language instruction for one line of source program, 33...Step execution processing unit for function, 34...Step execution for block Processing section, 35...
- Statement step execution processing unit, 36...Step execution processing unit.

Claims (1)

[Claims] In a debugging method that performs step execution of a source program at the source level using a debugging means on a host computer that communicates with a target system using a source program translated by a language processing program,
By setting a breakpoint in the processing section for step execution generated by the language processing program,
A debugging method characterized by step execution of a single functional unit at the source level.