JPH0594311A - Machine language translation program - Google Patents

Abstract

PURPOSE:To minimize an object size in a machine language translation program having the function calling instruction of a different instruction length. CONSTITUTION:In the source analyzing processing (step 100) at a path 1, a source program is converted to an intermediate code, in a CALLX instruction (function calling instruction) use frequency table preparing processing (step 200), the function name and the use frequency called by a CALLX instruction are registered into a CALLX instruction use frequency table 210. Next, the function calling instruction optimizing processing (step 220) by the CALLX instruction is performed, the optimizing processing (step 102) of a branching instruction, etc., is performed, and the object preparing processing (step 103) at a path 2 is performed through a step 104 up to the completion of a file.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a machine language translation program.

[0002]

2. Description of the Related Art Conventionally, a machine for a processor having an instruction for directly calling a function and an instruction for indirectly calling a function by referring to a head address of a finite number of functions stored in advance in a finite specific area. In a word translation program, when writing a source program, it is generally made by the source program writer himself to select the instruction so that the instruction code is minimized.

Hereinafter, the processing of a conventional machine language translation program according to the two-pass method will be described with reference to FIG. 4, and an example of description of a source program using a function call instruction will be described with reference to FIG. explain.

In FIG. 4, in the conventional 2-bus machine language translation program, the source analysis process is performed in pass 1 (step 100), and then the source analysis process is performed up to the end of the file. Is determined (step 101), and if the source analysis process up to the end of the file has not been performed, the process returns to step 100 again and the source analysis process in pass 1 is performed. In step 101, if the source analysis processing is performed up to the end of the file, the process proceeds to the next processing step, optimization processing such as a branch instruction is performed (step 102), and an object is generated in pass 2. The process is executed (step 103). Next, it is judged whether or not the object generation processing has been performed up to the end of the file (step 104). If the object generation processing has not been performed up to the end of the file, the procedure returns to step 103 again, and the path 2 The object generation process in is executed. In step 104, when the object generation process is performed up to the end of the file, the series of processes in the machine language translation program by the 2-bus method ends.

In this case, the instruction for directly calling the function is CAL.
The L instruction (instruction length is 3 bytes) is referred to, and the instruction that indirectly calls the function is referred to by referring to the start address of the function (the code length expressing the address is 2 bytes) stored in the specific area. If the code length is 1 byte), the more frequently this function is used, the more CA
When the LLT instruction is used, the instruction length generated in the object generation processing (sup 103) becomes shorter.

In one example of the description of the source program using the function call instruction shown in FIG. 5, the function SUB
1 and SUB4 are used once, so CAL
The function call 400 using the L instruction is executed, and the function SUB
2 and the function SUB3 are used twice, so C
The function call 401 using the ALLT instruction is performed, and the start addresses of the functions SUB2 and SUB3 are described in the specific area (402) to minimize the instruction code length.

[0007]

In the above-mentioned conventional machine language translation program, there is no optimization processing method corresponding to the function call instruction of different instruction length, and the function call instruction described in the source program is Since it was simply translated into the corresponding machine language, when writing the source program so that the instruction code length was minimized, the source program writer himself, in the order of frequent use of the function, It is necessary to use an instruction that indirectly calls a function. In addition, even when the source program is changed, if the frequency of use of the function changes, in response to the change, instructions for calling the function in the order of high frequency of use of the function are interleaved again. The disadvantage is that the source program needs to be modified to use it.

[0008]

A machine language translation program of the present invention refers to a first calling instruction for calling a function and a leading address of a finite number of functions stored in advance in a finite specific area. In a machine language translation program for a processor having a second call instruction having an instruction length shorter than the instruction length of the first call instruction by indirectly calling the function, a virtual first call function is provided. 3 is defined, and a table for registering the name of a function to be called each time the third calling instruction is used and the number of times the function is used during the machine language translation process; and the function in the table. A first processing procedure for registering a name and the number of times the function is used, and the second call instruction within a range applicable to the processor corresponding to the rank of the function that is frequently used. A second call instruction for converting the third call instruction to the second call instruction and the remaining third call instruction that cannot be converted to the first call instruction until reaching the numerical value. And at least a processing procedure.

[0009]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Next, the present invention will be described with reference to the drawings.

FIG. 1 is a block diagram showing the essential parts of an embodiment of the present invention, and FIG. 2 is a flow chart showing the operation of an optimization processing unit for function call instructions in this embodiment. Also, FIG.
(A) and (b) respectively show a description example of the source program in the present invention and a source code corresponding to the intermediate code after the optimization processing of the function call instruction.
This is an example program.

Now, a CALL instruction (instruction code length is 3 bytes) is used as an instruction for directly calling a function, and a finite number of function start addresses stored in advance in a finite specific area (the code length representing the address is 2 bytes). ), A second call instruction having an instruction length shorter than the instruction length of the first instruction is made a CALLT instruction (instruction code length is 1 byte) by indirectly calling a function, and a machine language translation process is in progress. The CALL instruction or C to minimize the instruction code length.
The function call instruction defined for conversion into an ALLT instruction will be called a CALLX instruction, and the specific area will be called a CALLT table.

Corresponding to the conventional technique, a CALL is newly added after the source analysis process (step 100) in pass 1.
X command usage count table creation process (step 200)
And the optimization process of the CALLX instruction (step 220) before the optimization process of the branch instruction (step 102).
And the name of the function called by the CALLX instruction and the number of times the CALLX instruction is used to call the function are registered.
The instruction usage count table 210 is added.

In the source analysis process in pass 1 (step 100), the source program is converted into intermediate code. At this time, in the CALLX instruction use count table creation process (step 200), the function name and the use count are CA for each function called by the CALLX instruction.
It is registered in the LLX instruction usage count table 210. This operation continues until the end of the file.

Next, the function call instruction optimizing process (step 220) is performed. The process operation will be described with reference to FIG.

First, the CALLX instruction usage count table 210 created through the above processing procedure is sorted and sorted in descending order of the usage count (step 221).
From the beginning of the ALLX instruction usage count table 210, the beginning address of the function with the saved function name is converted into a CALLT instruction as long as it can be stored in the CALLT table (step 222), and the remaining CALLX instructions are converted into CALL instructions. (Step 223). And
A CALLT table corresponding to the converted CALLT instruction is created (step 224).

Next, returning to FIG. 1, optimization processing of branch instructions and the like is performed as in the conventional processing method (step 1).
02), the object generation process in pass 2 is executed (step 103), and the object generation process in pass 2 is executed until the end of the file through the determination process in step 104.

In this case, in the source program example shown in FIG. 3A, all the function calls are CALL.
When the X instruction is used, after the CALLX instruction optimizing process (step 220) is performed,
As shown in the example of the source program corresponding to the intermediate code in (b), the call instruction of the function SUB1 is CA
It is converted into an LLT instruction (300), and the call instruction of the function SUB2 is converted into a CALL instruction (step 30).
1). Also, a CALLT table for the function SUB1 is created (302).

[0018]

As described above, according to the present invention, the optimization processing is performed by the function call instruction having the different instruction code length, so that the intervention of the source program writer can be avoided.
There is an effect that the object size generated by the machine language translation program can be optimized.

[Brief description of drawings]

FIG. 1 is a flowchart showing a processing procedure of an embodiment of the present invention.

FIG. 2 is a flowchart showing a partial processing procedure in the present embodiment.

FIG. 3 is a diagram showing a description example of a source program in the present embodiment.

FIG. 4 is a flowchart showing a processing procedure in a conventional example.

FIG. 5 is a diagram showing a description example of a source program in a conventional example.

[Explanation of symbols]

 100 Source analysis in pass 1 101 File end judgment 102 Optimization of branch instructions 103 Object generation 104 File end judgment 200 CALLX instruction usage count table 210 CALLX instruction usage count table 220 CALLX instruction optimization 221 CALLX instruction usage count sort 222 Converts CALLX command to CALLT command 223 Converts remaining CALLX command to CALL command 224 Creates CALLT table 300 Calls function using CALL command 301 Calls function using CALLT command 302 Stores start address of function 400 to CALLT command Converted function call 401 Function call converted to CALL instruction 402 Created FALLT table

Claims (1)

[Claims] 1. A first call instruction for calling a function and a head address of a finite number of functions stored in advance in a finite specific area are referred to, thereby indirectly calling the function, In a machine language translation program for a processor having a second call instruction having an instruction length shorter than that of one call instruction, a virtual third call instruction for calling the function is defined,
During the machine language translation process, a table for registering a function name called each time the third call instruction is used and the number of times the function is used, and the table showing the function name and the number of times the function is used Corresponding to the first processing procedure to be registered and the rank of the function that is frequently used, the third call instruction is executed until the number value of the second call instruction within the applicable range in the processor is reached. A second processing procedure for converting the second call instruction into the second call instruction and converting the remaining third call instruction that cannot be converted into the first call instruction. Language translation program.