JPS6292034A - Program debugging device - Google Patents

Abstract

PURPOSE:To grasp quickly and accurately the overall flow of a program by identifying and displaying successively the statements under execution. CONSTITUTION:A debugging system includes a work station 11, a terminal equipment 12 that enables an operator to directly address to the station 11, and a debug executing device 13. Then a list of source programs stored in an internal storage 22 set at an executing part is displayed on the screen of a CRT27 when a program to be debugged is executed. Then the statements under execution are specified successively on the displayed list. Thus, the executing process of the program at the same level as the source program is confirmed.

Description

DETAILED DESCRIPTION OF THE INVENTION Technical Field of the Invention The present invention relates to a program debugging device, and more particularly to an improved display method when tracing program execution.

<Summary of the Invention> The present invention displays a source program list of the executed portion on a display screen when tracing the execution of a program to be debugged, and sequentially identifies currently executing statements on the displayed list. By going to the source program, it is possible to check the program execution process at the source program level.

<Background of the Invention> Currently, so-called "symbolic debuggers" are often used as means for supporting program development in high-level languages. As one of the debug functions of such a symbolic debugger, a trace function is known that sequentially traces the execution status of a program and displays the trace status.

However, the trace display described above has traditionally been a method of sequentially displaying indirect information about the currently executed part, such as file names, function names, and line numbers of the source program, in response to executed instructions at the machine language level. was common, so when trying to check the execution process at a high-level language level,
It was necessary to trace the program execution order on the source program list again based on the displayed information, making tracing work extremely complicated.

On the other hand, attempts have been made to display execution traces in addition to the indirect information such as "file name, function name, and line number" of the source program, as well as the source statement of the corresponding line.However, programmers generally do not The flow of a program is often understood in terms of a chain of several lines of statements, and simply displaying executed source statements chronologically has a limit in helping programmers understand the flow of the entire program.

<Objective of the Invention> The present invention has been made in view of the above problem, and it is possible to trace the currently executed statement by tracing the movement on the source program list displayed on the screen when tracing the execution of the program to be debugged. An object of the present invention is to provide a debugging device that allows a programmer to visually recognize the flow of a program in a more natural manner by displaying the program as .

<Structure and Effects of the Invention> In order to achieve the above object, the program debugging device of the present invention includes means for tracing the execution process while executing the program to be debugged, and means for displaying the tracing status of the tracing means. The display means is configured to display a series of source program lists on the screen, and to sequentially identify and display statements currently being executed by the trace means on the displayed list.

With the above configuration, the present invention allows the steps in which the program to be debugged to be executed to be directly observed while checking the relationship before and after the statements on the source program list, so that the program can quickly and accurately check the execution status of the program to be debugged. This has the effect of improving the efficiency of debugging work.

<Description of Examples> The present invention will be specifically described below based on examples shown in the drawings.

In the embodiment, an example will be shown in which the present invention is implemented in a C language debugging system using a general-purpose computer and expanding the scope of application by replacing peripheral devices and software according to the debugging purpose, but the present invention is not limited to this. It goes without saying that the present invention can be implemented in substantially the same way on a dedicated debugging machine that operates independently, and the language for the program to be debugged can also be changed to various high-level languages other than "C".

As shown in FIG. 3, a debug system implementing the present invention includes an engineering workstation 11 using a general-purpose computer, a terminal device 12 that allows an operator to directly access the workstation 11, and a workstation 11. The debug execution device 13 executes a program to be debugged developed using the debugger under control from the workstation 11 side, and enables debugging at the assembler level.

The workstation 11 is centered around an arithmetic and control unit 21 using a microprocessor, an internal storage device 22 consisting of a RAM, an external storage device 23 such as a hard disk drive, and an input/output device 24 equipped with an interface circuit for peripheral devices. are connected to each other via various buses 25, and a terminal device 12 and a debug execution device 13 are further connected to the workstation 11 through an input/output device 24.

The terminal device 12 consists of a keyboard 26 that allows direct access to the workstation 11, and a display device 27 such as a CRT that visually displays the data processing status within the workstation 11.
By inputting a command from the keyboard 26, the compiler 3 shown in FIG. 4 stored in the external storage device 23 is activated.
After loading data created from an execution program such as a tosympolink debugger 32, a source program 33, a load module 34, etc. into the internal storage device 22, the workstation is 11 operates as a debug system as a whole while controlling the debug execution device 13.

The debug execution device 13 is located between a device to be debugged 28, such as an electronic cash register, whose control unit is a microprocessor capable of running a program to be debugged, and the device to be debugged 28 and the workstation 11. The emulator 29 directly controls the debugged device 28 in place of the CPU. The emulator 29 can perform debugging at the assembler level by itself, but in this embodiment, the emulator 29 debugs the debugged object in response to commands given from the workstation 11 through the input/output device 24. After displaying and updating the contents of the memory on the device 28, or performing various controls such as executing and stopping the program on the device 28 to be debugged, the results are sent back to the workstation 11, thereby debugging the workpiece. This enables debugging processing at the level of a source program 33 using a high-level language on the station 11 side.

FIG. 4 schematically shows the flow of software processing mainly within the workstation 11 from when a source program 33 written in C language is translated into machine language and further symbolically debugged.

First of all, the source program 33 consisting of a plurality of files is compiled by the internal compiler 31 of the workstation 11.
is compiled to form the load module 34. In addition to the machine language that can be executed by the microprocessor of the device to be debugged 28 , the load module 34 also contains line number information that indicates the correspondence between the address of the machine language and the line number of the source program 33 . The file format includes, for example, the operating system UNIX SYSTEM V(7) COFF (
Common Object File For
mat).

Next, when the symbolic debugging 32 is activated and a predetermined command is input from the keyboard 26 of the terminal device 12, an emulator command necessary to process the command is sent to the emulator 29. Emulator 29
interprets and executes the emulator command, and then sends the result back to the debugger 32.

Symbolic debugging 32 stores information on its internal memory,
Based on the line number information of the load module 34, a line number table consisting of a record group consisting of machine language addresses, corresponding file names, function names, and line numbers is created in advance, and the debugger 32 uses the emulator The processing results returned from 29 are edited with reference to the line table and source program file 33, and are displayed on the display device 27 of the terminal device 12.

The present invention resides in the debug system having the above configuration, and is characterized by a method of displaying results of trace status during program execution tracing.

FIG. 1 shows an example of a screen display suitable for carrying out the present invention, in which the program counter value of the currently executed command is displayed on the bottom row 42 of the display screen 41 on the display device 27 of the terminal device 12. 43, the file name 44, function name 45, and line number 46 of the corresponding source program are displayed in the format of "file name-function name one line number <pc value>".

The second row from the bottom is a command input canister 47 for inputting disk commands from the keyboard 26 of the terminal device 12.
When the workstation 11 side is accessible, a prompt (>) 48 and a cursor ( ) 49 are displayed, allowing predetermined commands to be input. Further, the area above the area 47 is used as a trace status display area 51.

The trace status display area 51 displays the current program counter value 43 during execution tracing of the debugged program.
Including source program 330 line number 46 corresponding to
A source program list 52 near line number 46 is displayed.

Further, on the list 52, the line number 46 corresponding to the current PC value is specified as a white inversion rod 53, and by sequentially moving the white line 53 in accordance with changes in the PC value 43, the source The execution trace status of the program is displayed on the list 52 of the program 33.

FIG. 2 shows an example of the flow of control for displaying the above-mentioned information. At the "beginning" of step 61, the operator inputs a trace execution start command into the command input canister 47 of the display screen 41 through the keyboard 26. This indicates that trace execution has started.

In conjunction with the start of trace execution, in step 62,
The debugger 32 sends a predetermined emulator command "s tp" to the emulator 29 for step execution of the machine language program. Then, the emulator 29 executes only one machine language of the program in the debugged device 28 in response to the command, and then returns the program counter value (PC) after execution to the symbolic debugger 32. When such a program counter value is received by the debugger 32 (step 63), a line number table created in advance inside the debugger 32 is searched, and the file name 44 of the source program 33 corresponding to the address indicated by the program counter value is searched. , function name 45,
Row number 46 is examined (step 64). In the following step 65, "Is there a line number corresponding to the PC?"
If the determination is "NO", it is determined that a blank line has been executed, so the process returns to step 62 and repeats the above operation until a valid machine language is executed.

On the other hand, if it is determined in step 65 that there is a line number corresponding to the program counter value, then in step 66 it is determined whether the line number is within the range of the source program currently displayed on the display. A judgment is made.

If the determination is "YES", the source program list 52 including the execution part is already displayed on the display screen 41, so the process goes to step 67 without performing an operation to redisplay the source program list 52 on the screen. Move on,
Of the source program list 52 displayed on the screen,
The line number 46 corresponding to the program counter value 43 is highlighted in white 53 to identify the source statement 54 currently being executed.

On the other hand, if the determination in step 66 is NO, it is determined that the program list 52 is not displayed at all, or that the program list 52 is displayed outside of the part currently being executed, so the execution statement 54 is included. It is necessary to display the program list 52. Therefore, in step 68, it is first determined whether the file name corresponding to the program counter value is the same as the file name currently being displayed.
If YES, it is further determined in step 69 whether or not the corresponding line number exists in the file. If the determination is NO, an error message is displayed to call the operator's attention (step 69). 70), the judgment is “Y”
ES", the nearby source program list 52 is displayed for 20 lines on the screen with the line number in the center (step 71), and the corresponding line is outlined 53 in the same way as above.
and display it.

Further, if it is determined in step 68 that "the file name corresponding to the PC value and the currently displayed file name are different", then in step 72 it is further determined that "whether the source file exists in the external storage device or not" is determined. Step 7: If the source file does not exist, an error message indicating that the source file does not exist is displayed to alert the operator.
3) If the file exists, it is opened so that it can be referenced (step 74), and the above display operation is repeated until the entire program to be debugged has been executed.

Note that in the above embodiment, the list 5 of the source program 33
With the movement of 2 stopped, execute statement 54
The trace status is displayed by moving the white inversion rod 53 that indicates the line containing the program, but the line number corresponding to the program counter value is always positioned at a fixed location such as the center of the screen, and the program list is displayed as an execution trace. It is also possible to scroll up and down as the line progresses, and it is also possible to make changes such as adding a mark to the beginning of the line to specify the execution queue instead of making the entire line white.

[Brief explanation of drawings]

FIG. 1 is a front view of a display screen showing an example of displaying an execution trace status in a dehanging device according to the present invention, FIG. 2 is a flowchart explaining the display procedure shown in FIG. 1, and FIG. FIG. 4 is a block diagram showing an example of a debug system for debugging. FIG. 4 is a schematic diagram illustrating the flow of processing in the system of FIG. 11... Workstation 12... Terminal device 27... Display device 33... Source program 41... Display screen 52... Source program list 53... Outline Line Patent Applicant: Tateishi Electric Co., Ltd.

Claims (2)

[Claims] (1) A debugging device comprising means for executing a program to be debugged and tracing the execution process, and means for displaying the trace status of the tracing means, wherein the display means displays a series of source sources on a display screen. A program debugging device characterized by displaying a program list and sequentially identifying and displaying statements currently being executed by a tracing means on the list. (2) The source program list displayed by the display means is a partial list of a predetermined number of lines including the statement currently being executed, and while the movement of the list is stopped and displayed, a predetermined mark indicating the statement currently being executed is displayed. The first claim is shifted sequentially in correspondence with the lines containing the statement.
Program debugging device as described in Section 1.