JPS61264441A - Compiling system - Google Patents

Abstract

PURPOSE:To reduce the overhead phenomenon produced when a main program is processed by the direct in-line development of a logic part of a related subroutine program to the subroutine call area of the corresponding main program. CONSTITUTION:The #1 source program 24 serving as a main program and its related subroutine program 25 are stored in an external storage device 22. While an object program 26 of the machine word that performed the direct in-line development of the logic part of the program 25 to a prescribed area of the program 24 is stored in the device 22. Then the device 22 storing programs 24 and 25 and the device 22 storing the program 26 are connected to a compiler 21 respectively. While the device 22 storing a load module 27 and the device 22 storing the program 26 are connected to a linkage editor 23. In such a way, both the pre-processing and the after-processing can be omitted with a subroutine program.

Description

[Detailed Description of the Invention] [Field of Industrial Application] This invention relates to a pile processing method, and is particularly concerned with a source program written in a high-level language and equipped with a predetermined subroutine (function) call function. It relates to a compilation processing method for converting something into an object program written in machine language.

[Conventional technology]

FIG. q is a schematic diagram for explaining a conventional compilation processing method. In this diagram, (/1 is the compiler, (c) is the external storage device, and (3) is the linkage editor. And what is held in the external storage device -) are the fA, fB base programs. (+'l,
(71, /A, /B object programs (A), ('71) in machine language corresponding to these, and a load module +ffl created by editing the object program.

Figure 5 shows the load module +ff according to the above conventional method.
FIG. In this Figure 5, (?) is a raw program, (10) is a subroutine (function) program that is called by the raw program (ri), and (//) is a main program (de)K provided. subroutine (function) call statement, (/ko).

(/3), (Ha, are both ?Broutine (function)
In the logic processing section of the program (/Q),
(/2) is a preprocessing section for saving registers, importing parameters, etc., (/, 7) is a logic section for the original processing of a subroutine (function) program (/Q), (
C0 is a post-processing unit for restoring registers, returning parameters, etc.

Next, the operation of the above conventional method will be explained. The 1A, IB source program body 1s (t) stored in the external storage device (2) is subjected to a predetermined compilation process by the compiler (1), and is independently compiled into corresponding machine language 1A, 1B. Object program f program (41
, (ri) are generated. Here, the IA base program (RI is the so-called main program, whereas /B
It is assumed that the source program (!) is a certain predetermined subroutine (function) program.

Then, the machine language lA generated in this way.

The IB object programs (A) and (RI) are edited in a specified manner by a linkage editor (3), and a load module (1) having the configuration shown in FIG.
) is generated. In this Figure 3, the main program (
A branch is made to the subroutine (function) program (10) by the subroutine (function) call (//) in (d). Then, in the preprocessing section (/), preprocessing such as importing the required parameters sent from the main program (TE) and saving certain registers is performed. Next, the logic section (/3) ), processing operations are performed based on the inherent logical functions of this subroutine (function) program (10). Then, the post-processing section (
In lq), post-processing operations are performed to reset the function box to be sent back as a result of the processing operation based on the logical function, and to store the saved register. After this post-processing operation, a return is made to the subroutine (function) call (/l) of the main program (TE), and the operation by the main program (DE) is continued.

[Problem that the invention seeks to solve]

According to the conventional compilation processing method described above, branch operations are performed on subroutine (function) programs, which has the advantage of improving the efficiency of the memory size used. The main program that makes the call must manage various parameter settings, and the subroutine (function) program must perform pre-processing and post-processing operations in addition to processing operations based on the original logical functions. Because of this necessity, there is a problem in that there is a lot of overhead when executing the main program, which impedes improvement in its execution performance.

This invention was made in order to solve the above-mentioned problems, and the original logic part of the related subroutine (function) program is directly placed at the subroutine (function) call point of the corresponding main program. The purpose of this is to provide a compilation processing method that selectively enables inline expansion of files.

[Means for resolving intervening points]

The compilation processing method according to the present invention includes a subroutine (
This is for converting a source program in a high-level language with a function) call function into a corresponding object program in machine language, and inline expansion of the source program as a subroutine (function) program within the source program as the main program. In order to generate a desired object program, a predetermined instruction is given in the source program as the main program.

[For production]

According to this invention, only a source program as a subroutine (function) program to which a predetermined instruction has been given is selectively developed inline within a source program as a main program.

〔Example〕

Hereinafter, an embodiment of the present invention will be explained with reference to FIGS. 7 to 3. First, FIG. 1 is a schematic diagram for explaining an embodiment of the present invention.
(3) is the compiler used in this example, (here) is the external storage device, and (3) is the linkage editor.

What is held in the external storage device (co 2) is i/, l co source program (co a), (2! r),
This is a machine language object program (21,) as a result of the compilation process of the software, and a load module (Koku). Here, the l/source program (cog) is the main program, and the 12 source program (co3) is a predetermined subroutine (function) program related to this. Also, 1 machine language object program (26
) is the -U source program (ko, 8'') expanded inline at a predetermined location in the l/source program (tlI). Figure 2 shows these -/, -1 north programs (2 Figure 7 is an example diagram of an object program (Koro) in source program format. An example is shown in which the original logic part of the I-conce program (5) is expanded inline at a predetermined location in (2).

It is now assumed that a call is being made from the l/source program (2hiro) to the fcosource program (25), which is represented by FUNC(x,y) as a subroutine (function) program. The t2 source program (2r) is given the instruction Book@FUNC to the t2 source program (2r).
The original logic part of the above l/source program (
Compilation processing is performed such that inline expansion is performed in 2hiro). Further, when the above-mentioned FUNC instruction is not given, a branch instruction is created in the same way as in the conventional case. The 12th source program (3) instructed to be expanded inline as described above is retrieved from the external storage device (22) and merged at a predetermined location with the l/source program (00).

−/a in source program (2q) = FUNC(
Steps b and c) are replaced with the original logic part of the subroutine (function) program developed in the l co-source program. At this time, the variables (X .

y) is replaced by a certain predetermined constant (bpc).

Furthermore, if a certain constant (such as d) is used with different meanings in both the source program and the t2 source program (23), conflicts between them may occur. To avoid confusion,
The constant (dl) in the I concourse program (Koku) is changed to a unique expression such as d■FUNC, and the F U N C in this I,2 source program (2yo)
= x + y step is determined by a predetermined constant B =
t) + c. In this way, according to the embodiment of the present invention, the original logic part of a subroutine (function) program is expanded inline within the main program that requires it, and the ) Predetermined pre-processing and post-processing operations for programs are not required, and the number of automatic heads is reduced.

〔Effect of the invention〕

As described above, according to the present invention, by giving a predetermined instruction, a source program as a desired subroutine (function) program can be selectively expanded inline in a source program as a main program. That's what happened, again. The subroutine (
Since only the original logic part of the function (function) program is subject to the inline expansion, the number of heads automatically decreases, and the most convenient program generation is possible in terms of both memory usage efficiency and execution efficiency. It has the effect of being done.

[Brief explanation of drawings]

FIG. 7 is a schematic diagram for explaining an embodiment system of the present invention, FIG. 2 is an illustrative diagram of a source program in the above embodiment, and FIG. 3 is a source program of an object program generated in the above embodiment. An illustrative diagram in a program format, FIG. 7 is a schematic diagram for explaining this type of conventional example system,
FIG. 3 is a schematic diagram of a load module according to the conventional method described above. (,2/) is the compiler, and (here) is the external storage device. (23) is a linkage editor, (2g), (yuj) are 1/, -1 source program, (coro) is an object program, and (27) is a load module. In each figure, the same reference numerals indicate the same or corresponding parts.

Claims (2)

[Claims] (1) A compilation processing method for converting a source program in a high-level language with a subroutine call function into a corresponding object program in machine language, in which the source program as a subroutine program is inlined within the source program as the main program. A compiling processing method characterized in that the inline expansion is selectively enabled by giving a predetermined instruction in the source program as the main program in order to generate a desired object program by expansion. . (2) The compile processing method according to claim 1, wherein only the original logic section in the source program as the subroutine program is subjected to the inline expansion.