JPH11161514A - Debugger device, debugging method and storage medium recording debugging program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a debugger device capable of debugging respective modules without omission even in the case of simultaneously activating the plural modules. SOLUTION: This debugger device is provided with a control part 1, plural debugging execution processing parts 2, a data storage part 3, a data sampling processing part 4 and a display device 5. In this case, when the module during debugging at present instructs the activation of a slave process, the control part 1 selects the debugging execution processing part 2 for debugging the module corresponding to the slave process and sets information required for debugging to the selected debugging execution processing part 2. Also, when the transmission and reception of data are instructed, the control part 1 instructs the module for transmitting and receiving the data to transfer the information relating to transmission/reception data to the data storage part 3 and then, instructs the data sampling processing part 4 to generate the data for screen display. Receiving the instruction, the data sampling processing part 4 generates the data for the screen display.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a technique for debugging a program including a plurality of modules, and more particularly, to a technique for debugging a program described in a high-level language such as C language.

[0002]

2. Description of the Related Art A debugger device that verifies at a source code level whether a program described in a high-level language such as the C language has an error is widely used. This type of debugger has a function of executing a source code constituting a program for each line and displaying the execution result on a screen. If this type of debugger device is used, the source code can be verified line by line, so that bugs can be easily found and the program development period can be shortened.

[0003]

Recently, with the speeding up of the CPU, programs (software) tend to be complicated and sophisticated, and the development period of the program tends to be long. In order to develop a program efficiently, it is desirable to divide the program into a plurality of modules for each function and develop each module.

However, the conventional debugger device cannot debug a plurality of modules at the same time. For example, when a child process is started from a certain module, a debugger device for debugging the child process is newly started. Needed. Also, when data is transmitted / received between a plurality of different modules, the debugger device has to be separately activated in the transmitting module and the receiving module.

[0005] For this reason, in some cases, processing of the child process and data transmission / reception may end while the debugger device is running, and whether the processing and the data transmission / reception of the child process are performed normally. There was a possibility that it was not possible to confirm whether or not it was.

The present invention has been made in view of such a point, and an object of the present invention is to eliminate debugging of each module even when a plurality of modules are started simultaneously, such as starting a child process and transmitting / receiving data. It is an object of the present invention to provide a debugger device which can be performed without any error.

[0007]

According to an aspect of the present invention, there is provided a debugger apparatus capable of debugging a program including a plurality of modules, wherein the debugging is performed on a module basis. A plurality of debug execution processing means for performing, and when starting another module from one module, a debug execution processing means different from the debug execution processing means for debugging an activation source module. And debug control means for setting information necessary for debugging in the newly executed debug execution processing means.

The invention according to claim 1 will be described with reference to FIG. 1, for example. "A plurality of debug execution processing means" are provided in the debug execution processing unit 2, and "debug control means" is provided in the control unit 1
Respectively.

The invention of claim 2 will be described with reference to, for example, FIG. 1. "Debug information storage means" corresponds to the data storage unit 3.

[0010] The display control means corresponds to the control unit 1 and the data collection processing unit 4.

The transmission and reception information storage means corresponds to the data storage unit 3.

[0012]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Hereinafter, a debugger device to which the present invention is applied will be specifically described with reference to the drawings.
The debugger device described below debugs a source code of a program including a plurality of modules described in a high-level language.

FIG. 1 is a block diagram of one embodiment of a debugger device according to the present invention. The debugger device of FIG. 1 includes a control unit 1, a plurality of debug execution processing units 2, a data storage unit 3, a data collection processing unit 4, and a display device 5.

Each of the debug execution units 2 has the same configuration, and performs source code debugging of a program module specified by the control unit 1. The debug result is displayed on the display device 5 via the control unit 1. An array unit 6 is provided inside the control unit 1 as shown in the figure. In the array unit 6, the name of a newly activated module (more specifically, the process ID of the module) and the The name of the debug execution processing unit 2 that performs debugging is stored in association with the name. The array unit 6 is specifically composed of a memory, a register, and the like.

The data storage unit 3 stores data and the like transmitted and received between a plurality of modules. Data collection processing unit 4
Generates data for displaying the program execution position of each module at the time of data transmission / reception on the display device 5.
The data generated by the data collection processing unit 4 is displayed on the display device 5 via the control unit 1.

FIG. 2 is a flowchart showing the processing operation of the control unit 1 of FIG. 1. The processing operation of the control unit 1 of FIG. 1 will be described below based on this flowchart. First, the control unit 1 selects the debug execution processing unit 2 for debugging the main module of the program, and sets information necessary for debugging in the selected debug execution processing unit 2 (step S1). The debug execution processing unit 2 executes the source code of the main module one line at a time, and performs debugging in line units.

Next, the control unit 1 includes a debug execution processing unit 2
Display results of the main module debugging performed by
Is performed (step S2). Next, the control unit 1 determines whether or not the main module currently being debugged has instructed the activation of a child process (step S3).
When the activation of the child process is instructed, the control unit 1 selects the debug execution processing unit 2 for debugging the module corresponding to the child process, and selects the selected debug execution processing unit 2
Information required for debugging (step S
4). At the same time, the control unit 1 stores, in the array unit 6, the process ID of the newly started child process and the name of the debug execution processing unit 2 that debugs the module.
Each time a new child process is started, the array unit 6 additionally stores the process ID of the child process and the name of the debug execution processing unit 2.

Next, the control unit 1 displays on the display device 5 the results of the debugging performed by the debug execution processing unit 2 selected in step S4 (step S5).

FIG. 3 is a diagram for explaining the flow of data in the debugger device when a child process is started from the main module. The control unit 1 first stores the process ID “aa” of the main module and the name “D1” of the debug execution processing unit 2 that debugs the main module in the array unit 6 in association with each other. Also, the debug execution processing unit 2
Executes the main module aa line by line to perform debugging, and transfers the debugging result to the control unit 1.

When starting a new module, the control unit 1 sets the process ID “bb” of the module,
Debug execution processing unit 2 that debugs the module
Is added to the array unit 6 and stored in association with the name “D2”. On the other hand, the debug execution processing unit 2
Is executed line by line to perform debugging, and the debugging result is transferred to the control unit 1.

When the module bb starts a child process, the control unit 1 sets the process ID "cc" of the module corresponding to the child process and the name "debug execution processing unit 2" for debugging the module. D3 ”is added to the array section 6 and stored.

As described above, every time a new process or child process is started, the control unit 1 sets the process ID of the process and the name of the debug execution processing unit 2 for debugging a module corresponding to the process. To the array section 6
To be stored sequentially.

The control unit 1 displays the debug results transferred from each debug execution processing unit 2 on the display device 5. As shown in FIG. 3, the display area W1 of the display device 5 stores the source code of the main module in the display area W2.
Displays the source code of the module corresponding to the child process started from the main module. Also,
In the display area W3, a button for selecting information to be displayed on the screen, a button for instructing start / stop of debugging, and the like are displayed. In the display area W4, a variable value or the like at the current execution position of the main module is displayed.
In 5, a variable value at the current execution position of the module corresponding to the child process is displayed.

In FIG. 3, the debug results of two modules are displayed, but the debug results of three or more modules may be displayed simultaneously. However, since the information that can be displayed on one screen is limited, it is desirable that the information to be displayed can be arbitrarily selected according to an instruction of the operator. For example, when three or more modules are activated at the same time, the debug execution processing unit 2 corresponding to the module whose debug result is to be displayed is searched from the array unit 6 and displayed on the display device 5.

Returning to FIG. 2, when the processing of step S5 is completed, or when the module currently being debugged does not instruct the activation of the child process, the control unit 1
It is determined whether the module currently being debugged has instructed another module to transmit and receive data (step S6). When data transmission / reception is instructed, the control unit 1 instructs a module that transmits / receives data to transfer information on transmission / reception data to the data storage unit 3 (step S7).

FIG. 4 is a diagram for explaining the outline of information stored in the data storage unit 3. The data storage unit 3 includes information I1 indicating transmission / reception distinction, transmission / reception data I2, a transmission / reception key I3 used to determine whether transmission data matches reception data, and a module for transmitting / receiving data. Is stored, a source code name I5 of a module that transmits and receives data, and a currently executed source code line I6. Both the module that sends data and the module that receives data,
Information as shown in FIG. 4 is stored in the data storage unit 3.

When the processing in step S7 in FIG. 2 is completed,
Next, the control unit 1 instructs the data collection processing unit 4 to generate data for screen display. In response to this instruction,
The data collection processing unit 4 extracts information having the same transmission / reception key from the data storage unit 3 and generates data for screen display (step S8).

FIG. 5 is a diagram showing an example of screen display data generated by the data collection processing unit 4. As shown,
The data collection processing unit 4 includes: a program name to which the transmitting module belongs; a source code name of the transmitting module; a source code line being executed by the transmitting module; a program name to which the receiving module belongs; Data is generated by combining the source code name and the source code line being executed by the receiving module into one line. FIG.
After the above data is generated, there is no need to store the same data in the data storage unit 3, so these data are deleted from the data storage unit 3.

When data for screen display is generated by the data collection processing unit 4, the control unit 1 displays the data on the display device 5 (step S9). When the process of step S9 is completed, or when data transmission / reception is not instructed in step S6, the control unit 1 repeats the process of step S3 and subsequent steps.

FIG. 6 is a block diagram of a debugger device for transmitting and receiving data between different modules. FIG.
Shows an example in which data is transmitted from the module aa to the module bb. When the data transmission is notified from the debug execution processing unit 2 that debugs the module aa, the control unit 1 transfers the transmission data, the reception data, and the like to the data storage unit 3 to each debug execution processing unit 2. To instruct. In response to this notification, each debug execution processing unit 2 transfers information such as transmission / reception data and a currently executed source code line to the data storage unit 3.

The data collection processing unit 4 extracts information on data transmission / reception between modules from the data storage unit 3 in accordance with an instruction from the control unit 1 and displays data for display as shown in FIG. Is generated and transferred to the control unit 1.
The control unit 1 displays the transferred data on the display device 5.

As described above, according to the present embodiment, since a plurality of debug execution units 2 are provided, even when one module activates a child process, the child process can be immediately debugged, and a plurality of modules can be debugged. Debug results can be displayed on the same screen without missing. Further, since each debug execution processing unit 2 can debug any module by changing the input conditions, it is not necessary to provide a plurality of debugger devices.

When data is transmitted and received between different modules, the transmitted and received data and the source code lines of the transmitting module and the receiving module are displayed at the same time. It can be performed easily.

The control unit 1 in the debugging device shown in FIG.
The debug execution processing unit 2, the data storage unit 3, and the data collection processing unit 4 may each be realized by hardware or may be realized by software. When the present invention is implemented by software, the software may be recorded on various recording media such as a floppy disk or a CD-ROM and executed by a computer.

The display format of the debug result is not limited to the format shown in FIG. There is no particular limitation as long as the number of debug execution processing units 2 is two or more. further,
Although an example in which the control unit 1 controls the display of the display device 5 is described in FIG. 1 and the like, the data collection processing unit 4 may perform the display control.

[0036]

As described above in detail, according to the present invention, a plurality of debug execution processing means for performing debugging in units of modules are provided, and when a child process is started, the module corresponding to the child process is activated. Since the debug execution processing means is immediately assigned to the child process, the child process can be debugged at the same time as the activation of the child process, and the debug can be performed without dropping all the source code.

When data is transmitted / received between different modules, the transmission side information of the transmission side module and
Since the receiving side information of the receiving side module is displayed on the same screen, debugging at the time of data transmission / reception can be performed in detail and easily.

[Brief description of the drawings]

FIG. 1 is a block diagram of an embodiment of a debugger device according to the present invention.

FIG. 2 is a flowchart showing a processing operation of a control unit in FIG. 1;

FIG. 3 is a diagram illustrating the flow of data in a debugger device when a child process is started from a main module.

FIG. 4 is a view for explaining an outline of information stored in a data storage unit.

FIG. 5 is a diagram showing an example of screen display data generated by a data collection processing unit.

FIG. 6 is a block diagram of a debugger device for transmitting and receiving data between different modules.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Control part 2 Debug execution processing part 3 Data storage part 4 Data collection processing part 5 Display device 6 Array part

Claims (7)

[Claims] 1. A debugger device capable of debugging a program comprising a plurality of modules, wherein a plurality of debug execution processing means for performing debugging on a module basis and a case where one module activates another module In addition, another debug execution processing means different from the debug execution processing means for debugging the activation source module is allocated for debugging of the activation destination module, and the debug execution processing means newly assigned is required for debugging. A debug control device for setting important information. 2. The type of module to be debugged,
2. The debugger device according to claim 1, further comprising: debug information storage means for storing a type of the debug execution processing means for debugging the module in association with each other. 3. A debugger device capable of debugging a program composed of a plurality of modules, comprising: a plurality of debug execution processing means for performing debugging on a module basis; Debug control means for assigning a module to be debugged and setting information necessary for debugging to the debug execution processing means to which the module has been assigned; and transmitting and receiving data when performing data transmission and reception between a plurality of modules. A debugger device comprising: display control means for displaying, on a display device, transmission side information including a name of a side module and a program execution position and reception side information including a name of a reception side module and a program execution position. . 4. When transmitting / receiving data between a plurality of modules, transmission / reception information for storing transmission / reception distinction, transmission / reception data, a transmission / reception key indicating a correspondence relationship between transmission / reception, and a program execution position in the module at the time of transmission / reception Storage means, wherein the display control means displays the transmission side information and the reception side information on the display device based on data having the same transmission / reception key among data stored in the transmission / reception information storage means. The debugger device according to claim 3, wherein the debugger device is displayed on the same screen. 5. The debugger device according to claim 1, wherein said plurality of debug execution processing means debugs a source code described in a high-level language. 6. A debugging method capable of debugging a program comprising a plurality of modules, comprising a plurality of debug execution processing means for performing debugging on a module basis, and starting another module from one module. In this case, a debug execution processing means different from the debug execution processing means for debugging the activation source module is assigned for debugging the activation destination module, and the newly assigned debug execution processing means is assigned to the newly assigned debug execution processing means. To set information required for debugging and to send and receive data between multiple modules,
A debugging method characterized by displaying, on the same screen of a display device, transmission side information including a name of a transmission side module and a program execution position and reception side information including a name of a reception side module and a program execution position. 7. A computer-readable recording medium on which a debugger program capable of debugging a program comprising a plurality of modules is recorded, wherein a plurality of debug execution processing means for performing debugging on a module basis; When activating another module from a module, another debug execution processing means different from the debug execution processing means for debugging the activation source module is assigned for debugging the startup destination module, and the newly assigned debug Debug control means for setting information necessary for debugging to the execution processing means; transmitting / receiving information including a name of a transmitting module and a program execution position when transmitting / receiving data between a plurality of modules; Reception including module name and program execution location A computer-readable recording medium debugger program for executing a display control means for displaying on the same screen of the display device and the information.