JPS63200243A - Debugging device - Google Patents

Abstract

PURPOSE:To perform an effective debugging job by deciding the presence or absence of the interruption of a break point after storing the location correspondence between a program to be debugged and a source list into a 1st table and the location of the set break point into a 2nd table respectively. CONSTITUTION:A lower rank information processor 101 contains a program 101 to be debugged and a break pointsetting routine 112; while a higher rank information processor 103 contains a debugger 105, the 1st and 2nd tables 108 and 106, and a location counter 107. Then the location correspondence between the program 102 and a source list is stored in the table 1008. The debugger 105 decides a location on the program 102 corresponding to a location on the source list and stores it into the table 106. Then the debugger 105 receives the information on the discontinuation of the program 102 and decides whether the location of the program 102 is stored in the table 106 or not. If so, the interruption of a break point is decided and displayed.

Description

[Detailed Description of the Invention] [Field of Industrial Application] The present invention relates to a device for debugging a program written in a high-level language, and in particular, a device for debugging a program written in a high-level language. This invention relates to a debugging device that allows breakpoints to be set during interaction to stop the process.

[Conventional technology]

A program to be used on an existing computer, such as an existing control computer, is developed on a separately prepared program development computer, and an execution object is generated on this computer (the developed source program is written in a high-level language). This is then compiled into machine language) and downloaded to a control computer via a communication circuit. In this system, it is desirable that the program development computer also performs operation management and maintenance of the control computer, and one of these is a program debugging function.

As a device for this debugging, Japanese Patent Application Laid-Open No. 61-82247
As disclosed in the issue of lower-level information processing device i! In order to debug the debugged program executed on the above-mentioned control computer on the higher-level information processing device (the above-mentioned program development computer), breakpoints (for checking the values of each register, etc.) in the source list must be set in advance. The method used was to write characters to set the point at which the execution of the program was paused.

FIG. 2 is a block diagram of the debugging device described above, in which a program to be debugged 202 on a lower-level information processing device 201 is transferred to a debugger (debugging device) 20 in a higher-level information processing device 203.
5 to debug. The input/output device 240 is used by the operator for debugging.

FIG. 3 shows the flow of debugging work using such a conventional device. The figure also shows the process of creating a normal program; in step 301, a high-level language source list is input to the host computer 203.

In step 302, this is translated and compiled)) In step 303, the syntax is checked. If a mistake is found, it is corrected and retranslated in step 308, and if there are no grammatical mistakes, the program to be debugged (compiled object) is downloaded to the lower-level information processing device 201 in step 304. In step 305, this loaded program is run on the lower-level information processing device 201 to debug it, and if a bug is found, the process moves from step 306 to step 308, where the source program is modified and a breakpoint is set at the location you want to check. do. Next, proceed to translation, download, and debugging again, and check each register etc. at the set breakpoint.

[Problem that the invention seeks to solve]

In the conventional device described above, the operator does not set breakpoints interactively. Therefore, if you try to stop at an arbitrary point during debugging, you must first modify the high-level language source list and set the breakpoint. death,
This modified source list needs to be translated and downloaded again, which poses a problem in that efficient debugging cannot be performed.

An object of the present invention is to provide a debugging device that can stop program execution at any point by interactively setting breakpoints at any point during debugging, without having to set breakpoints when creating a program source list. It is on offer.

[Means for solving problems]

The purpose of the above is to store the location correspondence between the program to be debugged and the source list in the first table, and use this first table to set breakpoints specified by statements on the source list in the program to be debugged. Set a breakpoint by converting it to a location, and store the location of the special pending breakpoint in a second table for storing the location, and also a table storing breakpoint locations of the program to be debugged. This is achieved by providing a processing means that uses a location counter to determine whether or not an interrupt generated in a lower-order information processing device is a breakpoint interrupt.

[Effect]

When an operator sets a breakpoint.

Display the source list on the CRT screen and specify any breakpoints for each statement. The debugger first maps the source list to the location of the program being debugged.
Refer to the table below and set a breakpoint at the appropriate location in the program to be debugged. At this time,
The set location is registered in the second table for storing breakpoint locations.

On the other hand, when the debugger receives an interrupt from the lower information processing device, it obtains the current location from the location counter, refers to the second table that stores the breakpoint location, and if the location is on the table, the breakpoint is set. It is determined that there is, and each part can be checked in that state.

〔Example〕

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

FIG. 1 is a configuration diagram showing an embodiment of a debugging device. The lower information processing device 101 has a program to be debugged 1.
02 and a breakpoint setting routine are built in, and the upper information processing device 103 includes a debugger 105, a second table 106 that stores the location string of breakpoints set in the lower information processing device 101, and a A first table 108 that associates a location counter 107 in the bugged program with the locations of statements on the source list and the program to be debugged is built-in. The functions of the debugger 105 include setting breakpoints in the program to be debugged, controlling execution of the lower information processing device 101, and accessing the memory and registers of the lower information processing device 101. Communication lines 110 and 111 connect the memory and registers of the lower information processing device 101 to the upper information processing device 103.
The lower information processing device 10 accesses the debugged program translated and generated by the upper information processing device 103.
This is a communication line for downloading to 1. Further, the input/output device 104 is used for debugging by the operator.

FIG. 4 shows the flow of processing in this embodiment.

In the figure, first, in step 401, a source list is input to the upper level information processing device 103, in step 302 it is translated into an object, and in step 303, a check for grammatical errors is performed. If there is an error, the source list is corrected in step 409 and the translation is restarted from step 302. Step 404 when there are no grammatical errors
The object is downloaded to the lower-level information processing device 101 in step 405, and debugging is performed by the operator while running this object. If a breakpoint needs to be set during this process (step 406),
Breakpoints are set while referring to the source list as described below (step 410), and the process returns to debugging step 405. If setting a breakpoint is not necessary, it is determined in step 407 whether debugging is complete, and if correction is necessary, the process returns to step 409.

FIG. 5 is a flowchart showing details of breakpoint setting in step 410 of FIG.

Although not shown in FIG. 4, when the source list is translated by the higher-level information processing device 103 (step 402), a first table showing the location relationship between the sentences in the source list and the program to be debugged is created.

If it is determined in step 406 of FIG. 4 that breakpoint setting is necessary, the operator issues an instruction in step 501. The debugger determines which location on the object (program to be debugged) the location on the source list indicated by the operator corresponds to by referring to the first table (step 502), and then, together with the determined location, lower-level information A start request is issued to the breakpoint setting routine 112 of the processing device 101 (step 503). Then, the lower information processing device 10
The breakpoint setting routine in step 1 is started (
In step 505), when a breakpoint is set in the object code (step 506), a completion report is sent to the lower-level information processing device 101. Upon receiving this completion report, the higher-level information processing device 103 performs step 504.
).

The location of the breakpoint set on the object code is stored in the second table, and the process ends.

Next, FIG. 6 shows the flow of breakpoint processing during execution of the program to be debugged. When an interrupt occurs in the lower information processing device 101 and the execution of the program to be debugged is stopped (step 601), the debugger 105 of the upper information processing device 103 receives this interrupt notification and learns the stop location of this interrupt from the location counter 107. (Step 602), and checks whether this location is in the second table by referring to the second table (step 602).
Step 603), if the same entry as the stop location exists on the second table (Step 604), the debugger 105 determines that it is a breakpoint interrupt and outputs a breakpoint message to the CRT screen.Step 6
05), Waits for a debug command input from the operator (step 607), and if the interrupt is not caused by a breakpoint, it is determined that the interrupt is due to some kind of busy schedule, and a message to that effect is output to the CRT screen (step 606).
).

〔Effect of the invention〕

According to this embodiment, by allowing the operator to interactively set breakpoints on the source list, object code can be created without going through processes such as translating the source list into objects and downloading it to the lower-level information processing device. Since breakpoints can be set directly in the program, debugging efficiency is significantly improved.

[Brief explanation of the drawing]

Fig. 1 is a block diagram showing an embodiment of the debugging device of the present invention, Fig. 2 is a configuration diagram of a conventional debugging device, Fig. 3 is a diagram showing the flow of conventional debugging work, and Fig. 4 is a diagram showing the present invention. Figure 5 is a flowchart showing the details of the breakpoint setting step in Figure 4.
FIG. 6 is a flowchart of processing in the upper information processing device when an interrupt occurs in the lower information processing device. 101...Lower information processing device, 102...Program to be debugged, 103...Upper information processing device, 104
...Input device, 105...Debugger, 106...
Breakpoint location storage table, 107・
. . . Execution location counter, 108 . . . Corresponding location storage table of source list and debugged program.

Claims (1)

[Claims] 1. A higher-level information processing device creates a source list written in a high-level language and converts it to object code, and a lower-level information processing device connected to the higher-level information processing device via a line downloads and executes the object code. In the debugging device installed on the upper information processing device side of the computer system configured as described above, a correspondence table between each sentence on the source list and the location on the object code corresponding to that sentence is generated and stored at the time of the above translation. a location counter to indicate the location of the executable code when the object code is executed; and a second table to store the location of a breakpoint set to pause execution of the object code. table and the location on the object code where the breakpoint should be set when the operator specifies a breakpoint on the top list.
A first processing means having a function of determining the location by referring to a table, setting a breakpoint at the determined location, and registering the determined location in the second table, and executing an object code. When an interrupt occurs in the lower information processing device and this is notified to the upper information processing device, the location where the interrupt occurred is read from the location counter, and the read location is registered in the second table. A second processing means determines that the interrupt is caused by a breakpoint when the location matches one of the locations, and determines that the interrupt is caused by an abnormal occurrence when there is no match, and notifies the operator to that effect via the input/output device. A debugging device characterized by being provided with.