JPH07319729A - Software debugging method - Google Patents

Abstract

PURPOSE:To verify a program to be verified in exactly the same state as the program to be built in a real product by showing a source program row to which the address of an object code is assigned and another source program row to which the address of the object code is not assigned on a display device after discriminating both rows from each other based on the inputted information. CONSTITUTION:The information on the corresponding relation between the address of an object code 6 produced in the optimization processing step when a source program 4 to be verified is compiled and the row number of the program 4 is inputted through a keyboard 2 before the start of execution of the processing that is carried out based on the code 6 that compiled the program 4. Then the row of the program 4 to which the address of the code 6 is assigned and another row of the program 4 to which the address of the code 6 is not assigned are discriminated from each other based on the information inputted through the keyboard 2 and shown on a display device 1 to the display instruction of the program 4. Thus the program 4 can be verified with high efficiency.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a software debugging method for verifying a program developed in software development work.

[0002]

2. Description of the Related Art Generally, when verifying a newly created source program, the source program is compiled by a compiler and converted into an object code,
A method of confirming whether or not it works as designed by causing the debugger to execute it is adopted. Then, the source program, which is confirmed to operate as designed, is incorporated into the actual product and shipped.

In this case, the optimization technique has improved in recent compilers, and a plurality of lines of the source program are collectively optimized, so that the address of the object code corresponds to each line of the source program. Instead, the compilation method is such that a multi-line source program corresponds to multi-line addresses.

Therefore, in such a compiling method, there is a portion in which the line of the source program to be verified and the address of the object code do not have a one-to-one correspondence.

However, if such a portion occurs, when an attempt is made to verify the result of execution up to an arbitrary source program line n in debugging work, and the address of the object code corresponding to the source program line n does not exist, , It becomes impossible to set the address (breakpoint) of the object code that stops execution.

Therefore, conventionally, in the debugging work stage, (1) UNIX symbolic debugger (sd
As shown in b), debug with the object code created with the optimization processing of the compiler suppressed, or (2) the tester predicts the breakpoint and executes up to the predicted breakpoint. The following debugging method is adopted, and if it is confirmed that the operation works as designed in this debugging work, it is incorporated into the actual product.

[0007]

However, when debugging is performed with the object code created in a state where the optimization processing of the compiler is suppressed, even if it is confirmed that the object code operates as designed, it is incorporated into the actual product. This means that a program different from the program has been debugged, and strictly speaking, it cannot be said that the program incorporated in the actual product has been verified.

Further, when the method in which the tester executes up to the predicted breakpoint is adopted, it is unlikely that one prediction hits the target breakpoint.
There is a problem in that work efficiency is poor because the operation of setting a prediction breakpoint must be repeated many times.

An object of the present invention is to provide a software debugging method capable of verifying a program to be verified in exactly the same state as a program incorporated in an actual product, and performing the verification work efficiently. is there.

[0010]

In order to achieve the above object, the present invention is basically based on the verification of the source program to be verified before the execution of the process according to the object code obtained by compiling the source program to be verified. Input the information indicating the correspondence between the address of the object code created in the optimization processing stage at compile time and the line number of the source program, and the source program to which the address of the object code is assigned to the display instruction of the source program. The present invention is characterized in that a step of displaying on the display device a line and an unassigned source program line are distinguished based on the information.

[0011]

According to the above means, the address is not assigned to the source program line to which the address of the object code is assigned based on the information of the table showing the correspondence between the address of the object code and the source program line number. The contents of each line are displayed on the display device separately from the source program line.

Therefore, even if the source code line and the address of the object code do not have a one-to-one correspondence with each other when the optimization process is executed at the time of compilation,
Since the source program line to which the address of the object code is assigned (hereinafter referred to as the valid line, the source program line to which the address is not assigned is referred to as the invalid line) becomes clear, the tester must specify only the valid line. It becomes possible to give an execution stop instruction or an execution start instruction.

Therefore, without suppressing the optimization process,
That is, the verification target program can be verified in the same state as the program installed in the actual device. Further, since it is not necessary to predict the effective row, it is possible to realize the execution stop or the execution start in the effective row with only one instruction operation.

[0014]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS The present invention will be described in detail below with reference to illustrated embodiments.

FIG. 1 is a block diagram showing an embodiment of an apparatus for carrying out the present invention.

In the figure, 1 is a display, 2 is a keyboard, and 3 is a workstation. Inside the workstation 3, a source program 4 to be verified is compiled to create an object code 6 and is optimized. When verifying the source program 4, a compiler 5 that creates information 7 (hereinafter referred to as symbol information 7) indicating the correspondence between the address of the object code 6 and the line number of the source program 4 during processing,
The source program 4 and the object code 6 and the symbol information 7 are read, and the object code 6
Object code 6 while executing the processing according to
A source program line (valid line) to which the address is assigned is provided with a software debugger 8 which distinguishes the line from the invalid line and displays the contents of each line on the display 1.

FIG. 2 is a diagram showing an example of the source program 4, the object code 6, the symbol information 7 and the detailed structure of the software debugger 8. In the source program 4, the line number 4a is described at the beginning position of the line, and then the line number 4a is described. The character information indicating the processing content is described in.

The object code 6 obtained by compiling the source program 4 has an instruction word 6b and an operand 6c.
Address information 6a indicating the storage address is assigned to each object code line.

Further, in the table for registering the symbol information 7, the address information 6a of the object code line,
The line number of the source program 4 corresponding to the object code line is registered as a pair.

On the other hand, the software debugger 8 comprises a source program display process 8a, a line number discrimination process 8b, a line number correction process 8c and a debug process 8d. The debug process 8d further includes a breakpoint process 8d1 and a variable display process. 8d2 and the like.

FIG. 3 is a flowchart showing a procedure for verifying the source program 4 in the above configuration.

First, the source program 4 to be verified
Is read into the compiler 5 and the compiling process is performed. At this time, it is determined whether the optimizing process is performed and whether the software debugger 8 is used, based on the input information from the tester (step 30). When performing the optimization process and using the software debugger 8,
The source program 4 is read by the compiler 5, the compilation process is executed, and the object code 6 is generated (steps 31 and 32).

At the same time, in the optimization process of the compiler 5, the symbol information 7 indicating the correspondence between the address 6a of the object code 6 and the line number 4a of the source program 4 is created.

On the other hand, if there is an instruction not to perform the optimization processing, the compilation processing is executed with the optimization processing suppressed (step 33).

As a result, for example, in the source program 4 of the example of FIG. 2, when the optimization processing is instructed,
The 19th to 20th lines of the line number 4a of the source program 4 are changed from addresses "85E8" to "85F4" of the object code 6, and the 21st to 24th lines of the line number 4a are changed from addresses "85F8" to "8630". The optimizing process is collectively performed on a plurality of lines in a corresponding manner.

Next, when a start command is input to the software debugger 8 and the software debugger 8 is started (step 34), the software debugger 8 reads the source program 4 to be verified and its object code 6 and , Symbol information 7 is read (step 35).

Next, the software debugger 8 determines whether or not the display command (source display instruction) of the source program 4 has been input from the keyboard 2, and if so, the source program display processing 8a of the software debugger 8 is executed. As shown in FIG. 2, the line number 4a is added to each line of the source program 4 and displayed on the display 1 (steps 36 and 37).

At this time, the symbol information 7 is searched, and if there is a match in the symbol information 7 with the line number 4a, a symbol 4b (for example, "# (sharp)" symbol) is added to the line number 4a. The address information 6a is displayed so as to be distinguishable from other lines to which the address information 6a is not assigned.

In response to this display, the execution of the source program 4 is temporarily stopped at any step before the final step, and in order to verify the execution result at that stage, the source program line number 4a corresponding to the execution stop step is displayed.
Is set as a breakpoint from keyboard 2,
When the execution start instruction is input, the software debugger 8 sequentially executes the processing according to the object code 6 (steps 38 and 39).

The breakpoint processing 8d1 of the software debugger 8 converts the preset breakpoint (effective line number) from the keyboard 2 into the corresponding address information with reference to the symbol information 7, and the execution address information of the object code 6. It is monitored whether or not 6a and 6a match, but if they match (step 41), the debugging process is temporarily stopped at the stage when the object code indicated by the address information 6a is executed (step 41).

However, if they do not match (that is, if the execution address is not a breakpoint), it is judged whether or not it is the final address (step 42), and if it is the final address, all debugging work is terminated.

For example, when the software debugger 8 performs an execution stop operation or an execution start operation with the line number 4a, the first line of the source program 4 in the example of FIG. Information 6a
Therefore, the execution stop operation and the like can be made effective, but the address information 6a of the corresponding object code 6 is unknown from the 22nd line to the 24th line. Execution stop operations are treated as invalid.

Therefore, as described above, the line number 4a of the source program 4 to which the address 6a of the object code 6 is assigned, that is, a valid line is clearly indicated by the symbol 4b, and this valid line is designated as a breakpoint. To do.

As a result, even if a portion where the source program line and the address of the object code do not have a one-to-one correspondence when the optimization process is executed at the time of compilation, the source program line to which the address of the object code is assigned is generated. Since it becomes clear, the tester can specify the valid line only and give the execution stop instruction or the execution start instruction.

Here, when a breakpoint is set in step 38, the tester sets the address information 6
The source program line (valid line) to which a is assigned is not always specified. Further, the source program display process 8a has a mode in which only the object code 6 is displayed on the display 1 as shown in FIG.

Therefore, in the present embodiment, when a break point is set by the tester, it is determined whether or not the break point corresponds to a valid line by the line number discrimination processing 8b.
In the case where it is determined by the collation with the symbol information 7 and it corresponds to the valid line, it is passed to the breakpoint processing 8d1 as it is, but when it corresponds to the invalid line,
It is passed to the line number correction process 8c, where it is corrected to a number indicating the immediately preceding valid line, and then passed to the break point process 8d1.

For example, in the example shown in FIG. 2, when the line number "22" is set as a breakpoint, the line number "21" is corrected to break point processing 8d1.
Hand over to.

As a result, the breakpoint processing 8d1
Then, the line number set as the breakpoint is converted into the corresponding address information 6a by the symbol information 7, and the debugging work is temporarily stopped when the address indicated by the address information 6a is executed.

In this case, when the line number is corrected, the test person is notified by a warning message or a warning sound that the line is temporarily stopped at the last valid line.

It should be noted that not only the case of temporarily stopping during the debugging but also the case of resuming from the middle can be executed similarly.

Therefore, according to the present embodiment, even if there is a portion where the source program line and the address of the object code do not have a one-to-one correspondence when the optimization process is executed at the time of compilation, the address of the object code is Since the assigned source program line is clarified, the tester can specify the valid line only to give the execution stop instruction or the execution start instruction.

As a result, the verification target program can be verified without suppressing the optimization process, that is, in the same state as the program installed in the actual device. Further, since it is not necessary to predict the effective row, it is possible to realize the execution stop or the execution start in the effective row with only one instruction operation.

For an instruction to stop execution or an instruction to start execution in a source program line to which an address is not assigned, the line number of the source program immediately before the object code address is assigned is corrected and then the object code is followed. Since the process is executed, even if the tester designates an invalid line, the operation is not invalidated, the operation can be reliably stopped, and the work efficiency can be prevented from lowering.

In the embodiment, the valid line and the invalid line are distinguished by the # symbol. However, the invention is not limited to this, and the distinction may be made by a method of changing the brightness, the color or the like.

As a display form of the source program 4, as shown in FIG. 4, the contents of the source program and the corresponding object code may be displayed as a pair for each optimization processing.

[0046]

As described above, according to the present invention, even if the source code line and the address of the object code do not have a one-to-one correspondence with each other when the optimization process is executed at the time of compilation, the object code is generated. Since the source program line to which the address is assigned is clarified, the tester can specify the valid line only to give the execution stop instruction or the execution start instruction.

As a result, the verification target program can be verified without suppressing the optimization process, that is, in the same state as the program installed in the actual device. Further, since it is not necessary to predict the valid row, it is possible to stop the execution or start the execution in the valid row with only one instruction operation, and it is possible to improve the work efficiency.

For an execution stop instruction or an execution start instruction in a source program line to which an address is not assigned, the line number of the source program immediately before the object code address is assigned is corrected and then the object code is followed. Since the process is executed, even if the tester designates an invalid line, the operation is not invalidated, the operation can be reliably stopped, and the work efficiency can be prevented from lowering.

[Brief description of drawings]

FIG. 1 is a block diagram showing an embodiment of an apparatus for carrying out the present invention.

FIG. 2 is a diagram showing a detailed configuration of FIG.

FIG. 3 is a flowchart showing a debug procedure in the embodiment.

FIG. 4 is a diagram showing another example of a display format of a source program.

FIG. 5 is a diagram showing a display example of only an object code.

[Explanation of symbols]

1 ... Display, 2 ... Keyboard, 3 ... Workstation, 4 ... Source program, 5 ... Compiler, 6 ...
Object code, 7 ... Symbol information, 8 ... Software debugger, 8a ... Source program display processing, 8
b ... Line number determination process, 8c ... Line number correction process.

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor, Tamotsu Sasaki 1 Horiyamashita, Hadano City, Kanagawa Pref., General Computer Division, Hitachi, Ltd. (72) Akinori Koizumi 1 Horiyamashita, Hadano City, Kanagawa Prefecture Hitachi Computer Ta Engineering Co., Ltd.

Claims (2)

[Claims] 1. A software debug method for verifying a source program by converting a source program to be verified into an object code by a compile process and sequentially executing a process according to the object code, wherein execution of a process according to the object code is started. Previously, the address of the object code created in the optimization processing stage at the time of the compilation of the source program of the verification target, and the information indicating the correspondence relationship between the source program line number is input, to the display instruction of the source program, A method of software debugging, comprising the step of distinguishing a source program line to which an object code address is assigned and a source program line to which an object code address is not assigned based on the information and displaying them on a display device. 2. For an execution stop instruction or an execution start instruction in a source program line to which the address is not assigned, the object code is corrected to the line number of the source program immediately before the object code address is assigned. 2. The software debugging method according to claim 1, wherein the processing according to is executed.