JPH05120025A - Inline development method for source program - Google Patents

Abstract

PURPOSE:To provide the inline development method of a source program, which executes the inline development of the source program by means of a linkage editor for improving the execution speed of a whole program composed of the plural source programs. CONSTITUTION:The source programs 1, 2, 3, 4 and 5 are compiled and an object module 7 with debug information is generated. Then, they are linked with the linkage editor 8. At that time, the reference relation of the source programs 1, 2, 3, 4 and 5 is analyzed. The source program which is referred to only from one source program is inline-developed in the source program being a reference source and an optimized new source program 10 is prepared.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for inline expansion of a source program, and more particularly, to a source of a plurality of object modules by analyzing a relationship between a plurality of object modules by a linkage editor for creating an execution type load module. Also, the present invention relates to an inline expansion method of a source program for expanding a plurality of source programs inline to make the program faster in execution speed than the current program.

[0002]

2. Description of the Related Art Conventionally, an inline expansion method of a source program for increasing the execution speed of this type of program has been prepared by an inline expansion statement as a grammar of a compiler so that a user can easily describe it in the source program. There was a method and a method of inline expansion that was automatically analyzed by the optimization function of the compiler itself, or a method of inline expansion of a source program by an optimization tool that has a source program inline expansion function.

[0003]

According to the above-described conventional inline expansion method for a source program, when the compiler attempts to perform the inline expansion, the compiler can optimize only within one source program. There is a problem that the expanded sentence must be designed by the user from the beginning. There are some source program optimization tools that can support programs created by multiple source programs, but you can either generate dedicated information from the compiler, or you can use the optimization tool itself to make it equivalent to the compiler. There is a drawback that it cannot be processed unless the source analysis information of is generated, and that information is not information used for other purposes, and there is only a short function up to the function of generating the source program. It also has the drawback of not having a function to generate.

An object of the present invention is to eliminate such problems of the prior art and to provide an inline expansion method of a source program which can be optimally expanded inline at the same time as linking.

[0005]

The inline expansion method of a source program as a first solution of the present invention for solving the above problems is to translate individual source programs from a plurality of input source program data groups. Then, a compiler step for generating the processing information for the debugger and the object module data as the processing information for the linkage editor from the constituent elements of the source program data, and the load module data by combining the plurality of object module data groups At the same time, when it is determined that one of the object module data groups is referenced only by one of the other object module data groups, the source program data of the referenced side is Source program on the referencing side And inlined in the data, characterized in that it comprises a linkage editor step of creating a new source program data.

A method for inline expansion of a source program as a second solution means of the present invention for solving the above-mentioned problem is the new solution created by inline expansion of the linkage editor step to the first solution means. Compiling the source program data to generate new object module data having optimal code.

A source program inline expansion method as a second solution means of the present invention for solving the above-mentioned problem is that the first solution means is to obtain an optimum code from new object module data having the optimum code. It is characterized by including a linkage editor step for generating new load module data having.

[0008]

According to the inline expansion method of the source program of the present invention, the linkage editor generally refers to the output information of the compiler which the debugger used when the program developer confirms the execution of the program to obtain the source image information. Thus, in addition to the function of linking a plurality of object module data groups, which is the original function of the linkage editor, to create load module data, the CALL /
By analyzing the CALLER relationship, it is possible to inline a multi-source program data group.

Further, since the work of making a program into executable load module data is a work that must be performed without fail, it is characterized in that the source program can be optimally inline-expanded at the same time as linking.

Furthermore, the present invention of the second and third solving means is not limited to simply generating the source program data by inline expansion, but by recompiling and linking the newly generated source program. It has a function of generating the object module data and the load module data which are the optimum code, and operates so that the stage can be selected.

[0011]

Embodiments of the present invention will be described below with reference to the drawings. FIG. 1 is a block diagram showing the processing sequence of an embodiment of the present invention. The processing of the present invention in FIG. 1 is performed by programs 1, 2, 3, 4, which are source programs A, B, C, X, Y created by the user.
5 is input to the compiler 6. Object modules A, B, C, X, and Y, which are machine language instruction type programs in which programs 1, 2, 3, 4, and 5 are translated from the compiler 6 and are represented by relative addresses. 7 is output. The linkage editor 8 uses the object module group 7 to combine the object modules, and further obtains a designated program by combining symbols between the modules.
A load module 9, which is a program code that can replace, delete, and add a segment, and gives an overlay function to a designated module to extract it from the main storage device, and outputs an output source program 10. .. 2 is a program structure analysis mechanism showing a part of the processing contents of the linkage editor 8, and FIG. 3 is a flow chart of an inline expansion mechanism showing a part of the processing contents of the linkage editor 8. In the above processing sequence, the processing operation of the inline expansion method of the programs 1, 2, 3, 4, and 5 will be described below with reference to FIGS.

The compiler 6 uses the programs 1, 2, 3,
4 and 5 are translated, and the corresponding object modules A, B, C, X and Y are output. At this time, debug information such as statement number information / name tag information necessary for performing a program execution test with the debugger is also output. Next, the linkage editor 8 performs a link process from the object module group 7 output from the compiler 6 to generate a load module 9. Further, in the process, the linkage editor 8 inputs the input object module group 7
From the CALL of each object module shown in FIG.
The relation A1 can be discriminated and determined, and all the sub-object module groups referred to by the main object module A can be combined. For example, the object module A having the definition name "A" refers to the sub-object modules B, X, and Y, and the sub-object module B refers to the sub-object module C. Further, the sub-object module C does not refer to any other object module, and the sub-object module Y refers to the sub-object module X. Along with this link, the program structure analysis mechanism A2 seeks the CALLER relation A3 of the object module, which indicates by which module each external definition name is referenced. Reference source is 1 in CALLER relation A3 of object module
If there is only one, it is determined that the source program of the referenced sub-object module can be inline-expanded to the parent source program. In this example,
Since the source program C is referenced only by the source program B and the source program B is referenced only by the source program A, it is determined that the source programs B and C can be expanded inline in the source program A in stages. Similarly, since the source program Y is referenced only by the source program A, the source program Y
Is determined to be possible for inline expansion to the source program A.

However, since the source program X is referred to by the source program Y and the source program A, it is determined that the inline expansion of the source program X is not possible.

The determination conditions made here are used for the determination in step B1 in FIG.

In FIG. 3, assuming that the source program on the referencing side has a shallow nest and the source program on the referencing side has a deep nest, the source on the side referred to as an internal subroutine in the main source program on the referencing side. It shows a method of arranging programs and performing inline expansion of source programs.

In step B1, it is determined whether or not the inline expansion is possible, and in step B2, if the description languages of the two source programs having the reference relationship are not the same language, the program description grammars are different. Since the source programs cannot be combined as they are, inline expansion is not possible and this process ends without performing inline expansion. From step B2, the process of converting a deeply-nested source program into the writing of an internal subroutine, the overlap of external reference names in two source programs, and the definition when only one source program has an external reference definition statement Sentences are deleted or transferred, combined as one source program, and converted into a consistent description. Step B3 is a process for reading the two source programs themselves to be combined for work, and step B4 is a process for reading debug information in order to quickly identify the name / sentence numbers used in the two source programs to be combined. Is. Steps B5 and B6 are processing for deleting an external reference definition statement in a deeply-nested source program when two source programs have the same external reference name.
Steps B7 and B8 are processing for moving the external reference name definition statement in the deeply-nested source program to the shallowly-nested source program when there is a single external reference name in either of the two source programs.
Step B9 is a process of rewriting the writing portion of the deeply-nested source program into a subroutine type, and step B10 is an inline expansion of two source programs to combine them into one source program D1.
This is the final output process.

FIG. 4 shows an example of application of the above embodiment.
Will be described below with reference to. Note that FIG. 4 also shows a partial flowchart of the processing contents of the linkage editor 8.

First, in step C1, a selection is made as to whether to finish by creating only the source program D1 generated in step B1 or to compile the created source program D1 and further create an object module D2. When creating the object module D2, the compiler is activated (step C2) so that the generated source program D1 is input and translated, and the source program is compiled to control the generation of a new object module D2. ..

Further, after the above processing, in step C3 the object module D2 to the load module D3 are loaded.
Select whether to generate. When creating a load module, the linkage editor is activated (step C4) so that a new object module D2 is input and linked, and the load module is controlled. In this way, a new optimized source program that is expanded inline with a single link operation, a new object module is created from the optimized source program, and a load module optimized from the object module is created. Create and control.

[0020]

As described above, according to the present invention, a linkage editor is optimally inline-expanded with a link from a plurality of source programs to create a new source program, and the new source program is further compiled. With, you can create optimized object code that runs faster. Moreover, it also has the effect of simplifying a program with a complicated structure composed of multiple subroutines. In addition, it is possible to continuously compile and link from a new simplified source program to create an optimally coded object module and load module at the same time.

[Brief description of drawings]

FIG. 1 is a processing block configuration diagram of an embodiment of the present invention.

FIG. 2 is a diagram showing a program structure analysis mechanism showing a part of the processing contents of a linkage editor 8.

FIG. 3 is a flowchart of an inline expansion mechanism showing a part of the processing contents of the linkage editor 8.

FIG. 4 is a flowchart of a next processing control unit showing a part of processing contents of a linkage editor 8.

[Explanation of symbols]

 1, 2, 3, 4, 5 Input source program 6 Compiler 7 Object module 8 Linkage editor 9 Load module 10 Output source program

Claims (3)

[Claims] 1. An individual source program is translated from a plurality of input source program data groups, and debugger processing information and object module data as linkage editor processing information are obtained from the constituent elements of each source program data. The compiler step of generating and the load module data are generated by combining the plurality of object module data groups, and one of the object module data groups is referred to only by one of the other object module data groups. If it is determined that there is not, a linkage editor step that creates a new source program data by inlining the referenced source program data in the referenced source program data is included. Features Inline expansion method of source program. 2. The linkage editor step includes a step of compiling the new source program data created by inline expansion to generate new object module data having optimum code. Inline expansion method of the source program. 3. The inline expansion method for a source program according to claim 1, further comprising a linkage editor step of generating new load module data having an optimum code from new object module data having the optimum code.