JPH01211135A - Program debugging system - Google Patents

Abstract

PURPOSE:To shorten the time necessary for debugging and to improve a debugging efficiency by rewriting the instruction of a routine peak to an unconditional return by a utility program at the time of the unuse of a special processing while a special processing is made into a sub-routine and compiled. CONSTITUTION:First, a source list is compiled and linked, a load module is obtained, next, the necessity of a debugging output is selected, and at the time of the necessity, the peak instruction 8 of a sub-routine 2 is rewritten to an 'NOP', and at the time of the unnecessity, the instruction is rewritten to an unconditional return 'RETURN'. Thereafter, the presence and absence of the change of the necessity of the debugging printing output are checked, and when the necessity of the printing output is changed on the way of debugging, the processing is returned to the first and the processing is re-executed. Namely, when a program composed of a main routine and a sub-routine and described by a high level language is debugged, the peak instruction of the sub-routine is rewritten by a utility program corresponding to the user or unuse of the special processing at the time of the output and at the time of the unuse, this is returned.

Description

[Detailed Description of the Invention] [Industrial Application Field] The present invention relates to a program debugging method that improves debugging efficiency during unit tests and combination tests of programs written in a high-level language. ] Figure 4 shows, for example, O860/UMX FORTRAN 7
This is a source format diagram showing the conventional program debugging method using the "selective compile line" shown on pages 10-11 of the 7 Instruction Manual (published by Mitsubishi Electric Corporation on November 20, 1985). Fortran (FO) is one of the
In the figure, 1 is a main routine, 2 is a subroutine, and 3 is an example of special processing described in the "selective compilation line" in the main routine 1. The debug print output instruction 4 will also be described with respect to the 0th order operation, which is a subroutine call instruction for calling the subroutine 2, which is written in the main routine 1 as the "selective compile line" K. Figure 5 is a flowchart showing the debugging procedure.As shown in Figure 4, instruction 3 of the debug print output is set as a "selective compile line" and the work is carried out according to the flowchart in Figure 5. First, in step STI, it is determined whether debug print output is necessary. As a result, if it is necessary to output a debug print, the process proceeds to step ST2.
For example OS 60/UMX FORT
Compilation is executed with the [Compile option If unnecessary, the process is passed to step ST3, and compilation is executed without specifying "compile option X". after that,
Linking is performed in step ST4, and debugging is performed in step ST5.

Figure 6 is an explanatory diagram showing the structure of the load module when the source list shown in Figure 4 is compiled and linked in this way, and (4) in the same figure is compiled with "compile option X" specified.・This shows the load module when linked, and shows the load module when linked. In the case of "Compile option Compiled and compiled as 3a or 4a,
When linked in step ST4, subroutine 2 is loaded in accordance with subroutine call instruction 4, and during execution, a debug print is output in accordance with debug print output instruction 3, and subroutine 2 is executed. Also, if "compile option X" is not specified,
As shown in Figure 6), each instruction 3.4 written in a "selective compilation line" is a non-executable statement (comment) 3b, 4.
Compiled as b, these comments 3a, 4
Since subroutine b is skipped during execution and is not executed, subroutine 2 is not imported even if it is linked, and no debug print is output.

Check whether or not to change the necessity of debug print output in step ST.
If the necessity of debug print output is changed during debugging in step ST5, the process returns to step ST1 and the compiling operation is restarted. Here, as shown in FIG. 4, the compiling process requires a processing time of about 20 to 30 minutes, and the linking process requires a processing time of about 5 to 7 minutes.

[Problem to be solved by the invention]

Conventional program debugging methods are configured as described above, so if you want to change the use/non-use of special processing such as debug print output, you must compile and link again. As mentioned above, link processing requires a processing time of about 30 to 40 minutes, which poses a problem in that debugging efficiency becomes extremely poor.

This invention was made to solve the above-mentioned problems, and it eliminates wasted time spent on recompiling and linking when changing the use/non-use of special processing, and improves debugging efficiency. The purpose is to obtain a good program debugging method.

[Means to solve the problem]

The program debugging method according to the present invention compiles special processing such as debug printout into a subroutine, and when the special processing is not used, the instruction at the head of the subroutine is rewritten to an unconditional return by a utility program.

[Effect]

The program debugging method according to the present invention converts special processing such as debug print output into a subroutine, and rewrites the instruction at the beginning of the subroutine with a utility program depending on whether the special processing is used or not. If necessary, leave the instruction at the beginning of the subroutine as is, so that when the subroutine is called, the subroutine will be executed and output a debug print, etc. If special processing is not required, the instruction at the beginning of the subroutine will be left as is. Replace the command with an unconditional return, so that even if a subroutine is called, the subroutine will not be executed and will return to the main routine unconditionally.
Prevent debug prints from being output.

〔Example〕

An embodiment of the present invention will be described below with reference to the drawings. 1st
In the figure, 1 is the main routine, 2 is the subroutine,
Reference numeral 5 indicates a subroutine call instruction within the main routine 1 to call this subroutine 2, and 6 indicates a debug print output instruction located within the subroutine 2 as an example of special processing. Here, the source list shown in FIG. 1 is also written in the FORTRAN language TR-, which is one of the high-level languages, like the conventional one.

Next, the operation will be explained. FIG. 2 is a flowchart showing the debugging procedure. First, step ST7
The source list shown in FIG. 1 is compiled in step ST8, and linked in step ST8 to obtain the load module shown in FIG. 3 (3). Next, in step ST9, it is selected whether or not to output a debug printout, and if necessary, step S
At T10, the first instruction 8 of subroutine 2 is set to “NOP”.
”, if unnecessary, the instruction 8 is rewritten to “RETURN” for unconditional return in step 5T11. Whether or not to change the necessity of debug print output is determined in step 5T13.
If you want to change the necessity of debug print output during debugging in step 5T12, return the process to step ST7 and recompile.
Directly return to step ST9 and restart the work without linking.

Here, in the load module shown in FIG. 3 (G) obtained by compiling and linking in steps ST7 and ST8, subroutine call instruction 5 is converted to machine language 5a that calls subroutine 2, and the debug print output is Instruction 6 is converted into machine language 6a for debug print output. When a program is executed in the load module shown in FIG. Then, processing moves to the first instruction 8. Here, immediately after this compile tube link, the first instruction 8 of the subroutine 2 is 'NOP', so
Thereafter, the instructions of subroutine 2 are sequentially executed, and as the processing progresses in the machine language Sat for debug print output, a debug print is output. Thereafter, when the process advances to the last instruction 9 of the subroutine 2, the process returns to the main routine 1 according to the instruction 9, and the process starts from the next instruction 10 of the machine language 5a that calls the subroutine 2. The last instruction 11 is processed and the process ends.

Here, if you do not need debug print output,
At step 5T11, the first instruction 8 of subroutine 2 is changed from "NOP" to "#RETURN" for unconditional return.
Rewrite it to . This rewriting is performed by a utility program. FIG. 3(B) is an explanatory diagram showing the structure of the load module thus obtained. When the program is executed in the load module () in Fig. 2, when the processing progresses from the first instruction 7 of the main routine 1 to the machine language 5a that calls the subroutine 2, the subroutine 2 is called and the first instruction 8 is processed. will move. Here, since the instruction 8 at the beginning of this subroutine 2 has been rewritten to "RETURN" as described above, subroutine 2 is not executed and the processing is unconditionally returned to main routine 1, and the machine that calls subroutine 2 Processing starts from the instruction 10 following word 5a, and ends after processing the last instruction 11 of main routine 1. If you need to output the debug print again while debugging,
In the step 5T10, a utility program is used to execute the instruction 8 at the beginning of the subroutine 2 as "
Rewrite from “RETURN” to “NOP”.

In the above embodiment, a case has been described in which the use/non-use (necessity) of debug print output is changed, but the present invention is not limited to debug print, and may be used to change use/non-use of other special processing.

Further, although the above embodiment shows a case where a program written in FORTRAN is debugged, the present invention may be applied to debugging a program written in another high-level language, and the same effects as in the above embodiment can be obtained.

〔Effect of the invention〕

As described above, according to the present invention, special processing is compiled into a subroutine, and when the special processing is not used, the first instruction of the subroutine is rewritten to an unconditional return by the utility program. Approximately 30~ when changing the use/non-use of
There is no need to recompile and link, which takes up to 40 minutes, and the processing time required for rewriting the first instruction of the subroutine is only about 1 to 2 minutes, so the time required for debugging is significantly reduced. This has the effect of shortening the time and improving debugging efficiency.

[Brief explanation of the drawing]

FIG. 1 is a source format diagram showing a program debugging method according to an embodiment of the present invention, FIG. 2 is a flowchart showing the debugging procedure, FIG. 3 is an explanatory diagram showing the configuration of the load module, and FIG. 4 is a conventional FIG. 5 is a flowchart showing the debugging procedure, and FIG. 6 is an explanatory diagram showing the configuration of the load module. 1 is the main routine, 2 is the subroutine, 6 is the special processing (debug print output) instruction, and 8 is the first instruction of the subroutine. In addition, in the figures, the same reference numerals indicate the same or equivalent parts.

Claims (1)

[Claims] In a program debugging method for a program consisting of a main routine and a subroutine and written in a high-level language, special processing such as debug printout is compiled into the subroutine, and the subroutine is changed depending on whether the special processing is used or not. A program debugging method characterized in that the first instruction is rewritten by a utility program, and when the special processing is not used, the first instruction of the subroutine is set as an unconditional return.