JP2001273150A - Device for converting program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a program conversion device that converts access description into an optimum assembler code when the access description of an assembler template function being a description format to be developed into an assembler code is included in a source program. SOLUTION: When a controlling part 104 detects the access description of the assembler template function, an assembler template selecting part 105 obtains a plurality of definitions corresponding to the assembler template function accessed by the access description from an assembler template storing part 103, decides whether or not the respective definitions are usable according to whether an argument in the access description is a variable or a constant, the number of performance cycles of an assembler code specified by a definition is calculated with respect to each of usable definition, and one definition in which the number of performance cycles is the smallest is selected. An assembler function access translating part 107 generates an assembler code on the selected definition and outputs the assembler code to an output file storing part 108.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to a program conversion device for converting a source program described in a high-level language into assembler code for a specific processor.
The present invention relates to a program conversion apparatus that converts a source program containing a function call description to be converted into separately defined assembler code.

[0002]

2. Description of the Related Art Generally, a program developer or the like creates a program using a high-level language such as C language, C ++ language, and the like.
The program is converted into assembler code by a program conversion device such as a compiler, and finally converted into a machine language instruction sequence executable by a processor and used.

Recently, microprocessors have been manufactured which support digital signal processing instructions (hereinafter, referred to as "DSP instructions") such as a product-sum operation and a saturation operation in order to perform multimedia processing such as image processing at a high speed. Such microprocessors have been installed in information home appliances and personal computers. However, high-level languages such as the C language and the C ++ language do not assume a DSP instruction and do not have an operator corresponding to the DSP instruction.

Therefore, in order to create a program for executing a process using a DSP instruction, a part of the process using the DSP instruction must be described in assembler language. Some conventional program conversion apparatuses can use a call description for an assembler template function in order to describe processing realized by assembler code in a high-level language source program. An example is a compiler from GAIO Technology. An assembler template function is a description used to determine assembler code, and takes the form of a function formally. A definition of the contents of the assembler template function, that is, information for determining the assembler code, is called an assembler template. That is, the assembler template is a description for defining the assembler template function, that is, a description for specifying the contents of the assembler template function.

In such a program conversion device, when a call description of an assembler template function is described in a source program, the contents of the assembler template function are used in accordance with the arguments and return values in the call description. The assembler code is determined, and the determined assembler code is used as a translation result of the call description portion of the assembler template function. That is, by this program conversion device, the call description of the assembler template function is not translated into assembler code including an instruction to call a subroutine, but into assembler code directly placed at that position.

FIG. 10 shows an example of the contents of a conventional assembler template. As shown in the figure, the contents of the assembler template are definitions of assembler template functions, and the meaning of each line is as follows. "Asm
“_Template” indicates that the template is an assembler template. “Fir” represents a function name of an assembler template function. Note that there is only one definition description of the assembler template function specified by one function name. That is, two or more assembler template functions cannot be defined with the same function name.

"{P1 = {p0, p1, p2, p3}"
Indicates that the virtual register “$ p1” represents the first argument of the assembler template function, and “$ p0, p1, p2,
p3} "indicates a register of a candidate for assignment of the first argument.
Here, a virtual register is a variable that is converted into a register. When translating the source program, the program conversion device determines and assigns any one of the allocation candidate registers as the one corresponding to the first argument in the call description of the assembler template function. The value indicated by the first argument is stored in the determined one register.

"{P2 = {p4, p5, p6, p7}"
Indicates that the virtual register “$ p2” represents the second argument of the assembler template function, and “$ p4, p5, p6,
p7} "indicates a register of a candidate for assignment of the second argument.
“{P3 = {r0, r1, r2, r3}” is “{p
A virtual register “3” represents the third argument of the assembler template function, and “{r0, r1, r2, r3}” represents a register that is a candidate for assignment of the third argument.

"{T1 = {a0, a1}" is replaced with "{t
The virtual register “1” represents the first temporary resource used in the assembler template function, and “$ a0, a
“1｝” indicates a register of a candidate for temporary resource allocation.
The temporary resource means a register used temporarily. “Ret = {t1}” indicates that the first temporary resource used in the assembler template function is the return value of the function.

"Kill = {p1, {p2}" indicates that the values of the first and second arguments are changed in the function. “Code = {...}” Is the main description of the definition of the assembler template function, and is an assembler code expressed using arguments and temporary resources. "Rep
n @ p3 is an instruction to repeat the next instruction the number of times of the third argument, and "mac @ t1, m (@ p1,
1), m (@ p2,1) "is a temporary resource which is a sum of a product of a memory content pointed to by an address value as a first argument and a memory content pointed to by an address value as a second argument and a temporary resource. After storing, the address value which is the first argument and the second argument
These instructions increase the address values that are arguments.

In other words, the assembler template function having the function name "fir" is stored in the memory in order from the address as the first argument in the memory, and from the address in the second argument in the memory. This is a function that returns the sum of the results of calculating the inner product with the numerical value sequence by the number of elements indicated by the third argument as a return value. FIG. 6 is a diagram illustrating an example of a source program including a call description of an assembler template function.

The source program shown in FIG. 1 is described in the C language, and is called "fir (v1, v2, n)".
And "fir (v3, v4, 10)" described in the above "fi
This is a call description of an assembler template function with a function name of "r". Hereinafter, a conventional program conversion device 900 will be described with reference to FIG. FIG. 9 is a functional block diagram of a conventional program conversion device 900.

FIG. 1 shows a source file storage unit 901 which is a storage destination of an input file of the program conversion apparatus.
And an assembler template file storage unit 902;
Output file storage unit 907 as a storage destination of the output file
Is also shown. The program conversion device 900 converts a source program into assembler code, and is composed of a personal computer including a CPU, a memory, a hard disk device, and the like in terms of hardware, and functionally includes an assembler template storage unit 903 and a control unit. 90
4, an assembler function call translator 905, and a general instruction translator 906. The functions of the control unit 904, the assembler function call translating unit 905, and the general instruction translating unit 906 are realized by a CPU executing a control program stored in a memory.

Here, the source file storage unit 901 includes:
The storage device stores a source program including a call description of an assembler template function. The assembler template file storage unit 902 is a storage device that stores an assembler template file in which an assembler template that is a definition of an assembler template function called from a source program is described.

The assembler template storage unit 903 includes:
A memory area for reading and storing an assembler template from an assembler template file stored in the assembler template file storage unit 902. The control unit 904 reads the source program from the source file storage unit 901 and sequentially focuses on each statement of the source program. The focused statement is a statement that means a function call description, and the name of the function is stored in the assembler template storage. If it is stored in the unit 903, the assembler function call translating unit 905 is activated. In other cases, the general instruction translating unit 906 is activated. Here, activation refers to causing an activation target to start execution of a function process.

The assembler function call translating unit 905 is activated by the control unit 904, obtains a definition corresponding to the assembler template function called by the function call description from the assembler template storage unit 903, and obtains a main description "code". = ＄...｝ ”,“ ＄ p1 ”,“ ＄ p2 ”,“ ＄ p3 ”,“ ＄ t1 ”
, An assembler code is generated by allocating one of the allocation candidate registers and adding a code for setting an argument and a return value and a code for saving and restoring the register. The code is output to the output file 907.

The general instruction translating unit 906 is activated by the control unit 904 and performs a general instruction translating process. That is, the general instruction translating unit 906 converts a statement other than the statement including the call description of the assembler template function into assembler code according to the contents of the statement, and outputs it to the output file storage unit 907. After reading the source program and the assembler template from the source file storage unit 901 and the assembler template file storage unit 902, the program conversion device 900 converts them into a predetermined internal format with high processing efficiency, and converts them into assembler code. Execute the process of translating to

FIG. 11 is a diagram showing assembler code obtained as a result of converting the source program shown in FIG. 6 by the conventional program conversion device 900. The assembler template file storage unit 902 stores
When the assembler template shown in FIG. 10 is stored, the assembler code shown in FIG. 11 is obtained.

In the source program shown in FIG.
For the first use of the assembler template function, all arguments are variables, and for the second use, the first and second arguments are variables and the third argument is a constant "10". However, the assembler code generated as a result of the conversion of the source program has a part corresponding to the first use as shown in FIG. 11, regardless of whether a variable or a constant is used as an argument of the assembler template function. Also, the part corresponding to the second use is formally composed of the same instruction sequence.

As described above, the conventional program conversion device converts any portion using the same assembler template function into assembler code composed of the same instruction sequence.

[0021]

The above-mentioned conventional program conversion apparatus has the following problems from the viewpoint of converting a source program into an optimal assembler code, that is, generating an optimal assembler code. The instruction set that can be executed by the processor may have different instructions depending on whether the processing target is the contents of a register or a constant value, and by using each instruction effectively, the optimal assembler code Generation becomes possible. In the case where such different instructions are prepared, for example, even though an instruction for processing a constant can be used, if an instruction for processing a register is used after storing a constant in a register, the optimal It cannot be said that the assembler code was generated.

According to the conventional program conversion apparatus, a call description of an assembler template function is converted into assembler code composed of the same sequence of instructions regardless of the description using any arguments. It is not converted to the optimal assembler code depending on whether the argument is a variable or a constant. Also, prepare multiple assembler template functions that perform the same function but have different function names, and the creator of the source program can determine which arguments are variables or constants. It is conceivable to call the function by selecting whether to use the assembler template function.However, it imposes the burden of selection on the creator, which lowers the productivity and causes the creator to always make the optimal selection. There is a problem that is not always.

Accordingly, the present invention has been made in view of such a problem, and an assembler template function is provided according to the contents of a call description such as whether a parameter in a call description of an assembler template function is a variable or a constant. It is an object of the present invention to provide a program conversion device for converting a call description into an optimal assembler code. In addition, the present invention uses instructions for optimization in accordance with the contents of the call description of the assembler template function, and also sets which of the code size and the number of execution cycles to optimize. Another object of the present invention is to provide a program conversion device that converts a call description of an assembler template function into an optimal assembler code by selectively using instructions according to the following.

[0024]

In order to achieve the above object, a program conversion device according to the present invention is a program conversion device for converting a source program described in a high-level language into assembler code, comprising an assembler template function. Template storage means for storing a plurality of definitions for: and call detection means for detecting a call description of an assembler template function in the source program;
When the call description is detected by the call detection unit, a selection unit that selects an optimal one from among a plurality of definitions of the assembler template function called by the call description, Conversion means for converting the call description into assembler code based on the definition of the assembler template function selected by the selection means.

Here, the definition of an assembler template function refers to information on the contents specifying an assembler code. As a result, one of a plurality of definitions for the assembler template function is selected. Therefore, when using this program conversion device, if a plurality of definitions are prepared for one assembler template function,
It is possible to convert a call description of an assembler template function in a source program into an optimal assembler code according to the description contents, etc., and to convert it into an optimal assembler code in terms of code size or the number of execution cycles. . For example, the assembler template function is called according to whether the argument in the call description of the assembler template function in the source program is a variable or a constant, or whether the conversion is performed with priority on the code size or the number of execution cycles. Can be converted into an optimal assembler code having a small code size or a small number of execution cycles.

[0026]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS A program conversion device according to a practical embodiment of the present invention will be described below with reference to the drawings. <Structure> FIG. 1 is a functional block diagram of a program conversion device 100 according to an embodiment of the present invention.

FIG. 1 shows a source file storage unit 10.
1, the assembler template file storage unit 102 and the output file storage unit 108 are also described. Here, the source file storage unit 101 is a storage device that stores a C language source program including a call description of an assembler template function. The assembler template file storage unit 102 is a storage device that stores an assembler template file in which a plurality of assembler templates that are definitions of assembler template functions are described.

The output file storage unit 108 is stored in the source file storage unit 1 by the program conversion device 100.
01 is a storage device for storing assembler code generated as a result of conversion of the source program stored in the source program 01. The program conversion device 100 includes a CPU, a memory,
The control program, which is constituted by a personal computer having a hard disk device or the like,
This is a so-called compiler that realizes a function of converting a source program into assembler code by being executed by the U. Functionally, the assembler template storage unit 103, the control unit 104, the assembler template selection unit 105, the general instruction translation unit 106 , And an assembler function call translator 107. Note that converting a source program into assembler code refers to generating assembler code for causing a processor to execute processing contents described in the source program based on the source program.

The assembler template storage unit 103
This is a memory area for reading and storing an assembler template from the assembler template file storage unit 102, and is equivalent to the assembler template storage unit 903 in the conventional program conversion device 900. Control unit 1
Reference numeral 04 denotes a source program that is read from the source file storage unit 101, sequentially pays attention to each statement of the source program, and the focused statement is a statement meaning a function call description, and the name of the function is the assembler template storage unit 1
03, the assembler function call translator 107 is activated, otherwise, the general instruction translator 106 is activated. The control unit 104 is equivalent to the control unit 904 in the conventional program conversion device 900.

The assembler function call translating unit 905 is activated by the control unit 904, activates the assembler template selecting unit 105, and receives from the assembler template selecting unit 105 the definition corresponding to the assembler template function called by the function call description. Allocate any of the candidate registers to the virtual register used in the main description of the definition of the assembler template function, and save and restore the code and register for setting arguments and return values and registers To generate an assembler code and output the generated assembler code to the output file storage unit 108.

The assembler template selection unit 105
A plurality of definitions corresponding to the assembler template functions invoked by the assembler function call translator 107 and called by the function call description, that is, a plurality of assembler templates are obtained from the assembler template storage 103, and the cost of each assembler template is calculated. And select the lowest cost assembler template,
It is passed to the assembler function call translator 107. Note that the cost refers to an index value for use in selecting an assembler template, and a low cost means that the code size of the assembler code that is the translation result of the assembler template function is small or the number of execution cycles of the assembler code is short. It represents a thing.

The general instruction translating unit 106 is activated by the control unit 104, converts a sentence other than a statement including a call description of an assembler template function into assembler code according to the contents of the sentence, and outputs it to the output file storage unit 108. I do. The general instruction translating unit 106 is equivalent to the general instruction translating unit 906 in the conventional program conversion device 900.

After reading the source program and the assembler template from the source file storage unit 101 and the assembler template file storage unit 102, the program conversion apparatus 100 converts a source program into an internal format by a general compiler and performs a translation process. Similarly, the source program and the assembler template are converted into a predetermined internal format having high processing efficiency, and a process of translating these into assembler code is executed. <Data Content> Hereinafter, a plurality of assembler templates stored in the assembler template file storage unit 102 will be described.

FIG. 7 is a diagram showing an example of the contents of a plurality of assembler templates. In the example of FIG. 2, the definition description of two assembler template functions having the same function name is given.
Shows two assembler templates. First, the definition of template 1 in the figure, that is, the first assembler template function will be described.

"Fir" represents a function name of an assembler template function. "＄ p1 = ｛p0, p1, p2, p
3}, the virtual register “$ p1” represents the first argument of the assembler template function, and “$ p0, p1,
p2, p3} "indicates a register of a candidate for assignment of the first argument. "{P2 = {p4, p5, p6, p7}"
The virtual register “$ p2” represents the second argument of the assembler template function, and “$ p4, p5, p6, p
7} "indicates a register of a candidate for assignment of the second argument.

"{P3 = {r0, r1, r2, r3}"
Indicates that the virtual register “$ p3” represents the third argument of the assembler template function, and “$ r0, r1, r2,
r3} "indicates a register of a candidate for assignment of the third argument.
“{T1 = {a0, a1}” represents the first temporary resource whose virtual register “{t1” is used in the assembler template function, and “{a0, a1}” is a candidate for temporary resource allocation. Represents a register.

"Ret = {t1}" indicates that the first temporary resource used in the assembler template function is the return value of the function. "Kill = $ p1,
{P2} ”indicates that the values of the first and second arguments are changed in the function. "Repn @ p3" and "mac @@" described as the contents of "code = {...}"
“t1, m (＄ p1,1), m (＄ p2,1)” is the main description of the definition of the assembler template function.
This is an assembler code represented using virtual registers “$ p1”, “$ p2”, “$ p3”, and “$ t1”.

[Cost = 2] indicates that the cost is 2. Next, regarding the definition of the template 2 in FIG. Only the differences will be described. “{P3 = {imm}” indicates that the virtual register “{p3” ”indicates the third argument of the assembler template function, and“ {imm} ”indicates that the assignment candidate of the third argument is a constant value.

[Macr ＄ sp3, ＄ t1, m (＄ p1,
1), m ($ p2, 1) "are the main descriptions of the definition of the assembler template function, and" $ p1 "and" $ p
This is an assembler code represented using virtual registers “2”, “$ p3”, and “$ t1”. "Cost =
1] indicates that the cost is 1. <Operation> Hereinafter, the operation of the program conversion device 100 having the above-described configuration will be described by taking as an example the conversion of a source program described in the C language shown in FIG.

It is assumed that the source program shown in FIG. 6 to be converted is stored in the source file storage unit 101, and the two assembler template functions shown in FIG. Is the assembler template file storage 1
02 is stored. FIG. 2 is a flowchart showing the operation of the program conversion device 100.

First, the program conversion apparatus 100 reads out all the assembler templates stored in the assembler template file storage unit 102, converts them into the internal format of the program conversion apparatus, and stores them in the assembler template storage unit 103 (step). S201).
After reading the assembler template, the program conversion device 100 reads the source program stored in the source file storage unit 101 and stores it in the memory (Step S202).

After the source program is stored in the memory, the control unit 104 sequentially focuses on each sentence in the source program and performs a translation process according to the contents (steps S203 to S208). That is, the control unit 104 focuses on one statement of the source program (step S203), and determines whether this statement is a function call description (step S20).
4) If it is a function call description, it is next determined whether or not the function name to be called is stored in the assembler template storage unit 103 (step S205). Activate and execute assembler function call translation processing (step S206). The assembler function call translation process will be described later in detail.

One statement in the source program shown in FIG. 6, “result1 = fir (v1, v2, n)”
Is a function call description, and the function name "fir" is stored in the assembler template storage unit 103 (see FIG. 7), so that assembler function call translation processing is performed. Further, the control unit 104 determines whether the focused statement (step S203) is not a function call description (step S204), or if the name of the function to be called is not stored in the assembler template storage unit 103 ( (Step S205), the general instruction translating unit 106 is activated to execute a general instruction translating process for converting into an assembler code according to the contents of the sentence (Step S20).
7). The general instruction translating process is the same as the translating process in a general compiler, and a detailed description of the operation is omitted.

Assembler function call translation processing (step S
206) or after the general instruction translation process (step S207) ends, the control unit 104 determines whether or not there is a sentence in the source program that has not been noticed yet (step S208). If there is, the process returns to step S203 to focus on the next sentence. In the source program shown in FIG. 6, the following statement “result2
= Fir (v3, v4,10) ", the sentence is focused on (step S203). This sentence is also a function call (step S204), and the function name "fir" is stored in the assembler template storage unit 103 (step S205), so that assembler function call translation processing is performed (step S206).

As described above, in the judgment in step S208, when there is no sentence that has not been focused on yet, that is, when all the sentences have been processed, the program conversion apparatus 100
Ends the operation related to the conversion of the source program. <Assembler function call translation process> The assembler function call translation process performed by the assembler function call translation unit 107 will be described below.

FIG. 3 shows an assembler function call translator 107.
3 is a flowchart showing the contents of an assembler function call translation process performed by the program. Assembler function call translator 107
, Information such as a memory address necessary for referring to the call description of the assembler template function in the source program stored in the memory is passed from the control unit 104 at the time of startup. “Result1 = fir (v1, v1), which is a call description of the assembler template function shown in FIG.
(2, n) "will be described by way of example, when information for referring to" 2, n) is passed and the assembler function call translating unit 107 is activated.

When activated, the assembler function call translator 107 obtains a register that is not assigned to a variable described in the source program, that is, a register that can be used without saving and restoring (step S301). Then, the assembler template selection unit 105 is activated by passing the information indicating the registers that can be used and the information indicating the call description of the assembler template function. Incidentally, which register is not assigned to a variable can be obtained by a method used in a conventional compiler.

When activated, the assembler template selection unit 105 performs an assembler template selection process of selecting an optimal assembler template from a plurality of assembler templates. In this case, "result1 = f
For “ir (v1, v2, n)”, the template 1 shown in FIG. 7 is selected as the definition of the assembler template function “fir” and is notified to the assembler function call translator 107 (step S302). This assembler template selection processing will be described later in detail.

Next, the assembler function call translator 107
Determines whether a code for passing arguments and return values is required when converting the definition of the assembler template function selected by the assembler template selection unit 105 into assembler code (step S303). If necessary, the assembler function call translator 107
Generates the necessary delivery code for the argument and the return value (step S304). If the delivery code for the argument and the return value is not necessary, step S3
Skip 04.

In step S304, the assembler function call translating unit 107 sets “result1 = fir (v1, v
2, n)], the arguments “v1”, “v2”, “n”
For "mov @ p1, v1" and "mov
$ P2, v2 "," mov @ p3, (n) ", and the return value result1 is" mo
v (result1), {t1 "is generated.

The assembler function translator 107 inserts the delivery code for the argument before the assembler code generated corresponding to the body description of the definition of the assembler template function, and delivers the delivery code for the return value. Is inserted after the assembler code generated for the body description. After generating the code for passing the arguments and return values as necessary, the assembler function call translator 107 refers to the description of the register of the allocation candidate in the assembler template, and determines the definition of the assembler template function. Assembler code is generated by determining actual registers to be assigned to virtual registers “$ p3”, “$ t1”, “$ p1”, and “$ p2” in the description, and replacing these virtual registers with the determined real registers. (Step S305). The actual register to be replaced can be determined by a method similar to the method in the conventional program conversion device, and the description is omitted here.

Here, the virtual registers “$ p1”, “$ p2”, “$ p3” which are the parameters of template 1
And "@ t1" are the real registers "p0" and "p
4 "," r0 "and" a0 ". Next, when the actual register to be replaced is used in a portion that has already been converted into assembler code, the assembler function translating unit 107 performs the same conversion as that of the conventional program conversion device in converting the function call description. It is determined whether or not the save and restore codes are necessary by the method (step S30).
6).

If it is determined that saving and restoring are necessary, the assembler function translating unit 107 generates assembler codes for register saving and restoring, and generates the assembler template function in accordance with the main description of the definition of the assembler template function. A save code is inserted before the generated assembler code, and a restoration code is inserted after the assembler code generated corresponding to the main description (step S307). If it is determined that saving and restoring are not necessary, step S3
Skip 07.

Here, "p0", "p4", "r0"
And "a0" do not need to be saved and restored, and
It is assumed that the process of 307 is not performed. Finally, the assembler function translator 107 outputs the assembler code generated corresponding to the main description of the definition of the assembler template function to the output file 106 (step S308), and ends the assembler function call translation process.

Further, "result2 = fir (v)" which is a call description of the assembler template function shown in FIG.
3, v4, 10) ”, the assembler function translating unit 107 basically executes the above-mentioned“ result1 = fir (v1, v1, v4, 10) ”.
2, n)] is passed, but the template 2 shown in FIG. 7 is selected in the assembler template selection processing (step S302) performed by the assembler template selection unit 105, and the result is "Result1 = fir (v1, v2, n)"
, An assembler code including an instruction sequence different from the instruction sequence generated in response to is generated.

By such assembler function call translation processing, the source program shown in FIG. 6 is converted into the assembler code shown in FIG. Program conversion device 10
0 is used to convert an assembler template function “fir” into an optimal assembler code.
Alternatively, the template 2 is selectively adopted, and as shown in FIG. 8, each call description is converted into an assembler code centered on an instruction sequence of “repn” and “mac” or an assembler code centered on an instruction “macr”. Convert.

<Assembler template selection processing> The assembler template selection processing performed by the assembler template selection unit 105 will be described below. FIG.
9 is a flowchart showing the contents of assembler template selection processing performed by the assembler template selection unit 105.

The assembler template selection unit 105
It is activated by the assembler function translating unit 107, and at the time of activation, information indicating a register that can be used without saving and restoring and information indicating a call description of an assembler template function are passed. Here, "result1 = file" which is a call description of the assembler template function shown in FIG.
(V1, v2, n) "and" resul
t2 = fir (v3, v4, 10) "will be described as an example.

The assembler template selection unit 105
The definition of a plurality of assembler template functions having the function names to be called in the call description of the assembler template function is obtained from the assembler template storage unit 103 (step S401). The assembler template selection unit 105 determines “result1 = fir (v1,
v2, n) ”or“ result2 = fir (v3, v
[4, n)], the template 1 and the template 2 having the function name “fir” shown in FIG. 7 are obtained.

The assembler template selection unit 105
Among the acquired definitions of the plurality of assembler template functions, the definition of the assembler template function having the minimum cost is selected. Therefore, step S402 is performed.
To S407. The assembler template selection unit 105 outputs one of the assembler template functions.
Focusing on one definition (step S402), it is determined whether or not the definition can be used to convert the call description of the assembler template function (step S403).

The assembler template selecting unit 105
Focusing on template 1 shown in FIG. 7, “res
It is determined that it can be used regardless of whether “ult1 = fir (v1, v2, n)” or “result2 = fir (v3, v4, 10)”. This determination is made because the template 1 does not include a condition that the argument cannot be used unless it is a constant, that is, an immediate value, that is, a description using imm described later.

However, assembler template selecting section 1
05 focuses on template 2 shown in FIG.
Since “{p3 = {imm}” in the definition of template 2 indicates that the third argument must be an immediate value, it can be used in a call description in which the third argument is an immediate value. Is not usable in a call description that is not an immediate value. Therefore, “result1 = fir (v
1, v2, n)], the third of “fir”
Judge that the argument "n" is not usable because it is not an immediate value,
In the case of “result2 = fir (v3, v4,10)”, it is determined that the third argument “10” of “fir” can be used because it is an immediate value.

The assembler template selection unit 105
If it is determined that the definition of the focused assembler template function is usable, a cost calculation process for calculating the cost for the definition is performed (step S4).
04). This cost calculation process will be described later in detail. Next, it is determined whether or not the calculated cost is the smallest of the costs calculated in the past (step S405), and if it is determined that the cost is the minimum, attention is paid. The definition of the assembler template function is selected (step S406), and it is determined whether there is an assembler template function definition that has not been focused on yet (step S407).

In step S406, when the definition of the focused assembler template function is selected, if the definition of the focused assembler template function has already been selected, the definition of the focused assembler template function is replaced. Select a new definition. If it is determined in step S405 that the cost is not the minimum, step S406 is skipped and step S406 is skipped.
407 is determined.

If it is determined in step S403 that the definition of the assembler template function of interest is not usable, steps S404 to S406 are skipped, and the determination in step S407 is performed. If it is determined in step S407 that there is a definition of an assembler template function that has not been focused on, the process returns to step S402 to focus on the definition of the next assembler template function, and all the assembler template function definitions have been processed. If so, the assembler template selection process ends.

Thus, "result1 = fir (v
In the case of “1, v2, n)”, only the template 1 shown in FIG. 7 is selected, so that the template 1 is finally selected by the assembler template selecting unit 105. If there is only one usable definition, steps S404 and S405 for searching for the one with the lowest cost are not performed.

Also, "result2 = fir (v3,
v4, 10) ", the selection candidates are both the template 1 and the template 2 shown in FIG. 7, and as a result of the cost calculation process described later, the template 1 shown in FIG.
Is calculated as 6, and the cost of template 2 is 4
Is calculated, the assembler template selecting unit 10
5 is finally selected as template 2.

<Cost Calculation Process> The cost calculation process will be described below. FIG. 5 is a flowchart illustrating the content of the cost calculation process performed by the assembler template selection unit 105. As a cost calculation process, the assembler template selecting unit 105 obtains the cost described in the definition of the assembler template function, such as “cost = 2” in the template 1 shown in FIG. Initial value (step S5
01), it is determined whether or not a code for passing an argument is necessary (step S502). In this example,
The numerical value of “cost” indicates the number of execution cycles.

The assembler template selection unit 105
If the code for the delivery of the argument is necessary, the cost of the code for the delivery of the argument is added to the cost calculation value to obtain a new cost calculation value (step S503). Skipping is performed, and it is determined whether a code for saving and restoring the register is necessary (step S504).

The assembler template selection unit 105
If the register save and restore codes are required, the cost of the register save and restore codes is added to the cost calculated value to obtain a new cost calculated value (step S505). Step S5
05 is skipped, and the cost calculation process ends. In other words, the sum of the "cost of the body description part of the template function definition", the "cost of the passing code for arguments", and the "cost of the register save and restore code" is the final value of the assembler template function definition. Cost calculation value.

By such a cost calculation process, “re
The cost of template 1 shown in FIG. 7 for “sult2 = fir (v3, v4,10)” is 2 + 4 + 0 =
6 and the cost of template 2 is 1 + 3 + 0
= 4. The cost of the code for passing arguments and the code for saving and restoring registers, especially assemblers, are based on the result of executing the process of allocating various variables to registers, which is the same process as general program conversion equipment. Only the code newly required when converting the call description of the template function is calculated and obtained. In addition, the information for calculation may be held in advance so that the cost of these codes can be obtained according to the number of using the registers. For example, if there are three variables as arguments, together with one return value,
The cost is 4. <Supplement> The file transfer system according to the present invention has been described based on the embodiments. However, it is needless to say that the present invention is not limited to these embodiments. That is, (1) In the present embodiment, the program conversion device outputs the assembler code. However, the program conversion device may convert the assembler code into a machine language format and output it. (2) Source file storage unit 101, assembler template file storage unit 102, and output file storage unit 1
Reference numeral 08 may be a storage device such as a separate hard disk device or the same storage device. (3) In the present embodiment, the description format “cost =” is used to indicate that the information specifying the cost is included in the assembler template. For each instruction that can be used, a table in which the instruction is associated with information indicating the cost such as the number of execution cycles and code size is stored in a memory or the like in advance, and the table is referred to based on the assembler template. The cost for the assembler code to be converted may be calculated. In this way, for each of the multiple definitions of the assembler template function, the cost is calculated and compared, the definition with the lowest cost is selected, and the call description of the assembler template function is converted into assembler code according to the definition. You may do it. (4) In the present embodiment, the operation of the program conversion device has been described based on an example in which attention is paid to the number of execution cycles as a cost. However, a code size may be used as a cost instead of the number of execution cycles. For example, "c
The description “ost =” may be described in advance so as to represent the code size.

Further, both the number of execution cycles and the code size can be calculated, and which of the number of execution cycles and the code size is used as the cost is determined according to the setting by the creator of the program or other persons, and the assembler determines the cost. One of the plurality of definitions of the template function that minimizes the cost may be selected, and the call description of the assembler template function may be converted into assembler code according to the definition. (5) In the present embodiment, the condition regarding the argument that the third argument must be an immediate value is described by “{p3 = {imm}” in the definition of the template 2. The condition may be a condition relating to the magnitude of an immediate value as an argument. For example, "@ p3 =
A description such as {0 <= imm <256} ", on condition that the third argument is a value of 0 or more and less than 256,
The condition may be that the argument is a numerical value within a predetermined range. (6) For each of a plurality of definitions for each assembler template function, conditions in which the definitions can be selection candidates may be stored in any format. For example,
If there are two definitions, template A1 and template A2, for an assembler template function A that has only one argument, if the argument is a variable, the template A1
If the argument is an immediate value, that is, if it is a constant, selection information indicating that the template A2 is a selection candidate may be stored. In this case, the determination in step S403 is made with reference to the selection information. Further, the cost for each definition may be stored in any format. (7) In the present embodiment, the saving and restoring codes and the code for passing the arguments are taken into account in the cost calculation. However, these need not always be taken into account, and the main description part of the definition of the template function is not necessary. May be the result of the cost calculation. (8) A computer program for causing a general-purpose computer or the like to execute the processing procedure (the procedure of the flowcharts in FIGS. 2 to 5) of the program conversion device according to the present embodiment is recorded on a recording medium or various communication paths. It can also be distributed and distributed through such means. Such a recording medium includes an IC card, an optical disk, a flexible disk, a ROM, and the like. The distributed and distributed computer programs are provided for use by being installed in a computer or the like, and the computer executes the computer programs to realize the program conversion device as described in the present embodiment.

[0073]

As is apparent from the above description, the program conversion device according to the present invention is a program conversion device for converting a source program described in a high-level language into assembler code. Template storage means for storing the definition of
A call detecting means for detecting a call description of an assembler template function in the source program; and a plurality of definitions of an assembler template function called by the call description when the call description is detected by the call detecting means. Selecting means for selecting an optimum one, and converting means for converting the call description detected by the call detecting means into assembler code based on the definition of the assembler template function selected by the selecting means. It is characterized by.

As a result, one of a plurality of definitions for the assembler template function is selected.
When this program conversion device is used, if a plurality of definitions are prepared for one assembler template function, the call description of the assembler template function in the source program can be converted into the optimal assembler according to the description contents. It can be converted to code.

Further, the call detecting means detects a call description of a function in the source program, and judges whether a definition of a function called by the call description is stored in the template storage means. Alternatively, when the definition is stored, the call description may be detected as a call description of the assembler template function.

As a result, a call description of an assembler template function described in a format similar to a normal function call description on a source program can be detected and converted into an optimal assembler code. Further, the template storage means also stores, for each definition of the assembler template function, condition information indicating a condition for an argument to the function, when the condition information has a condition, and the selecting means stores the condition information. May be selected according to the description of the argument to the function included in the call description.

Thus, in the call description of the assembler template function, whether a variable is an argument,
That is, corresponding to each argument, such as whether a constant is used as an argument,
The call description of the assembler template function can be converted into more optimal assembler code. Further, the condition information is information indicating that the argument must be an immediate, and the selecting means determines whether or not the description of the argument to the function included in the call description is an immediate according to the condition information. May be selected according to the above.

Thus, in the call description of the assembler template function, different assembler codes are generated depending on whether a variable is used as an argument or a constant is used as an argument, that is, the call description of the assembler template function is converted into a more optimal assembler code. Can be converted. Further, the condition information is information indicating that the argument must be an immediate value within a predetermined range value, and the selecting means determines that the description of the argument to the function included in the call description is in accordance with the condition information. The selection may be made according to whether or not the value is an immediate value within the range.

Thus, even when a constant is used as an argument in the call description of the assembler template function, the generated assembler code can be made different depending on whether the constant is a value within a predetermined range. Become. For example, in the case of a constant in a numerical range that can be represented by 1 byte such as 0 to 255, an instruction that can specify an immediate value of 1 byte can be used.
In the case where an instruction to specify a byte numerical value must be used, the assembler code including an instruction to specify a 2-byte numerical value by calling the assembler template function with a numerical constant from 0 to 255 as an argument. Can be prevented.

Further, the template storage means also stores, for each definition of the assembler template function, an evaluation value serving as a reference for selecting an optimum one, and the selection means stores the evaluation value for each of the definitions. The selection may be made based on the evaluation value. This makes it possible to quickly select an optimal definition from among a plurality of definitions for the assembler template function, and to quickly convert a program.

The template storage means stores, for each of the definitions, information indicating the number of execution cycles for the assembler code specified by the definition as the evaluation value. One of the definitions may be selected to be converted into the assembler code having the minimum number of execution cycles.

Thus, the call description of the assembler template function can be converted into assembler code having a high execution speed. The template storage unit stores, for each of the definitions, information indicating a code size of an assembler code specified by the definition as the evaluation value, and the selection unit includes a code size of the plurality of definitions. May be selected to be converted into the assembler code with the minimum.

Thus, the call description of the assembler template function can be converted into a small-size assembler code. In addition, if the call description is assumed to be converted into assembler code specified by each of the definitions, the selecting means may need to include a code for setting an argument in a register and a code for saving and restoring a register. If there is such a code, the selection may be performed by making a determination based on the number of execution cycles or the code size of the code resulting from the conversion including the code.

As a result, cost calculation can be strictly performed, and an optimal definition that minimizes cost can be selected. As a result, a call description of an assembler template function is converted into an optimal assembler code. Will be able to do it.

[Brief description of the drawings]

FIG. 1 is a functional block diagram of a program conversion device 100 according to an embodiment of the present invention.

FIG. 2 is a flowchart showing an operation of the program conversion device 100.

FIG. 3 is a flowchart showing the contents of an assembler function call translation process performed by an assembler function call translation unit 107;

FIG. 4 is a flowchart illustrating an assembler template selection process performed by an assembler template selection unit 105;

FIG. 5 is a flowchart illustrating the contents of a cost calculation process performed by an assembler template selection unit 105;

FIG. 6 is a diagram showing an example of a source program including a description for calling an assembler template function.

FIG. 7 is a diagram showing an example of the contents of an assembler template.

8 is a diagram showing assembler code as a result of converting the source program shown in FIG. 6 by the program conversion device 100 according to the present invention.

FIG. 9 is a functional block diagram of a conventional program conversion device 900.

FIG. 10 is a diagram showing a content example of a conventional assembler template.

FIG. 11 shows a conventional program conversion apparatus 900 shown in FIG.
FIG. 14 is a diagram showing assembler code resulting from converting the source program shown in FIG.

[Explanation of symbols]

 REFERENCE SIGNS LIST 100 program conversion device 101 source file storage unit 102 assembler template file storage unit 103 assembler template storage unit 104 control unit 105 assembler template selection unit 106 general instruction translation unit 107 assembler function call translation unit 108 output file storage unit

 ──────────────────────────────────────────────────続 き Continuing on the front page (72) Inventor Wataru Hashiguchi 1006 Kazuma Kadoma, Kadoma-shi, Osaka Matsushita Electric Industrial Co., Ltd. F-term (reference) 5B081 CC21

Claims (10)

[Claims] 1. A program conversion apparatus for converting a source program described in a high-level language into assembler code, comprising: template storage means for storing a plurality of definitions of an assembler template function; Call detecting means for detecting a call description; and selecting, when the call description is detected by the call detecting means, an optimum one of a plurality of definitions of an assembler template function called by the call description. Means for converting the call description detected by the call detection means into assembler code based on the definition of the assembler template function selected by the selection means. 2. The call detecting means detects a call description of a function in the source program, and determines whether a definition of a function called by the call description is stored in the template storage means. 2. The program conversion device according to claim 1, wherein when the definition is stored, the call description is detected as a call description of an assembler template function. 3. The template storage unit stores, for each definition of the assembler template function, condition information indicating a condition for an argument to the function, if there is one. 3. The program conversion device according to claim 1, wherein the selection is performed according to a description of an argument to a function included in the call description in accordance with the condition information. 4. The condition information is information indicating that an argument must be an immediate value, and the selecting means is, according to the condition information, a description of an argument to a function included in the call description is an immediate value. 4. The program conversion device according to claim 3, wherein the selection is made according to whether or not the program is executed. 5. The condition information is information indicating that an argument must be an immediate value within a predetermined range value, and the selecting means, in accordance with the condition information, transmits an argument to a function included in the call description. 5. The program conversion device according to claim 4, wherein the selection is performed according to whether the description is an immediate value within a predetermined range. 6. The template storage unit also stores, for each definition of the assembler template function, an evaluation value serving as a criterion for selecting an optimum one. 3. The program conversion device according to claim 1, wherein the selection is performed based on an evaluation value. 7. The template storage unit stores, for each of the definitions, information indicating the number of execution cycles for an assembler code specified by the definition as the evaluation value. 7. The program conversion device according to claim 6, wherein one of the definitions to be converted into assembler code having the minimum number of execution cycles is selected. 8. The template storage unit stores, for each of the definitions, information indicating a code size of an assembler code specified by the definition as the evaluation value. 7. The program conversion device according to claim 6, wherein one definition to be converted into assembler code having the smallest code size is selected. 9. The method according to claim 8, wherein the selecting unit converts a code for setting an argument into a register and a code for saving and restoring a register when the call description is supposed to be converted into assembler code specified by each of the definitions. 3. The method according to claim 1, wherein if there is a necessary code, the selection is performed by making a determination based on the number of execution cycles or the code size of the code resulting from the conversion including the code. The program conversion device according to the above. 10. A recording program for recording a control program for causing a computer having a memory for storing a plurality of definitions of assembler template functions to execute a program conversion process for converting a source program described in a high-level language into assembler code. A medium, wherein the program conversion processing includes: a call detection step of detecting a call description of an assembler template function in the source program; and when the call description is detected by the call detection step, the program conversion process is stored in the memory. A selecting step of selecting an optimum one of a plurality of definitions of an assembler template function called by the call description; and calling the call description detected by the call detecting step to the assembler selected by the selecting step. Te Recording medium, characterized in that it comprises a conversion step of converting the assembler code based on the definition of the plate function.