JPH08255097A - Debugging information output system - Google Patents

Abstract

PURPOSE: To perform the source level debugging of an optimized object file. CONSTITUTION: A source level debugging information output system which outputs source level debugging information corresponding to a source program 1 and generates an output text file 5 that the object file to be debugged on a source level is based on is equipped with an optimizing process means which optimizes the source program 1 and a debugging information inserting means which outputs block information, made to correspond to the source program 1 in block units, as the source level debugging information after the optimization of the source program 1.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a debug information output method used for a programming language processing device or the like to debug an object file.

[0002]

2. Description of the Related Art Conventionally, when source level debugging is performed on an object file (a source program converted into a machine language for debugging), the object file is not optimized. The reasons are as follows.

(1) Since line information is used to make correspondence with the source program, if optimization is performed such that lines are deleted or lines are replaced, line information cannot be obtained. . This point will be described with reference to FIG. In the figure, 111 is a source program, 112 is an optimized image of the source program, and 113 is an output text file after the source program 111 is optimized.
Reference numeral 114 in the source program 111 is a portion indicating an unnecessary instruction and is deleted when optimization is performed. However, since the source level debug information is output for each line of the source program 111, the output text corresponding to the debug information 115 and 115 'for the portion 114 is lost, and source level debugging cannot be performed.

(2) The stack (a part of the memory) must be used to perform a powerful optimization, but if the stack is used, the contents written in the stack cannot be understood and the source level debugging cannot be performed. I can't do it. Since the conventional source level debug information has no means for knowing the contents of the stack, an object file using a frame pointer is used. However, when the frame pointer is used, optimization cannot be performed because there are insufficient registers.

On the other hand, it has been difficult for a user (hereinafter referred to as a user) to grasp the contents of an output text file obtained by optimizing a source program. Especially when the source program is optimized, it is impossible to follow the output text file in time series. The reasons are as follows.

(1) Variables in the source program are assigned to registers and memories in the output text file. Further, it may be deleted due to optimization.

This point will be described with reference to FIG. In the figure, 121 is a source program, 122 is an image obtained by optimizing the source program, and 123 is an output text file after the optimization of 121. In the process of optimization from 121 to 122, variables c, d, e, which are used internally,
f and g are deleted, and the variable does not appear in 123.
However, when the source program is verified using the output text file, the variable history (whether deleted or not) information is not output at all. Therefore, it is necessary to imagine and judge from the flow of the source program.

(2) In order to perform powerful optimization, the stack pointer (reference point when using the memory) must be used to use the stack (a part of the memory area). As the stack pointer moves sequentially, the contents of the stack cannot be grasped unless the movement amount is grasped.

Reference numerals 124 and 125 both refer to the variables a and b, but the reference address of the variable changes because an instruction using the stack is interposed between the processing of 124 and 125. However, when verifying the source program using the output text file, the stack movement information is not output at all. For this reason, verification cannot be performed without understanding all the instructions that use the stack in the output text file.

[0010]

For the above-mentioned reason, in the conventional source level debug information output method, the object file at the time of source level debugging is not optimized, so that it is wasteful and the size is very large. Grows to. When actually using the object file by incorporating it in the application product, it is necessary to make it as small as possible. Therefore, after the source level debugging is completed, it is necessary to compile while performing optimization again and to use it on the application product without the source level debugging, resulting in a significant decrease in reliability.

On the other hand, since it is difficult for the user to grasp the output text file obtained by optimizing the source program, there are the following three problems.

(1) When optimization is performed, information on a line unit basis of a source file cannot be obtained. Depending on the optimization method, the output text file for the source file may be output at different locations.

(2) It is difficult to grasp the relationship between the source program and the variable in the output text file, since the conventional source information does not have the related information.

(3) Since the data flows of the source program and the output text file do not completely match, the data flow cannot be grasped by the conventional information amount.

For the above reasons, when the user verifies the source program by using the output text file, the conventional information amount significantly reduces the time efficiency.

The present invention has been made to solve the above-mentioned conventional problems, and an object thereof is to make it possible to perform source level debugging on an optimized object file. It is to provide a debug information output method that makes it easier to grasp an output text file generated when optimization is performed.

[0017]

In order to achieve the above object, a feature of the first invention is that source level debug information is output corresponding to a source program, and an object file which is a target of source level debugging is executed. In a source-level debug information output method for generating an underlying output text file, optimization processing means for optimizing the source program, and a block for correlating with the source program in block units after the optimization of the source program And debug information inserting means for inserting information as the source level debug information.

The feature of the second invention is that the source level debug information is output corresponding to the source program, and the output text file which is the basis of the object file which is the target of the source level debug is generated. In the output method, the stack pointer for generating the object file, the block information that corresponds to the source program in block units after optimization of the source program, and the change amount of the stack pointer for each block are It is provided with a debug information insertion means to be inserted as source level debug information. A feature of the third invention is that a syntax analysis unit that analyzes the syntax of a source program, an assembler source generation unit that generates an output text file based on the analysis, and a display that displays the generated output text file. A debug information output method including a section, the assembler source generation section performing optimization processing means for optimizing the source program based on the analysis performed by the syntax analysis section; At least the information indicating the movement amount of the stack in units of text lines of the output text file and the register / memory allocation information of the variables used in the output text file are inserted into the output text file as user debug information. And debug information insertion means.

[0019]

According to the first aspect of the invention as described above, in consideration of the fact that unnecessary lines in the source program are deleted by the optimization of the source program, in order to correspond to the source program, Instead of conventional line information, block information in block units is inserted as source level debug information. This allows source-level debugging even if the optimization removes unnecessary lines.

According to the second aspect of the present invention having the above-mentioned configuration, since the amount of change in the stack pointer for each block is output as the source level debug information, the value of the stack pointer and the contents of the stack can be known. Source level debugging is also possible for object files optimized using.

According to the third aspect of the invention as described above, the user has information indicating the movement amount of the stack for each text line of the output text file, and the register memory of the variables used in the output text file. Since the allocation information can be obtained as user debug information,
When grasping the contents of the output text file, register /
There is no need to consider the memory, it is possible only by looking at the comment. As a result, the time required to understand the contents of the output text file can be reduced.

[0022]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of a debug information output system according to the present invention will be described below with reference to the drawings. The hardware configuration of the debug information output system according to the present invention includes a CPU for performing various processes, an input device such as a keyboard, a mouse, a light pen, or a flexible disk device, and an external device such as a memory device or a disk device. An ordinary computer system that includes a storage device and an output device such as a display device and a printer device may be used.
The CPU includes an arithmetic unit that performs processing in a language and the like, and a main storage unit such as a register that stores an instruction of the processing. Further, the display unit shown in FIG. 1 includes the display by the display device and the one printed by the printer device.

Next, the software configuration of the debug information output system according to the present invention has a syntax for parsing the source code (synonymous with the source program) 1 as shown in the block diagram of FIG. It has an analysis part and an assembler source generation part for generating an output text file (hereinafter referred to as assembler source) 5 according to the analysis in the syntax analysis part, and the assembler source generation part has an optimization processing means and debug information. And insertion means. Also,
The assembler source 5 generated here is provided with a source level debug analysis unit 9 that analyzes for performing source level debugging.

The processing operation performed by the optimized information output method according to the present invention will be described below. First, the program developer stores it in an auxiliary storage device such as a hard disk, and
An instruction for causing a computer system to perform optimization processing on a predetermined source program written in a high-level language such as tran or a machine-oriented language such as an assembler and the like.

Next, the computer system that receives the instruction copies the source program and the instruction group of the processing according to the present embodiment (hereinafter, simply referred to as an instruction group) to the main storage unit or the like in the CPU. The syntax analysis unit in the copied instruction group is executed to analyze the syntax of the copied source program. Next, the optimization processing means of the assembler source generation unit in the instruction group performs deletion of unnecessary instructions, addition of optimum instructions, optimization of instruction order, etc. based on the analysis.
Next, the debug information insertion means inserts the debug information for the user when the optimization process is performed and the source level debug information when the optimization process is performed into the assembler source. Next, a new optimized assembler source 5 is created and output to a display unit such as a display device. At this time, the debug information for the user and the contents of the optimization processing performed by the optimization processing inserting means are also output at the same time as the assembler source 5. Further, source level debugging can be performed by inputting the assembler source 5 into which the source level debugging information is inserted into the source level debugging information analysis unit 9.

A specific example of an embodiment of the debug information output system according to the present invention will be described below with reference to the drawings. In particular, the first to third embodiments will be described when the source level debug information analysis unit 9 performs source level debugging using the source level debug information in FIG. Therefore, in the following description, the source level debug information output method will be particularly referred to. 2 (a),
(B) is a diagram showing a source level debug information output system according to the first embodiment of the present invention, (a) is a flow chart of this system, and (b) is a source level debug information system of this system. It is an image figure.

The method of this embodiment is explained by taking as an example the case where a line is deleted by optimization. In FIG. 10A, 21 is a source program, 22 is an optimized image, and 23 is an optimum. It is a converted output text file (which is the basis of the object file). Since the part 24 in the source program 21 is an unnecessary instruction, it is deleted during optimization. As a result, the line (third and fourth lines) is deleted, so that block information 25, 25 'in block units is output in order to correspond to the source program. At this time, the block information 25 is output corresponding to the third to fifth lines of the source program (blo
ck 3-5, 0). In addition, the block information about the line which is not optimized like the 6th line of the source program,
As shown in the block information 25 ', one information is output per line (block 6-6, 0).

Reference numerals 26 and 26 'in FIG. 2 (b) show images obtained by performing source level debugging (step execution) using the object file generated from the optimized output text file 23. Inverted portions 27 and 27 'in the figure indicate the line currently being executed.

In this embodiment, since the portions 24 of the third and fourth lines of the source level debug 21 are deleted by the optimization, a plurality of lines of the third line to the fifth line are once inverted from the block information 25 in steps. Let it run This allows source level debugging even if the line is deleted by optimization.

FIGS. 3A, 3B and 3C are diagrams showing a source level debug information output system according to the second embodiment of the present invention. FIG. 3A is a flow chart of this system. FIG. 7B is a diagram showing the contents of the stack of this system, and FIG. 8C is an explanatory diagram relating to the movement of the stack.

The method of this embodiment will be described by taking a case where a stack (memory) is used for optimization as an example. Reference numeral 31 in FIG. 3A is a source program,
32 is an output text file optimized using the stack. The contents of the stack when the source program 31 is executed are shown at 33 in FIG.

The part 34 in the source program 31 is a local variable, and its value is stored in the stack (see FIG. 3).
(See (b)), the instruction corresponding to the movement of the stack accompanying the storage is the portion 35 (D
EC 0x02, XSP). Then, debug information related to stack movement is output to the output text file 3
2 is a portion 37 (-2) in the portion 36 (block ..., -2) in 2. This part 37 shows the difference between the start of the function and the stack position at the time of execution of the part 36.
That is, the part 37 indicates that the stack position (X ′) at the time when the part 36 is executed is −2 bytes from the stack position (X) at the beginning of the function (FIG. 3 (c)). 38).

As described above, the values of local variables are stored in the stack (see FIG. 3 (b)). The debug information attached to each local variable has a difference from the stack position at the head of the function to which the user belongs, as information indicating the position in the own stack. In other words, if the stack position at the beginning of the function is known, the contents of the stack can be known. Further, the source level debugger can know the current position of the stack by referring to the stack register (XSP).

Therefore, the stack position (X) at the beginning of the function can be known from the current position of the stack (XSP) and the difference from the beginning of the function at that time (X = XSP).
-(-2): See 38 'in Fig. 3 (c)).

From the above, since the stack position at the head of the function is obtained, it is possible to know the contents of the stack (location of the local variable) from the value and the offset value in the debug information of each variable. Yes, source level debugging is possible even for object files optimized using the stack.

FIG. 4 is a diagram showing a source level debug information output system according to the third embodiment of the present invention.

In this embodiment, as an application example of the second embodiment, a case where the contents of the stack change in the middle of a function will be described.

41 in the figure (a) is a source program,
42 is an output text file optimized using the stack. Part 43 (f in source program 41
uncl (a);) and part 43 '(funcl
(B);) indicates a function call with an argument, so the stack changes.

The parts of the output text file 42 corresponding to the parts 43, 43 'are parts 44, 44'.
Furthermore, parts 45 and 4 in the output text file 42
5'is information on the change of the stack. Here, in the present embodiment, the portion 45 is (block ..., -4) and the portion 45 'is (block ..., -6). When the stack changes in the middle of the function, the difference from the function head of the stack is output in the minimum block unit (part 46 (-4), part 46 '(-6)).

By doing so, the contents of the stack can always be known in the same manner as in the second embodiment, even if Go & Break is carried out at a certain point and stopped at once, instead of stepwise execution which is executed line by line. You can
You can also do source-level debugging on object files that are optimized using the stack.

Next, with respect to the fourth to sixth embodiments described below, an embodiment in which debugging is performed using the user debug information shown in FIG. 1 will be described. Therefore, in the following description, the user debug information output method will be particularly referred to.

FIG. 5 shows a fourth embodiment of the user debug information output method according to the present embodiment. The method of the present embodiment will be described by taking the case where stack movement information is output as an example. In the figure, 51 is a source program, 52 is an optimized output text file, and 55 is an image of the usage status of a stack used in the program. 5
The shaded area shown in 6 represents the area already used before this program is called. Arguments a and b passed to the program are stored in this area. To refer to these arguments, the difference with respect to the stack pointer at the time of reference is added (57 in the figure). Reference numeral 54 indicates the amount of movement of the stack with reference to the stack address at the beginning of the program. By using this information, the address of the target variable can always get a constant address by using the following formula even if stack operation is performed inside the program.

[0043]

[Equation 1] (Address of target variable) = (Address on output text file) + (Stack movement amount information) A specific description will be given below. 55 is an image of the stack used by the output text file, and XSP + shown in 57
0xE indicates the address of the variable a, and the movement amount of the stack pointer at this point is −0x0008 bytes (54). If the address of the variable a is applied to the above equation, a difference value of + 0x0006 is obtained.

[0044]

[Formula 2] (address of variable a) = (XSP + 0xE) +
(−0x00008) = (XSP + 0x0006) The value obtained by this calculation always shows the same value. 5 in the figure
3 represents the size of the stack. In this way, by acquiring the size of the stack required to realize the source program, it is possible to easily obtain information on the memory size required for the entire system.

FIG. 6 shows a fifth embodiment of the user debug information output system according to this embodiment. The system of this embodiment will be described by taking the case where variable allocation information is output as an example. In the figure, 61 is an output text file which is not optimized when the variable allocation information for the source program shown by 51 is added, and 62 is an optimized output text file. By obtaining the variable allocation information shown in 62, the variables deleted / generated as a result of optimization become explicit, and it is easy to understand the meaning of access to the memory or register appearing in the output text file. Become. For example, the 10th line of 61 substitutes the value of the argument a for the variable c.

FIG. 7 shows a sixth embodiment of the user debug information output system according to the present embodiment, and the system of this embodiment will be described by taking the case where an intermediate code is output as an example.
In the figure, 71 is an output text file obtained by optimizing the source program, and 72 is variable allocation information. 7
Reference numeral 3 denotes a comment obtained by replacing the variable allocation information with the register / memory in the output text file. Here, Rval is the return value of the program. By utilizing this information, the user does not need to consider the register / memory when grasping the contents of the output text file, and can do so only by looking at the comment. As a result, the time required to understand the contents of the output text file can be reduced.

[0047]

As described above in detail, according to the first aspect of the invention, the optimization processing means for optimizing the source program and the optimization of the source program correspond to the source program in block units. Since the debug information insertion means for outputting the block information as the source level debug information is provided, the source level debugging can be performed on the optimized object file. Therefore, the debugged object file can be used as it is on the application product, and the reliability of the object file is significantly improved.

According to the second invention, a stack pointer for optimizing the source program, block information for associating the source program in block units after the optimization of the source program, and the block information for each block. Since it has a debug information insertion means for outputting the amount of change of the stack pointer as source level debug information,
The contents of the stack pointer can be known, and source level debugging can be performed on the object file optimized using the stack pointer. Therefore,
The debugged object file can be used as it is on the application product, further improving the reliability of the object file.

According to the third aspect of the invention, by utilizing the user debug information, the user does not need to consider the register / memory when grasping the contents of the output text file, and only sees the comment. It will be possible. As a result, the time required to understand the contents of the output text file can be reduced.

[Brief description of drawings]

FIG. 1 is a block diagram showing a debug information output system according to the present invention.

FIG. 2 is a diagram showing a source level debug information output system according to the first embodiment of the present invention.

FIG. 3 is a diagram showing a source level debug information output system according to a second embodiment of the present invention.

FIG. 4 is a diagram showing a user debug information output system according to a third embodiment of the present invention.

FIG. 5 is a diagram showing a user debug information output system according to a fourth embodiment of the present invention.

FIG. 6 is a diagram showing a user debug information output system according to a fifth embodiment of the present invention.

FIG. 7 is a diagram showing a user debug information output system according to a sixth embodiment of the present invention.

FIG. 8 is a diagram showing a conventional debug information output method.

FIG. 9 is a diagram showing a conventional debug information output method.

[Explanation of symbols]

1 Source program 3 Compiler section Program language processing instruction group 5 Assembler source 7 Display section 9 Source level debug information analysis section 21, 31, 41 Source program 22 Optimized image 23, 32, 42 Optimized output text file 24 Unnecessary instruction of source program 25 Block information 26,26 'Source level debug image 27,27' Line currently being executed 33 Contents of stack 34 Local variable 35 Instruction corresponding to movement of stack 36,37 Stack Debug information about movement 38, 38 'Stack 51 Source program 52 Output text file 53 Size of stack required to realize source program 54 Stack movement information 55 Stack usage image 56 Source program Stack area that has already been used before execution 57 Stack reference 61 Output text file when optimization is not done 62 Variable allocation information when optimization is not done 63 Output text file when optimization is done 64 Variable allocation information at the time of optimization 71 Source program 72 Optimized output text file 73 Intermediate code 111 Source program 112 Output text file 113 Optimized output text file 114 Unnecessary instruction parts 115, 115 ' Debugging information 121 Source program 122 Optimized image of source program 123 Optimized output text file 124,124 'First argument reference part and description 125,125' Second argument reference part and description

Claims (3)

[Claims] 1. A source-level debug information output method for outputting source-level debug information corresponding to a source program, and generating an output text file which is a base of an object file for which source-level debugging is performed, wherein the source An optimization processing unit for optimizing a program; and a debug information inserting unit for inserting block information corresponding to the source program in block units as the source level debug information after the optimization of the source program. Characteristic debug information output method. 2. A source-level debug information output method for outputting source-level debug information corresponding to a source program and generating an output text file which is a base of an object file for which source-level debugging is performed, wherein the object A stack pointer for generating a file, block information that makes a correspondence with the source program in block units after optimization of the source program, and a change amount of the stack pointer for each block is inserted as the source level debug information. And a debug information inserting means for performing the debug information output method. 3. A syntax analysis unit that analyzes the syntax of a source program, an assembler source generation unit that generates an output text file based on the analysis, and a display unit that displays the generated output text file. A debug information output method, wherein the assembler source generation unit performs optimization processing means for optimizing the source program based on the analysis performed by the syntax analysis unit; and at least the output Inserting debug information that inserts information indicating the amount of stack movement in text line units of a text file and register / memory allocation information of variables used in the output text file into the output text file as user debug information. And a debug information output method comprising: