JP2002073371A - Program debugging method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To enable to debug an expanded function in a source level when a function is expanded in plural locations through optimization of a program. SOLUTION: A compiler 10 generates a leading address information table that is used for expanded functions and contains each leading address of functions expanded in plural locations through optimization of a program, a line address information table that consists of relative address per source statement line and has function names and table pointers of leading address information of expanded functions in a header, and if a function is expanded in plural locations, generates the line address information that consists of one address per source statement line and has table pointers to expanded function flags and line address information for expanded function, and a debugger 11 debugs a function expanded in lural locations in source level based on the above leading address information for expanded function, the line address information for expanded function and the line address information.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program debugging system including a compiler and a debugger.

[0002]

2. Description of the Related Art Generally, when debugging a program, a source program is debugged at a source level. To perform source-level debugging, the compiler generates debugging information. Debug information includes
One source line of the program has line address information corresponding to one code address. If there is a source line that is not registered in the line address information, the unregistered source line cannot be debugged at the source level, and the only way to perform debugging is to use the debugging method at the assembler code level.

In the debugging system at the assembler code level, it is necessary for the user to manage at least four items such as register management, memory management, stack memory operation management, and assembler code operation management. When it is estimated that it takes time, it takes about 40 hours, and it takes much time for debugging, which is a burden on the user.

[0004] Referring to FIGS. 7, 8, 9, 10, 11, and 12, a conventional program debugging method (Japanese Patent Laid-Open No.
289110) will be described. Note that the program conversion device will be described as a compiler, and the debug device will be described as a debugger.

The prior art shown in FIG. 7 (JP-A-10-289)
110) corresponds to an optimization other than the optimization of the function expansion, but is not related to the present invention. Therefore, the argument optimization unit 1052, the resource allocation unit 1053, the function information storage unit 7
031, variable information storage unit 7032, variable value acquisition unit 11
6. Variable value display unit 114, function call history display unit 11
This will be described with reference to FIG.

[0008] In the program debugging method including a conventional compiler and a debugger shown in FIG. 8, a compiler obtains a program from a program storage unit 101 in an internal representation conversion unit 104, and obtains an internal representation (a source line To the intermediate code generated at the stage of converting from to executable code).

The optimizing unit 105 includes an internal representation converting unit 104
Performs optimization processing on the internal representation generated by. In the optimizing unit 105 that performs the optimizing process, the function expansion optimizing unit 1051 that performs the optimizing process related to the function expands the contents of the called function at the position of the function call.

The internal representation optimized by the optimizing unit 105 is generated into an execution code by a code generation unit 106 and recorded in an execution code storage unit 102.

[0009] The debug information generation unit 107 associates the source line of the program with the address of the execution code on a one-to-one basis, and records it in the line address information storage unit 7034.
When the function is expanded, the function expansion optimizing unit 1051
Information regarding the function name, expansion position, and expansion range of the expanded function is recorded in the expansion function information storage unit 7033.

FIG. 12 shows a processing flow of the function expansion optimizing unit 1051 to be estimated.

In step 1101, a source line is obtained. In step 1102, it is determined whether or not it is a function call. If so, the flow branches to step 1103;

In step 1103, it is determined whether or not to expand the function at the function calling position. If so, the flow branches to step 1106; otherwise, the flow branches to step 1104.

In step 1104, the source line is advanced by one. In step 1105, it is determined whether or not the source line ends, for example, by EOF.
If it is not the source line end, the process branches to step 1101.

In step 1106, the function is expanded at the calling position. In step 1107, an expansion function table is created. In step 1108, function name registration is performed. In step 1109, a function expansion position is registered. In step 1110, a function expansion range is registered.

A debugger in a program debugging system including a compiler and a debugger shown in FIG.
The user inputs, for example, a line whose execution is to be stopped from the input unit 109, obtains an execution code from the execution code storage unit 102, and executes the code in the code execution unit 110.

The operation of the code execution unit 110 is monitored by the execution state monitoring unit 111 based on the debug information, the address and the source line of the execution code are acquired according to the execution state, and the acquired information is stored in the execution state storage. Recorded in the section 713.
The information recorded in the execution state storage unit 713 can be referred to by a user on a display, for example.

An example of expanded function debug information generated by a compiler in a program debugging system including a compiler and a debugger shown in FIG. 8 will be described with reference to FIGS. 9, 10, and 11. FIG.

Line: 216 shown in FIG.
In contrast to the case where the function composed of ne: 222 is called from Line: 13 of an arbitrary program, the function expansion optimizing unit 1051 stores the function called from the program in Line: 13 as “ A function is not generated, and the contents of the function are expanded at the call position of Line: 13. The expanded function information storage unit stores the function name, expanded position, start address, and end address of the expanded function. At 7033, it is recorded in the form shown in FIG.

An expansion function information storage unit 7033 shown in FIG.
It can be understood from the expansion position and the expansion range that each line of the function Line: 219 to Line: 221 has been expanded at the addresses 0x128 to 0x130, respectively.

Further, the relationship between the program line and the address of the generated execution code determined by the code generation unit 106 is recorded in the line address information storage unit 7034, for example, as shown in FIG.

The debugger debugs the expanded function based on the debug information shown in FIGS.
Since the address of Line: 13 in FIG. 10 is 0x128 and the start address of the development range in FIG. 11 is 0x128, the function in FIG.
It can be seen that it was developed at the position of.

[0022]

In the above-described processing, in order to increase the execution speed of a program, it is widely performed to optimize the execution speed when compiling a source program. As an optimization method for increasing the execution speed, when a function (subroutine) is called from a program, a method of expanding the contents of the function at a calling position instead of calling the function may be used.

When a function to be expanded to a calling position is called from a plurality of positions, the function is expanded to each of the plurality of positions. Therefore, for one source line of the function to be expanded, code addresses are generated at a plurality of expanded locations.

The compiler also generates debug information when compiling a source program to generate an execution code. The conventional row address information shown in FIG. 10 has a configuration in which one source address corresponds to one code address. The expansion function information shown in FIG. 11 also has a configuration in which one code address corresponds to one source line of the expansion function.

The conventional debug information does not have a structure in which a plurality of code addresses correspond to one source line. If there are a plurality of code addresses for one source line, the debug information is displayed. No local debug information is generated.

To debug a program at the source level, debug information is indispensable. However, if there is a location where debug information is not generated, there is a problem that the source level cannot be debugged at that location.

An object of the present invention is to solve the problem even when a function is expanded at a plurality of locations by optimizing a program.
An object of the present invention is to provide a program debugging method that enables debugging at a source level before an expanded function is expanded.

[0028]

According to the present invention, there is provided a program debugging system comprising a compiler and a debugger, wherein the compiler is adapted for an expanded function having each head address of a function expanded to a plurality of locations by optimizing a program. A head address information table is generated, and a function name of a function expanded at a plurality of locations by optimizing a program and a pointer of the expansion function start address information table are included in a header, and are configured with one relative address for one source line. A row address information table for an expansion function is generated, and when there is a function expanded at a plurality of locations by optimizing a program, the table has an expansion function flag and a pointer to the row address information table for the expansion function.
The debugger generates line address information composed of one corresponding address for a source line, and the debugger refers to the expansion function start address information table, the expansion function line address information table, and the line address information to generate a plurality of line addresses. It is characterized in that the function expanded in the location can be debugged at the source level.

[0029]

Next, an embodiment of the present invention will be described with reference to the drawings.

FIG. 1 is a block diagram showing an embodiment of the program debugging system of the present invention. The program debugging method shown in FIG.
And a program storage unit 101 for storing a program;
An execution code storage unit 102 stores execution code, a debug information storage unit 103 stores debug information generated at the time of compiling, and an execution state storage unit 113 stores an execution state of a program.

The compiler 10 includes an internal representation conversion unit 104
Optimizing unit 1 including a function expansion optimizing unit 1051 inside
05, a code generation unit 106, and an expansion function information generation unit 1
The debugger 11 includes an input unit 109 and a code execution unit 1.
10 and an execution state monitoring unit 111 to which an expansion function processing unit 112 is added.

The debug information storage unit 103 stores an expansion function information storage unit 1033 for storing information corresponding to functions expanded at a plurality of locations, a source line and an address associated with each other, and further, the expansion function information storage unit 1033. A row address information storage unit 1034 for storing row address information to which information that allows reference to be added is added.

The execution state storage unit 113 stores, in addition to the execution state of the program, the execution states of the functions expanded at a plurality of locations.

Next, the operation of the embodiment of the present invention will be described.

FIG. 2 shows a processing flow of the expansion function information generation unit 108, and FIG. 3 shows a processing flow of the expansion function processing unit 112. FIG. 4 shows a configuration diagram of the row address information storage unit 1034 as an example of data retention in the row address information storage unit 1034 in the debug information storage unit 103. The expansion function information storage unit 103 in the debug information storage unit 103
As a data holding example of No. 3, FIG. 5 shows a configuration diagram of an expansion function row address information table, and FIG. 6 shows a configuration diagram of an expansion function head address information table.

The internal representation conversion unit 104 and the optimization unit 1
05, function expansion optimization unit 1051, code generation unit 10
6. Debug information generation unit 107, program storage unit 10
1. The execution code storage unit 102, the input unit 109, the execution state monitoring unit 111, and the code execution unit 110 have the same configuration as the conventional one. Since the processing of the same configuration is the same as the conventional processing, detailed description is omitted.

In the program debugging system shown in FIG. 1 comprising the compiler and the debugger of the present invention, the compiler 10 first obtains a source program from the program storage unit 101 in the internal representation conversion unit 104, and Convert to internal representation (intermediate code generated at the stage of converting source lines to executable code).

The internal representation is generated in an execution code in the code generation section 106 and assigned an address. For each source line of the program, the debug information generation unit 107 records the corresponding address together with the source line number in the line address information storage unit 1034. The information recorded in the row address information storage unit 1034 is hereinafter referred to as
This is called “row address information”.

When one line of the program source is expanded not by the function expansion optimizing unit 1051 into the execution code of "call a function" but by the execution code of the processing contents of the function (the processing is executed at the position where the function is called). The function whose contents are expanded is hereinafter referred to as “expansion function”), and the function expansion optimizing unit 1
In step 051, information on the function name, source line, expansion position, and expansion range of the expansion function is passed to the expansion function information generation unit 108 via the debug information generation unit 107. The expansion function information generation unit 108 transmits the passed information to the expansion function information storage unit 1.
Record at 033. The information recorded in the expansion function information storage unit 1033 and the row address information storage unit 1034 is hereinafter referred to as “debug information”.

In the debugger 11, a user who is a debugger operator (hereinafter, referred to as a user) uses an input unit 109 to associate a source line number with a break condition (for example, stop execution immediately before executing a source line). When you do
If the input line number corresponds to the expansion function, the expansion function processing unit 112 determines the address corresponding to the input line number and the break condition based on the debug information.
Register at 11.

The execution state monitoring unit 111 monitors the execution state based on the registered address and the break condition, and acquires the address and the source line of the execution code according to the execution state.
It is recorded in the execution state storage unit 113.

When the user wants to check debug information (for example, source line, code, code address, etc.) at the time of debugging, the information recorded in the execution state storage unit 113 is displayed on a display or the like. Information such as the address of the user.

If the input line number does not correspond to the expansion function, the source line number and the break condition input by the user through the input unit 109 are stored in the line address information storage unit 103.
4, the debugger 11 registers the address corresponding to the input line and the break condition in the execution state monitoring unit 111 in the same processing as the conventional one, and continues the same processing as the conventional debugger.

FIG. 2 is a processing flowchart of the expansion function information generation unit 108.

When the function name, source line, expansion position, and expansion range of the expanded function are passed from the debug information generation unit 107, the expansion function information generation unit 108
Then, the expansion function flag is registered in the row address information storage unit 1034. In step 202, it is determined whether or not the function has already been expanded. If so, the flow branches to step 203; otherwise, the flow branches to step 206.

In step 203, the expansion function start address information table pointer 502 is obtained from the expansion function row address information table shown in FIG. Step 2
In step 04, the head address of the expanded position is registered in the expansion function start address information table shown in FIG. In step 205, the expansion function row address information table pointer 403 is registered in the row address information recording unit 1034.

In step 206, a row address information table for expansion function shown in FIG. 5 is newly created in the expansion function information storage unit 1033 for an arbitrary function. At step 207, the created function name 50 is added to the table.
Register 1.

In step 208, it is determined whether or not there is an expansion function in the expanded function. If so, in step 212, the expansion function information generation unit 108 is recursively called, and the same processing is performed. Otherwise, the process branches to step 209.

In step 209, one line of relative address information (source line number n: corresponding relative address n) 503 is registered in the line address information table for expansion function.
In step 210, the source line is advanced by one line. In step 211, it is determined whether or not the source line ends, for example, EOF.
(End Of File: symbol indicating the end of the file)
Then, the process branches to step 213 if the source line ends.

In step 213, the expansion function start address information table shown in FIG. 6 is newly created. In step 214, the expansion function start address information table pointer 502 is registered in a predetermined expansion function row address information table shown in FIG. In step 215, the start address 601 of the place where the function is expanded is registered in the expansion function start address information table shown in FIG.

FIG. 3 is a processing flowchart of the expansion function processing unit 112.

In step 301, a source line number and a break condition are input from the input unit 109 in the same manner as in the prior art. In step 302, the input source row number is searched for the source row number in the row address information storage unit 1034, and the address information (source row number n: corresponding address n) 401 of the target row is obtained.

In step 303, it is determined whether or not the function is an expanded function based on whether or not there is an expanded function flag 402. If so, the flow branches to step 306; otherwise, an address is obtained in step 304. Step 30
5, the execution state monitoring unit 11
Register 1 and end.

In step 306, the row address information table pointer 403 for the expansion function is obtained from the row address information storage unit 1034. In step 307, the expansion function start address information table pointer 502 is obtained from the expansion function row address information table shown in FIG.

In step 308, it is determined whether or not the inside of the function is a further expanded function.
The process branches to step 06, otherwise to step 309 to obtain the corresponding relative address from the expansion function row address information table.

In step 310, the start address 601 is obtained from the expansion function start address information table shown in FIG.
Is obtained. In step 311, the starting address +
The real address and the break condition obtained by the relative address are registered in the execution state monitoring unit 111.

In step 312, the process proceeds to the next start address (n + 1). In step 313, it is determined whether or not the head address information table is completed. If not, the process branches to step 310, and if so, the process ends.

FIG. 4 is a configuration diagram of the row address information storage unit 1034. Address information (source line number n: corresponding address n) 401 is recorded in a row other than the expanded function as in the related art. In the line where the function is expanded, the expansion function flag 402, the source line number, and the expansion function line address information table pointer 403 are recorded.

The expansion function information storage section 1033 is composed of an expansion function row address information table and an expansion function head address information table.

FIG. 5 is a configuration diagram of a row address information table for an expansion function. At the beginning of the table, an expansion function name 501 and an expansion function start address information table pointer 502 are recorded. Next, relative address information (source line number n: corresponding relative address n) 50
3 is recorded.

FIG. 6 is a configuration diagram of the expansion function start address information table. The table records the start addresses 601 at a plurality of locations where one function is expanded.

The expanded function row address information table and expanded function start address information table are generated for each type of expanded function.

According to the present invention, the table size is obtained by having the addresses recorded in the row address information table for the expansion function as relative addresses and having each head address of the position where the function is expanded in the head address information table for the expansion function. Has been reduced.

When the address of the row address information for the expansion function is not provided as a relative address, the number of addresses corresponding to one source line is equal to the number of expanded locations. For example, if a function of 20 lines is expanded to 30 places, if one source line and one address are one item,
(Rows) × 30 (locations) = 600 (items). If the line address information for the expansion function is stored as a relative address, and each head address of the position where the function is expanded is stored in the head address information table for the expansion function, 20 (line) +3
0 (start address) = 50 (items), 1
/ 12 items.

According to the present invention, the source program after the expansion of the function is performed at the level of the source program,
Instead of the user setting a breakpoint on the source line, the user sets a breakpoint on the source line for the source program before the function expansion is performed, and Debugging can be performed at a level, and debugging can be performed without making the user aware that the function has been expanded internally.

Further, according to the present invention, even if the expansion of one function is expanded to arbitrary plural places, the structure of the debug information is taken into consideration in advance that the function is expanded to plural places. A breakpoint can be set at the source level for a function expanded in multiple places.

[0067]

As described above, in the program debugging system according to the present invention, even when a function is expanded to a plurality of places by program optimization, the expansion is not possible in the conventional program debugging system. This allows debugging at the source level before the expanded function is expanded.

In the conventional program debugging method, when a function is expanded at a plurality of locations, the row address information of the expanded function does not correspond to the expanded function. From such line address information, an address corresponding to the source line of the expanded function cannot be extracted, and therefore, debugging at the expanded source level cannot be performed.

In the prior art, when debugging at the source level is not possible, there is a method of performing debugging at the assembler level. In this case, register management, memory management,
It is necessary for the user to manage at least four items, such as stack memory operation management and assembler code operation management. If it is estimated that one item requires 10 hours per debug, about 40 hours are required. In the debugging method, since debugging at the source level is possible, there is no need for the user to manage the above four items.

[Brief description of the drawings]

FIG. 1 is a configuration diagram showing an embodiment of a program debugging system of the present invention.

FIG. 2 is a processing flowchart of an expansion function information generation unit.

FIG. 3 is a processing flowchart of an expansion function processing unit.

FIG. 4 is a configuration diagram of a row address information storage unit.

FIG. 5 is a configuration diagram of a row address information table for an expansion function.

FIG. 6 is a configuration diagram of an expansion function start address information table.

FIG. 7 is a configuration diagram showing a conventional program debugging method.

FIG. 8 is a configuration diagram showing a conventional program debugging method.

FIG. 9 is a diagram showing an example of a function that is expanded in a compiler optimizing process;

FIG. 10 is a configuration diagram of a row address information storage unit.

FIG. 11 is a configuration diagram of an expansion function information storage unit.

FIG. 12 is a processing flowchart of an expansion function information storage unit.

[Explanation of symbols]

 Reference Signs List 10 compiler 11 debugger 101 program storage unit 102 execution code storage unit 103 debug information storage unit 104 internal expression conversion unit 105 optimization unit 106 code generation unit 107 debug information generation unit 108 expansion function information generation unit 109 input unit 110 code execution unit 111 Execution state monitoring unit 112 Expansion function processing unit 113,713 Execution state storage unit 114 Variable value display unit 115 Function call history display unit 116 Variable value acquisition unit 401 Address information 402 Expansion function flag 403 Expansion function row address information table pointer 501 Expansion Function name 502 Expansion function start address information table pointer 503 Relative address information 601 Start address 1033, 7033 Expansion function information storage section 1034, 7034 Row address information storage section 1051 Function Expansion optimization unit 1052 Argument optimization unit 1053 Resource allocation unit 7031 Function information storage unit 7032 Variable information storage unit

Claims (6)

[Claims] 1. A program debugging method comprising a compiler and a debugger, wherein the compiler generates an expanded function start address information table having each start address of a function expanded at a plurality of locations by optimizing a program, A row address information table for an expansion function which has a function name of a function expanded at a plurality of locations by optimization of a program and a pointer of the head address information table for the expansion function in a header and has one relative address for one source line. When there is a function expanded at a plurality of locations by optimizing a program, it has an expansion function flag and a pointer to the expansion function line address information table, and has one corresponding address for one source line. Generating line address information comprising: A program debugging method characterized in that a function expanded in a plurality of locations can be debugged at a source level by referring to a head address information table for expansion function, a line address information table for expansion function, and line address information. 2. The development information start address information table, the expansion function line address information table, and the line address information are generated at the time of compilation and stored in a debug information storage unit as debug information. 2. The program debugging method according to 1. 3. The user according to claim 1, wherein a break condition can be set by a user for a source line of the source program in a state before expansion of the function expanded at the plurality of locations. Program debugging method. 4. A program debugging method using a compiler and a debugger, wherein the compiler generates a development function start address information table having respective start addresses of functions expanded at a plurality of locations by optimizing the program, The expansion function row address information table having a function name of a function expanded at a plurality of locations by the optimization and a pointer of the expansion function start address information table in a header and having one relative address for one source line is provided. When there is a function generated and expanded at a plurality of locations by program optimization, it has an expansion function flag and a pointer to the expansion function line address information table, and is configured with one corresponding address for one source line. Generated line address information, and the debugger generates A program debugging method, wherein a function expanded at a plurality of locations can be debugged at a source level with reference to the expansion function start address information table, expansion function line address information table, and line address information. 5. The program debugging method according to claim 4, wherein said expansion function start address information table, expansion function line address information table, and line address information are generated at the time of compilation. 6. The break-down condition according to claim 4, wherein a break condition can be set by a user for a source line of the source program before expansion of the function expanded at the plurality of locations. How to debug programs.