JP2001014185A - Compiling and debugging method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a compiling and debugging method for shortening a program execution time till a debug interruption point and a time required for a whole debug process. SOLUTION: A larger code size between an optimizing object code size and a non-optimizing object code size is set as function size information by a compiler A, an object program 108 is outputted from an object file output means 107, a debugger B loads an optimizing object code in the object program 108 to a target memory by an object program input means 109 and the non- optimizing object code corresponding to a function in the object program 108 is re-loaded to the same address of the target memory when the debug interruption point is set to the optimizing object code.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an optimized object code optimized at the time of compiling (hereinafter referred to as an optimized code) and a non-optimized object code (hereinafter referred to as an unoptimized code). )
At the same time, load those optimized codes into the target memory by the debugger first, and then reload the non-optimized code into the target memory only for the functions for which the debug breakpoint has been set by the debugger. The present invention relates to a compiling and debugging method capable of reducing a program execution time up to a point, and accordingly, a time required for an entire debugging process.

[0002]

2. Description of the Related Art A general flow when a user develops a program is shown in FIG. In FIG. 7, a source program is created in a language (step 701), and the source program is compiled (step 702).
Then, a link is made (step 703), and an object program 704 is created. Next, debugging is performed on the object program 704 using a debugger (step 705). If a part to be corrected is found by debugging (step 706), the source program is corrected (step 707), and the program is compiled and linked again, and then debugged.

In this program debugging process, it is very important to reduce the time required for debugging by the user in order to improve the development efficiency of the user. In debugging, it is not possible to perform step execution or tracing according to the meaning of a source program on an optimized program.

For example, Japanese Patent Laying-Open No. 10-133911 ("Debugger") proposes an apparatus for debugging a program that has been optimized by a compiler. In this device, the value of the variable at the debug interruption point is displayed in the same value as when the instruction is not rearranged by optimization. The execution of the unexecuted part that has been positioned is being performed.

[0005]

However, in this method, the value of a variable is not the same as that of an unoptimized program in the step execution after the debug interruption point. It is not possible with the currently proposed method to execute a program optimized in this way exactly as the meaning of the source program. In addition, the technology for optimizing compilers is becoming more and more complex year by year, and it is difficult to change the method of the debugger to approximate the meaning of the source program.

Therefore, when a user conventionally needs to perform debugging according to the meaning of a source program, debugging is performed using a program that is not optimized by a compiler. However, debugging with a program that does not perform optimization takes a long time to execute the program itself, so that the user's debugging time becomes longer.

The present invention has been made to solve the above-mentioned conventional problems, and can reduce the program execution time as compared with the case where all object codes are not optimized. It is an object of the present invention to provide a compiling and debugging method that can also reduce the time required for debugging.

[0008]

In order to achieve the above object, a compile and debug method according to the present invention comprises: inputting an optimized object code and a non-optimized object code generated during a compile process to a function size adjusting means; A first step of adjusting the respective code sizes of the optimized object code and the non-optimized object code to output the optimized object code and the non-optimized object code whose code size has been adjusted as an object program; In the above, when the optimized object code in the object program is loaded on the target memory and a debugging break point is set for the optimized object code, the set function is recognized and the Corresponding to that function Unoptimized object code, characterized in that it comprises a second step of reloading the same address on the target memory.

Therefore, the compiler adjusts the code size of the optimized object code and the non-optimized object code by the function size adjusting means during the compiling process, and adjusts the code size of the optimized object code by the object file output means. And the non-optimized object code are output to the debugger as an object program, and the debugger first loads the optimized object code on the target memory,
When a debug break point is set in the optimized object code, the object program input means receives an instruction to reload the non-optimized object code for the function for which the debug break point has been set, and outputs the non-optimized object code of the object program. Since the code is loaded into the target memory, the program execution time can be reduced as compared with the case where all object codes are not optimized, and the time required for the entire debugging process can be reduced accordingly. .

[0010]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Next, an embodiment of a compiling and debugging method according to the present invention will be described with reference to the drawings. FIG. 1 is a block diagram showing a configuration of a compiler and a debugger applied to the first embodiment of the compiling and debugging method of the present invention. Compiler A in FIG. 1 includes syntax analyzing means 101, line information creating means 102 for generating source debug information which is the correspondence between source line numbers and code addresses, and optimizing means 103 for optimizing codes such as replacing instructions. , Optimization means 1
03 with optimization code 104, optimization means 1
03, without optimization code 105 generated without going through
There are provided a function size adjusting means 106 for inputting these two codes and adjusting the code size of each code in function units, and an object file output means 107 for outputting an object program 108.

The debugger B applied to the first embodiment includes an object program input means 109 for reading an object program 108 which is a program to be debugged, a source level step execution for executing a step execution at a source program level. Means 11
0, a function input instructing unit 111 for requesting reloading of a code without optimization of a function for which a debug interruption point has been set. The emulator 112 or the simulator 113 is used as a target connected to the debugger B.

The function size adjusting means 106 performs processing by inputting the optimized code 104 output from the optimizing means 103 and the non-optimized code 105 not passing through the optimizing means 103. Note that the processes of the syntax analysis unit 101, the optimization unit 103, and the line information generation unit 102 are not directly related to the present invention, and thus description thereof is omitted.

Next, the operation of the first embodiment of the compiling and debugging method according to the present invention applied to the compiler A and the debugger B shown in FIG. 1 will be described. First, the compiler A generates two codes, an optimized code 104 and a non-optimized code 105, at the time of executing the compiling process. These two codes are adjusted by the function size adjusting means 106 so that the function size information is the same for each function. That is, the larger code size of the code with optimization and the code without optimization is set as the function size information.

The debugger B first stores the object program 1 thus generated on the target memory.
Load code with optimization in 08. When a debug break point is set for the optimized code, the set function is recognized, and the code without optimization corresponding to the corresponding function in the object program 108 is reloaded at the same address. As a result, the code other than the function for which the debug break point is set remains the optimized code,
Source debugging can be performed in a function in which a debug break point is set, and the program execution time up to the debug break point can be reduced.

FIG. 2 shows the contents of the function information table immediately before input to the function size adjusting means 106. The function information table includes a function name storage area 201, a function size storage area 202, a code size storage area with optimization 203, a code size storage area without optimization 204, a pointer 205 to a storage area of code 207 with optimization, It is composed of a pointer 206 to a storage area of the unencoded code 208. It should be noted that this table exists for the number n of functions.

FIG. 3 is a processing flow of the function size adjusting means 106. In FIG. 3, it is determined from the function information table whether there is an unprocessed function whose size is to be adjusted (step 301). If there is an unprocessed function, the corresponding function information is read from the function information table (step 302), and it is determined whether the code size of the corresponding function with optimization is the same as the code size without optimization (step 303). ).

If the result of this determination is that the code sizes are the same, the process returns to step 301 without doing anything. If the result of the determination in step 303 is that the code sizes are different, it is next determined whether or not the code size with optimization is larger than the code size without optimization (step 304).
As a result of this determination, if the code size with optimization is larger than the code size without optimization, the information of the code size storage area with optimization 203 is written into the function size storage area 202 of the function information table (step 305), and step 301 Return to

If the result of the determination in step 304 is that the code size with optimization is smaller than the code size without optimization, the information of the code size storage area without optimization 204 is written into the function size storage area 202 of the function information table ( Step 306), and return to step 301. If there is no unprocessed function in step 301, the object file output unit 107 outputs the code with optimization and the code without optimization and the function information table whose size has been adjusted as the object program 108, and ends.

Object program input means 109
The emulator 11 selectively selects the code with optimization or the code without optimization in the object program 108.
2 or to the target memory on the simulator 113. The function input instructing unit 111 instructs the object program inputting unit 109 to reload the code without optimization for the function for which the debug interruption point has been set.

FIG. 4 is an operation flow of the first embodiment in a debugging step. In FIG. 4, the debugger B first converts the code with optimization in the object program 108 into the emulator 112 or the simulator 11.
3 (Step 40)
1). Next, it is determined whether or not the program execution is specified (step 402). If the result of this determination is that program execution has been specified, it is determined whether a debug breakpoint has been set (step 403).

If the result of this determination is that a debugging breakpoint has been set, the set corresponding function name is recognized (step 404), and the code without optimization in the object program 108 corresponding to that function is re-created. The load is instructed to the object program input means 109 (step 405). According to the instruction, the object program input means 109 reloads the non-optimized code into the target memory of the emulator 112 or the simulator 113 (step 406). After the reloading is completed, the program execution is started (step 407).

If it is determined in step 402 that the program execution has not been specified, it is determined whether another process is to be performed (step 408). If another process is specified, another process 409 is performed, and the process returns to step 402. If no other processing is specified, terminate the debugger. Note that the other processing includes step execution, and the processing returns to step 402 after step execution. If the debug interruption point has not been set in step 403, the process moves to step 407, and the program execution is started. In the above description, the method of storing the function size has been described with reference to FIG. 2. However, it is apparent that the same effect can be obtained when the data is stored in another data structure in addition to the function unit.

Next, referring to FIGS. 4, 5 and 6, the first example when a certain C source is inputted as a specific example will be described.
The operation of the embodiment will be described. An object program is created by the compiler A. Next, the object program is input to the debugger B, and the code arrangement image of FIG. 5 is obtained by step 401 of FIG.
In FIG. 5, a code with optimization is stored in a target memory 501 and a code storage table with optimization 502, and a code without optimization is stored in a code storage table 503 without optimization.

FIG. 6 is an image of a code arrangement on the target memory for each step of FIG. When the setting of the debug interruption point is performed in step 403, steps 404, 405, and 406 are executed, and the layout image shown in FIG. 6 is obtained. When the debug break point 601 is set,
In step 404, funcC is recognized as the set function name, and in steps 405 and 406, the code 503 corresponding to funcC in the non-optimized code storage table 503 is set.
C is reloaded into the target memory 501. After that, the code in the target memory 501 is executed in step 407, and one type of debugging is completed.

As described above, in the first embodiment, when the source program of the object program is debugged, only the function for which the debug interruption point is set uses the code without optimization. In comparison, the program execution time can be reduced. As a result, it is also possible to reduce the time required for the debugging process which is generally performed a plurality of times.

The effect will be described below by taking an example. Here, as an example, a comparison of the execution times of code with optimization and code without optimization by a certain compiler shows that program execution speed is about 2.5 times faster with optimization than with optimization. . Next, the program execution time in the source debugging process will be calculated. When the source debugging process is started, the average number of times of debugging executed for each compilation is five.

The processing time required for compiling execution is as follows: two codes with optimization and two codes without optimization are output.
The object code generation process is about twice the conventional process,
Although the processing of the function size adjusting means is added, the other processing is the same as the conventional processing, so that the time required for the compiling process as a whole is about 1.5 times that of the conventional processing. Assuming that the number of modules constituting a program is 100 and the conventional compile time per module is 1 second, the compile time of all modules is 100 seconds in the past. 150 seconds.

Assuming that the program execution time of the code without optimization required in one debugging step is 5 minutes on average, depending on the program size, the execution of 5 debugging cycles would conventionally take 25 minutes. From the above description, 1/2.
5 of 10 minutes. Therefore, the time in the debugging process for one compilation is 12 minutes and 30 seconds in the present invention, compared to the conventional 26 minutes and 40 seconds, and the speed can be increased by about 2.2 times.

Generally, in the debugging step, as described above, the emulator 112 or the simulator 113 is connected to a debugger and used as a target. Since the program execution speed on the target is slower on the simulator, the effect of the first embodiment according to the present invention becomes remarkable when the simulator is used as the target.

[0030]

As described above, according to the present invention, an optimized object in which a code size is adjusted by adjusting each code size of an optimized object code and a non-optimized object code in a compile process in a compiler according to the present invention. The code and the non-optimized object code are output to the debugger as an object program. The debugger first loads the optimized object code on the target memory, and when an object break point is set in the optimized object code, the debugger stops. The non-optimized object code of the object program for the function for which the point has been set is reloaded to the same address in the target memory, so that the program execution time up to the debug interruption point can be shortened. all It is also possible to shorten the time required to.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration of a compiler and a debugger applied to a first embodiment of a compiling and debugging method according to the present invention.

FIG. 2 is an explanatory diagram showing the contents of a function size information table immediately before input to a function size adjusting means in the compiler of FIG. 1;

FIG. 3 is a flowchart showing a processing procedure of a function size adjusting means in the compiler of FIG. 1;

FIG. 4 is a flowchart showing a debugging process procedure in a compiling and debugging method according to the present invention;

FIG. 5 is a code layout image diagram of an optimized code and an unoptimized code in which an object program generated by the compiling and debugging method according to the present invention is input to a debugger and loaded into a target memory.

6 is an arrangement image diagram of a code without optimization on a target memory for each processing step in the flowchart of FIG. 4;

FIG. 7 is a flowchart showing a procedure for developing a general program.

[Explanation of symbols]

A: compiler, B: debugger, 101: syntax analysis means, 102: line information generation means, 103: optimization means, 104: code with optimization, 105: code without optimization, 106: ... function size adjustment means, 107 ...
... object file output means, 108 ... object program, 109 ... object program input means, 110 ... source level step execution means, 1
11 ... function input instruction means, 112 ... emulator,
113: Simulator, 201: Function name storage area,
202: Function size storage area, 203: Code size storage area with optimization, 204: Code size storage area without optimization, 205: Pointer to code storage area with optimization, 206: Code without optimization Pointer to storage area, 207: code with optimization, 208: code without optimization, 501: target memory, 502
... Code table with optimization, 503 ... Code storage table without optimization, 502A ... Code with optimization of funcA, 502B ... Code with optimization of funcB,
502C... FuncC optimized code, 503A... F
Unoptimized code of uncA, 503B... unoptimized code of funcB, 503C... unoptimized code of funcC,
601... Debug interrupt point setting.

Continuation of the front page (72) Inventor Eiji Shamoto 53-1 Kosugi-cho, Nakahara-ku, Kawasaki-shi, Kanagawa Prefecture 53 F-term in NEC Ic Microcomputer System Co., Ltd. 5B042 GA02 GA03 HH07 HH22 HH23 HH33 HH39

Claims (11)

[Claims] 1. An optimized object code and a non-optimized object code generated during a compile process are input to a function size adjusting means to adjust respective code sizes of the optimized object code and the non-optimized object code. A first step of outputting, as an object program, the optimized object code and the non-optimized object code whose code size has been adjusted; and loading the optimized object code in the object program into a target memory by a debugger. When a debug break point is set for the optimized object code, the set function is recognized, and the non-optimal object code corresponding to the function in the object program is reloaded at the same address on the target memory. No. Compiling and debugging method characterized by comprising the steps, a. 2. The compiler according to claim 1, wherein the compiler includes: a syntax analyzer; a line information generator configured to generate source debug information corresponding to a source line number and a code address; an optimization unit configured to optimize an object code; Function size adjusting means for inputting an optimized object code generated by the optimizing means and a non-optimized object code generated without passing through the optimizing means and adjusting the size of each object code in function units; 2. An object file output means for inputting an optimized object code, a non-optimized object code and a function information table adjusted by the function size adjusting means and outputting the function information table as an object program. How to compile and debug. 3. The function information table includes a function name recording area, a function size storage area, an optimized object code size recording area, a non-optimized object code size storage area, and an optimized object code storage area. 3. The compiling and debugging method according to claim 2, further comprising a pointer to a storage area of the non-optimized object code. 4. The object size output means outputs the object program from the object file output means when it is determined from the function information table that there is no unprocessed function whose object code size is to be adjusted. 3. The compiling and debugging method according to claim 2, wherein: 5. The function size adjusting means according to claim 1, wherein said optimized object code size is larger than said non-optimized object code size in said function information table, and said optimized object code size is stored in a function size storage area of said function information table. 3. The compiling and debugging method according to claim 2, wherein information of a storage area is written. 6. The function size adjusting means, if the optimized object code size is smaller than the non-optimized object code size in the function information table, stores the non-optimized object code in a function size storage area of the function information table. 3. The compiling and debugging method according to claim 2, wherein information of the size storage area is written. 7. The function designating means reloads a non-optimized object code in an object program corresponding to a set function name when a program breakpoint is set when program execution is specified. 3. The compiling and debugging method according to claim 2, wherein an instruction is given to said object program input means. 8. The method according to claim 2, wherein the function designating means performs another processing when the execution of the program is not specified and when it is specified to perform another processing.
Compiling and debugging methods described. 9. The compiling and debugging method according to claim 8, wherein said other processing includes step execution. 10. A debugger, comprising: a function input instructing unit for requesting reloading of a non-optimized object code of a function for which a debug break point has been set; and an object program inputting unit for reading the object program to be debugged. 2. The compiling and debugging method according to claim 1, further comprising: source level step executing means for performing step execution at a source program level. 11. The object program according to claim 1, wherein the optimized object code or the non-optimized object code in the object program is selectively loaded into a target memory on an emulator or a simulator by an object program input means. How to compile and debug.