JP2000132405A - In-line expansion processing device and method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To increase the in-line expansion processing speed of a library function by reading the object code of a function out of a library and outputting the object code in place of a function call code to perform the in-line expansion. SOLUTION: A source program is read by a program input means 21, decomposed into tokens by a token analysis means 31 and undergoes the parsing by a parsing means 32 to be decomposed into expressions. Then an object code generation means 41 generates the codes corresponding to every expression, and these object codes are outputted to a file by a result file output means 51. At the same time, the call expression of a library function is detected by a library function call detection means 33. Then the object code of the library function is read out of a library by a library function object code extraction means 23 and directly outputted to a file.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to an inline expansion processing method and apparatus, and more particularly, to an inline expansion processing method and apparatus in a compiler that inputs a source program and generates object code.

[0002]

2. Description of the Related Art An inline expansion processing method is known as one of the optimization methods of a compiler. This inline expansion processing method is an optimization method for improving the execution speed of an object generated by a compiler, and expands the contents (code) of a function to be called to a calling place. 2. Description of the Related Art Conventionally, various studies have been made on an inline expansion processing method on the premise that a function to be subjected to inline expansion inputs a source described in C language.

[0003] With the increase in software scale, the number of cases where general-purpose functions are registered as libraries has increased, and the demand for inline expansion processing of library functions without the above-mentioned C language source has increased.

Japanese Patent Application Laid-Open No. H10-31591 discloses a function inline expansion apparatus which enables inline expansion of functions existing in different compilation units.
As shown in FIG. 1, the function call finding means (S12) determines whether a function call exists in a plurality of object programs, and if so, creates a function call information table, and the function definition finding means (S13) The function definition of the function call stored in the function call information table is searched, a function definition table (T2) is created, the size of the corresponding function and the object of the function are copied, and the prologue / epilogue removal means (S14) The function object stored in the function definition table T2 is subjected to removal of unnecessary prologues and epilogues by inline expansion, and the function inline expansion means (S1
5) refers to the function call table for the function stored in the function definition table, embeds the object stored in the function definition table at the function call location, deletes the function call instruction, and changes the reference address changing means (S16). ) Calculates the jump instruction and the jump destination address if the function called by the function inline means includes a jump instruction that straddles the inline function, because the relative address between the jump instruction and the jump destination changes due to inline expansion. To correct. This inline expansion apparatus performs inline expansion processing of a function by a linker for an object generated by a compiler, and can conceptually also perform inline expansion of a library function.

[0005]

However, the above-described inline expansion processing device does not disclose how to solve the change of instruction addresses before and after inline expansion at the time of linking. When the linker performs inline expansion (embedding code) of a library function, the address of all instructions and all symbols must be changed after embedding the code. This is not realistic.

Further, as shown in FIG. 10, there is a compiler (translation program) itself having a function of a library function and enabling inline expansion of the library function. That is, referring to FIG. 10, source input means (S8), library function call finding means (S9), and library function inline expansion means (S1)
0), code generation means (S11), and a library function storage table (T1).

However, since the function of the library function is provided in the compiler itself, when the function of the library function changes, the compiler itself must also be changed.

Further, a library function created by a user of a compiler (translation program) cannot be expanded inline because the compiler itself cannot have the function in advance. Thus, FIG.
Is not sufficient as an inline expansion processing method for library functions.

SUMMARY OF THE INVENTION Therefore, the present invention has been made in view of the above problems, and has as its object to enable inline expansion of all library functions in a compiler and to speed up inline expansion processing of library functions. It is to provide a processing device and a method.

[0010]

According to the present invention, there is provided a method for performing inline expansion in a compiler for inputting a source program and generating object code, wherein the syntax of the input source program is a function call. In this case, it is determined whether or not the function name is registered in a library. If the function name is registered in the library, the object code of the function is read from the library and output as an object code to perform inline expansion.

[0011]

Embodiments of the present invention will be described. FIG. 1 is a diagram illustrating a configuration of a compiler device according to an embodiment of the present invention. Referring to FIG. 1, in one embodiment of the present invention, when the command input means (22) requests inline expansion of a library function,
The library function call detection means (33) determines whether or not the call function name recognized by the syntax analysis means (32) is a library function name.

When a call to a library function is detected,
Library function object code extraction means (23)
Searches the object code storage position of the function from the list of symbols in the library, and reads the object code of the function according to the searched information.

The result file output means (51) directly outputs the code of the corresponding function to a result file. Thus, the inline expansion processing of the library function is enabled.

According to a preferred embodiment of the present invention, a means (33) for judging whether or not a syntax obtained by parsing a source program is a function call, and a function name when the syntax is a function call. A library including a list and the object code of the function is input, and it is checked whether the function name is registered in the library. If the function name of the function call is registered in the library, the library Means (23) for searching the object code storage location and reading the object code of the function according to the searched information; and means (51) for outputting the read object code to a file. The function can be realized by the program executed by the program. in this case,
The present invention can be implemented by recording the program on a recording medium, reading the program from the storage medium to a main memory by a computer, and executing the program.
The library is provided independently of the compiler, and functions such as additions and changes in the library can be freely performed.

In the present invention, the inline expansion processing is performed in a compiler that generates an object code in a state where addresses of all instructions and all symbols are not determined, so that the speed of the inline expansion processing is increased. On the other hand, when the inline expansion processing is to be performed by the linker as in the conventional inline expansion processing apparatus shown in FIG. 11, the addresses of all instructions and all symbols that have already been determined must be changed. As described above, the processing time required for this is about twice as long as when the inline expansion processing is not performed.

[0016]

Embodiments of the present invention will be described with reference to the drawings. FIG. 1 is a diagram showing the configuration of one embodiment of the present invention. Referring to FIG. 1, one embodiment of the present invention includes a control processing unit 1 for performing the entire processing, an input unit 2, a source analysis unit 3, a conversion unit 4, and an output unit 5. I have.

The input means 2 includes: a program input means 21 for inputting a source program to be translated; a command input means 22 for receiving an instruction such as an inline expansion process;
Library function object code extracting means 23 for reading the object code of the objective function from the library.

The source analysis means 3 converts the input source into a number,
Lexical analysis means 31 for decomposing into tokens such as arithmetic expressions and variables
And a parsing means 32 for parsing the decomposed token and constructing it as an expression such as a syntax tree, and a library function call finding means 33 for judging whether a library function is called in the expression (syntax). And

The conversion means 4 includes an object code generation means 41 for generating a target code for each expression.

The output means 5 includes a result file output means 51 for outputting the converted code to a file, and a result display means 52 for displaying a message such as an error on a screen.

The source program is a program input means 2
1 and decomposed into tokens by the lexical analysis means 31, parsed by the syntax analysis means 32 and decomposed into expressions, a code corresponding to each expression is generated by the object code generation means 41, and a result file output means 51 The translation of the source program is completed by outputting the object code generated by the file to a file.

At this time, library function call finding means 3
3, the call expression of the library function is detected, the object code of the library function is read from the library by the library function object code extracting means 23, and the object code is directly output to a file, thereby implementing the inline expansion of the library function. .

FIG. 2 is a flowchart for explaining the operation of one embodiment of the present invention. With reference to FIGS. 1 and 2, the overall operation of the present embodiment will be described in detail.

First, in step S1, it is checked whether the read syntax (expression) is a function call.
If it is not a function call, the following steps S2 to S5
Is not performed.

When the read syntax is a function call,
To check whether the function name is a library function, in step S2,
Check whether the target function is registered.

FIG. 3 is a diagram showing an example of a library configuration in one embodiment of the present invention. Referring to FIG. 3, the library includes an object code area 301 in which object codes of functions are stored, and a symbol list area 302 in which function names and storage locations of functions are stored. The symbol list area 302 stores a function name, a function code start address, and a function code size for each function.

In step S2 of FIG. 2, a target function name is searched from the symbol list area 302 in the library of FIG.

Next, when it is determined in the determination processing in step S3 that the target function is not a library function,
When the target function name is not found in the symbol list area 302 of FIG. 3, the processing here ends.

If the target function is found as a library function in the determination processing in step S3, that is, if the target function is found to be a library function, step S4
In step (3), the function code start address and the object size of the target function are read from the symbol list area 302 in FIG. 3, and are set in variables adr and size, respectively.

Next, in step S5, the size from the address adr of the object code area 301 in FIG.
Read the minute code. During this reading, the first function name symbol and the last ret instruction (return instruction) are skipped. Thus, the reading of the library function object code ends.

Next, the operation of this embodiment will be described using a specific example. FIGS. 4 and 5 are diagrams specifically illustrating an embodiment of the present invention, and show specific examples of a source program and a library configuration, respectively.

For example, the source program (C shown in FIG. 4)
A case in which a library function inline expansion instruction is given when translating (compiling) a language source will be described. At this time, a library having the library structure shown in FIG. 5 is input.

The program input means 21 of FIG. 1 inputs the source program of FIG.
Then, the syntax analysis unit 32 decomposes the source program into a syntax (expression). When the syntax analysis is completed, the library function call finding means 33 and the library function object code extracting means 23 of FIG. 1 perform inline expansion processing of the library function for each syntax (expression). Hereinafter, specific processing will be described.

In FIG. 2, first, in step S1, the read syntax, in this case, the syntax 401 (ma
Since in ()) is not a function call, the processing here ends. Similarly, the subsequent syntaxes 402 and 403 are not function calls, so the process ends.

When the next syntax 404 is read, since it is a function call, the determination in step S1 of FIG. 2 is true, and the process proceeds to step S2. Step S2 and Step S
In 3, it is checked whether or not the function abs is registered in the library shown in FIG. 5. Since the function name abs is registered in the library, the process proceeds to step S 4 in FIG. 2. The function code start address and the object size of the function abs are read from the symbol list area 502, and are set in variables adr and size, respectively. In this case, the variables adr and size are 0 and 6
Are set respectively.

Next, in step S5 of FIG. 2, a code corresponding to size is read from the address adr of the object code area 501 shown in FIG. In this case, address 0
The object code for 6 words is read from.
However, at the time of this reading, since the first function name symbol and the last ret instruction are skipped, actually four words from code 504 to code 507 in FIG. 5 are read.

When the object code generating means 41 of FIG. 1 generates an object code for each syntax, the read object code is used instead of the function call code. FIG. 6 shows an example of the object code output in this way by mnemonics.

Next, a second embodiment of the present invention will be described. The basic configuration of the second embodiment of the present invention is the same as the configuration shown in FIG.

FIG. 7 is a flow chart for explaining the operation of the second embodiment of the present invention. FIG. 8 is a diagram for explaining the configuration of the library according to the second embodiment of the present invention. Referring to FIG. 7 and FIG. 8, in the present embodiment, the symbol list information 802 of the library structure to be input is replaced with the function code as shown in FIG. 8 instead of the size of the function code in the embodiment shown in FIG. As shown in FIG. 7, instead of steps S4 and S5 in FIG. 2 in which the function object code is read using the function code size in reading the library, the function code end address is used. The difference from the above embodiment is that the function object code is read.
In FIG. 7, the same processing steps as those in FIG. 2 are denoted by the same reference numerals.

Next, the operation of the second embodiment of the present invention will be described with reference to a specific example. For example, a case will be described in which a library function inline expansion instruction is issued at the time of translating the source program shown in FIG. At this time, a library having the library structure shown in FIG. 9 is input.

The program input means 21 (see FIG. 1)
The source program of FIG.
Then, the syntax analysis unit 32 decomposes the source program into a syntax (expression). When the syntax analysis is completed, the library function call finding means 33 and the library function object code extracting means 23 of FIG. 1 perform inline expansion processing of the library function for each syntax (expression). Hereinafter, specific processing will be described. In FIG. 7, first, step S1 is the read syntax, in this case, the syntax 401 in FIG. 4 is not a function call, and thus the processing here ends. Similarly, since the syntax 402 and the syntax 403 are not function calls, the process ends.

When the syntax 404 of FIG. 4 is read, FIG.
Is true in step S1, and the process proceeds to step S2. Steps S2 and S3 check whether the function abs is registered in the library shown in FIG. In this case, since the function name abs has been registered, the process proceeds to step S6 in FIG. In step S6, the function code start address and the function code end address of the function abs are read from the symbol list area 902 in FIG. 9 and set in variables adr_s and adr_e, respectively. In this case, 0 and 5 are set to the variables adr_s and adr_e, respectively.

Next, in step S7 of FIG. 7, the address adr_of the object code area 901 shown in FIG.
The code from s to address adr_e is read. In this case, six words of object code from address 0 to address 5 are read. However, at the time of this reading, since the first function name symbol and the last ret instruction are skipped, four words from code 904 to code 907 in FIG. 9 are actually read.

The read object code is used in place of the function call code when the object code generation means 41 of FIG. 1 generates an object code for each syntax. FIG. 6 shows an example of the object code output in this manner. Also in the second embodiment of the present invention, it can be seen that the same effect as when the library structure shown in FIG. 5 is input as the above embodiment is obtained.

[0045]

As described above, according to the present invention, the following effects can be obtained.

The first effect of the present invention is that all library functions can be expanded inline.

The reason is that, in the present invention, the compiler is provided with a library function object code extracting means for inputting a library and extracting an object code to be subjected to inline expansion from the library.

A second effect of the present invention is that the inline expansion processing of the library function can be speeded up and realized in a processing time equivalent to the processing time without the inline expansion processing.

[Brief description of the drawings]

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

FIG. 2 is a flowchart for explaining the operation of one embodiment of the present invention.

FIG. 3 is a diagram illustrating an example of a library configuration according to an embodiment of the present invention.

FIG. 4 is a diagram specifically illustrating an embodiment of the present invention, and is a diagram illustrating an example of a source program.

FIG. 5 is a diagram specifically illustrating an embodiment of the present invention, and is a diagram illustrating a specific example of a library.

FIG. 6 is a diagram specifically illustrating one embodiment of the present invention, and is a diagram illustrating an example of an output object code.

FIG. 7 is a flowchart for explaining the operation of the second exemplary embodiment of the present invention.

FIG. 8 is a diagram illustrating an example of a library configuration according to a second embodiment of the present invention.

FIG. 9 is a diagram for explaining a second embodiment of the present invention, and is a diagram showing a specific example of a library configuration.

FIG. 10 is a diagram showing an example of a configuration of a conventional inline expansion processing method.

FIG. 11 is a diagram showing another example of the configuration of the conventional inline expansion processing method.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 Control processing means 2 Input means 3 Source analysis means 4 Conversion means 4 5 Output means 5 21 Program input means 22 Command input means 23 Library function object code extraction means 31 Lexical analysis means 32 Syntax analysis means 33 Library function call finding means 41 Object Code generation means 51 Result file output means 52 Result display means 301, 501, 801, 901 Object code area 302, 502, 802, 902 Symbol list F1, F2 Library

────────────────────────────────────────────────── ───

[Procedure amendment]

[Submission date] September 27, 1999 (September 9, 1999
7)

[Procedure amendment 1]

[Document name to be amended] Statement

[Correction target item name] Claim 1

[Correction method] Change

[Correction contents]

[Procedure amendment 2]

[Document name to be amended] Statement

[Correction target item name] Claim 3

[Correction method] Change

[Correction contents]

[Procedure amendment 3]

[Document name to be amended] Statement

[Correction target item name] Claim 4

[Correction method] Change

[Correction contents]

[Procedure amendment 4]

[Document name to be amended] Statement

[Correction target item name] Claim 5

[Correction method] Change

[Correction contents]

[Procedure amendment 5]

[Document name to be amended] Statement

[Correction target item name] Claim 6

[Correction method] Change

[Correction contents]

[Procedure amendment 6]

[Document name to be amended] Statement

[Correction target item name] Claim 7

[Correction method] Change

[Correction contents]

[Procedure amendment 7]

[Document name to be amended] Statement

[Correction target item name] Claim 8

[Correction method] Change

[Correction contents]

[Procedure amendment 8]

[Document name to be amended] Statement

[Correction target item name] Claim 9

[Correction method] Change

[Correction contents]

[Procedure amendment 9]

[Document name to be amended] Statement

[Correction target item name] 0010

[Correction method] Change

[Correction contents]

[0010]

SUMMARY OF THE INVENTION The present invention for achieving the above object is a method for performing inline expansion in a compiler for inputting a source program and generating object code.
Prepare a library including
Can, if the syntax of the source program input is a function call, it is determined whether or not the number people the function is registered in the library, when registered in the library, the object code of the function number read from the library, calls the function the object code
Inline expansion by outputting in place of the output code .

Claims (9)

[Claims] 1. A method for performing inline expansion in a compiler that inputs a source program and generates an object code, wherein, when the syntax of the input source program is a function call, the function name is registered in a library. Judge whether or not the function code is registered in the library, read the object code of the function from the library, and output the object code instead of the code of the function call; Processing method. 2. The inline expansion processing method according to claim 1, wherein the library is input when an inline expansion processing is instructed. 3. A means for determining whether or not a syntax obtained by parsing a source program is a function call. If the syntax is a function call, a library including a function name list and an object code of the function is provided. Search and
Check whether the function name is registered in the library, and if the function name of the function call is registered in the library, obtain the storage location of the object code of the function from the library, and according to the location information An inline expansion device comprising: a unit for reading the object code of the function; and a unit for outputting the read object code instead of the function call code. 4. The inline expansion processing apparatus according to claim 3, wherein the library is input when an inline expansion processing is instructed from the input unit. 5. The library as a symbol list,
4. The inline expansion apparatus according to claim 3, wherein, in addition to the function name list, a start address and size information of the function are included for each function name. 6. The library as a symbol list,
4. The method according to claim 3, wherein each function name includes information on a start address and an end address of the function in addition to the function name list.
The inline expansion device as described. 7. The inline expansion device according to claim 3, wherein the library is provided outside the compiler and is updatable. 8. The inline expansion apparatus according to claim 3, wherein when reading the function object from the library, the first function name symbol label and the last return instruction are skipped. 9. A process for determining whether or not a syntax obtained by parsing a source program is a function call. (B) When the syntax is a function call, a list of function names and an object of the function. From the library including the code, the function name list is searched to determine whether the function name is registered in the library.If the function name of the function call is registered in the library, Searching for the object code storage location of the function from, and reading the object code of the function according to the searched information; and (c) outputting the read object code to a file instead of the function call code. And a recording medium storing a program for causing a computer to execute each of the above-described processes (a) to (c). .