JP2003044289A - Compilation method, compiler, recording medium storing the compiler, storage device storing object code prepared by compilation method and processor provided with the storage device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a compilation method and a compiler for converting a user program so as to control the heat generation of a target system to a stipulated value or less. SOLUTION: A normal assembler string is prepared for a user program SC by using various kinds of parameters and a provisional object code OC2 is outputted to the SC. By temporarily executing the provisional object code OC2 while referring to the table of the heat generation vs. an order or the like, a profile PF is prepared and outputted. Then, whether or not the prepared assembler string satisfies the temperature condition of hardware is determined on the basis of the profile PF, and if not satisfying the temperature condition, an optimization object part is found inside the provisional object code OC2 on the basis of the profile PF and an optimization processing for which the heat generation is taken into consideration is performed.

Description

Detailed Description of the Invention

[0001]

The present invention relates to a compiling method,
The present invention relates to a compiler, a recording medium that stores the compiler, a storage device that stores an object code created by a compiling method, and a processor that includes the storage device. Targets the function of the compiler that converts to.

[0002]

2. Description of the Related Art Semiconductor devices such as microprocessors are
With the recent increase in frequency, the amount of heat generated from the element tends to increase. When the temperature of the element rises, the semiconductor device may cause a temporary malfunction or semi-permanent failure. In order to avoid such a problem, conventionally, the following measures have generally been taken.

(1) The temperature of an element is prevented from exceeding a specified temperature even when the amount of heat generated from the element is maximized by subjecting a semiconductor device to sufficient heat treatment and providing a heat dissipation device. (2) The operating frequency of the device is lowered under the constraint that the heat radiation amount of the device is constant. (3) The temperature rise of the element is monitored, and the operating frequency of the equipment is dynamically reduced when the temperature rises above the specified temperature.

[0004]

However, the above-mentioned countermeasures have the following problems, respectively. That is,
Since the measure (1) generally involves an increase in cost, it is difficult to adopt it in a device for general consumers, especially in a home game machine.

Regarding measures (2) and (3),
Although hardware that realizes this has existed in the past, when the operating frequency according to the amount of heat radiation is managed by the OS, the degree of freedom decreases, while the user must create a program that explicitly controls the temperature. Had the problem that it would impose an excessive burden.

The present invention has been made in view of the above circumstances, and an object thereof is to compile a user program into an object code so that the amount of heat generated by an element or a device becomes a specified value or less, a compiler, and this compiler. Another object of the present invention is to provide a recording medium in which is stored, a storage device in which an object code created by a compiling method is stored, and a processor including the storage device.

[0007]

SUMMARY OF THE INVENTION The present invention solves the above problems by statically controlling heat generation of a processor and a system including the processor by software.

That is, according to the present invention, a procedure for receiving a user program to tentatively generate an object code that can be interpreted by the target hardware, and a case where the hardware executes the tentative object code In the procedure of calculating the heat generation amount generated from the hardware, a step of determining whether the calculated heat generation amount satisfies the temperature condition of the hardware, and if the heat generation amount does not satisfy the temperature condition, A procedure of finding an optimization target portion that produces a relatively large heat generation amount in the provisional object code, and a procedure of performing an optimization process for suppressing the heat generation amount with respect to the optimization target portion; A compiling method comprising is provided.

According to the compiling method, a procedure for performing optimization processing for suppressing the heat generation amount on the optimization target portion is provided, so the compilation method for automatically controlling the heat generation from the hardware. Will be provided.

Further, according to the present invention, there is provided a compiler for causing a computer to execute the above-described compiling method according to the present invention.

According to the present invention, there is also provided a recording medium storing the above compiler.

Further, according to the present invention, there is provided a storage device for storing the object code generated by the compiling method and subjected to the optimization processing.

Further, according to the present invention, there is provided a processor including the above storage device.

[0014]

DETAILED DESCRIPTION OF THE INVENTION Some embodiments of the present invention will be described below with reference to the drawings. First, an example of a heat generation mode of a semiconductor device to which the compiling method according to the present invention is applied will be described with reference to the drawings.

FIG. 1 is a graph showing the heat generation amount per unit cycle of one semiconductor chip used in a certain game machine. For this semiconductor chip, the total heat generation amount H1 and the limit peak heat generation amount H2 allowed at each time interval are set as shown in FIG. In the case of this semiconductor chip, the total heat generation amount exceeds the allowable amount H1 in the time interval TI0, and the heat generation amount exceeds the limit peak heat generation amount H2 in a certain time zone within the time interval TI1. If such a state is left as it is, there is a possibility that a temporary malfunction of the game machine may occur, which may cause a failure of the game machine, so it is necessary to suppress the heat generation of the chip. One feature of the present invention is that an instruction or an instruction sequence (hereinafter,
(For example, an instruction), the margin of the processing time is determined, and when the processing has a leeway in time and the temperature is to be suppressed, for example, an instruction to activate the function of suppressing heat generation is added, and, for example, The point is to select a subroutine that generates less heat. As a result, the best performance is obtained in the critical part of the process, and at the same time, the temperature of the equipment is controlled so that it is within the range that meets the specifications.

(1) Embodiment of Compiler First, an embodiment of a compiler according to the present invention will be described with reference to FIG. FIG. 2 is a schematic diagram for explaining the general function of one embodiment of the compiler according to the present invention. The compiler 2 of this embodiment is executed by a computer (not shown) including an auxiliary storage device. The libraries L2 to L8 are connected to this computer. The library L2 stores various parameters necessary for compilation. These parameters include the target system's critical temperature and the expected temperature during program execution. The library L4 calculates the amount of heat generated by the processor in the chip when the instruction or the like is executed.
A table of heat generation amount vs. instruction, etc., which is calculated and obtained in advance by the D tool or simulation at the time of design is stored.
The library L6 stores a low-power subroutine, and the library L8 stores a subroutine for high-speed operation. As a subroutine for high speed operation,
For example, there is a function that provides a high-quality image in image processing but generates a large amount of heat. As a low-power subroutine, for example, there is a function capable of suppressing the heat generation amount although the image quality is slightly inferior in image processing. In addition, if the processor itself has a hardware function, prepare a special instruction for lowering the frequency and power supply voltage of the processor or a special instruction for reducing the number of processing pipes in advance in the low power subroutine. Is also good. The handling of these subroutines will be described in detail later.

The compiler 2 takes in various parameters from the library L2, creates a normal assembler string for the user program SC as a source code, and outputs it as a temporary object code OC2. Next, the compiler 2 tentatively executes the provisional object code OC2 and creates a profile PF in which the heat generation amount is described corresponding to each instruction while referring to the table of the heat generation amount vs. instruction of the library L4. Based on this profile PF, the compiler 2 causes the temporary object code OC2 to generate heat in excess of the limit peak heat generation amount, and a code part in which heat exceeds the total heat generation amount in each interval (hereinafter referred to as an optimization target portion). ) To discover. When the user explicitly specifies in advance that the amount of heat generation is more important than the processing speed in the program, the compiler 2 prompts the user to perform optimization processing on the optimization target portion. If there is no explicit designation by the user, the compiler 2 fetches various subroutines from the libraries L6 and L8, and executes temperature optimization processing considering the heat generation amount for the optimization target portion while utilizing these subroutines. . The compiler 2 repeats the above processing until the provisional object code satisfies the temperature condition of the target element or the like, and outputs the provisional object code satisfying the temperature condition as the final object code OC4. More specific functions of the compiler 2 shown in FIG. 2 will be described below as some of the embodiments of the compiling method according to the present invention.

(2) First Embodiment of Compiling Method First, a first embodiment of the compiling method according to the present invention will be described with reference to FIGS. Figure 3
3 is a flowchart showing a schematic procedure of a compiling method of the present embodiment. First, the compiler 2 fetches various parameters from the libraries L2 and L4 (step S1). Next, the compiler 2 creates a normal assembler string for the user program SC and outputs it as the provisional object code OC2 (step S2).
Next, the compiler 2 creates and outputs the profile PF by tentatively executing the provisional object code OC2 while referring to the above-described table of heat generation amount vs. instruction (step S3). This profile PF contains
The data of the predicted peak calorific value and the data of the total calorific value associated with each subroutine at the time of temporary execution are described.
Then, the compiler 2 determines whether the created assembler string satisfies the temperature condition based on the profile PF (step S4). If the temperature condition is satisfied, it is not necessary to optimize the object code, so it is confirmed that the processing by the created assembler string is completed within a predetermined time (step S11), and this assembler string is finally processed. The object code OC4 is output and the compiling operation is completed.

When the created assembler string does not satisfy the temperature condition, the compiler 2 finds the optimization target part in the temporary object code OC2 based on the profile PF (step S5). As described above, when the user explicitly specifies the optimization target part in advance (step S6), the compiler 2 instructs the optimization target part (step S7) and prompts the user to perform optimization processing ( Step S8). FIG. 4 shows a specific example of the optimization target portion designated by the user. In the program shown in the figure, "begin low_power" and "end low_power" are compiler directives (directives), and the program part "bar ();" enclosed between them gives priority to temperature over processing speed. It shows that it optimizes. Compiler 2 if the optimization target part is not specified by the user in advance
FIG. 5 shows an example of a method for finding the relevant portion. 9A shows an example of the main function in the user program, and FIG. 8B shows it in the profile PF as shown in FIG.
Shows the maximum value of total calorific value in each interval associated with each function in the main function. As shown in FIG. 5B, the maximum total calorific value of the bar function is 100, the maximum total calorific value of the barbar function is 10, and the maximum total calorific value of the barbarbar function is 20. . Here, for example, when the total heat generation amount 100 exceeds the allowable total heat generation amount H1 (see FIG. 1) of the processor, the bar function is instructed to give priority to the temperature, that is, the low heat generation amount over the processing speed. Will be optimized.

Referring again to FIG. 3, when the optimization target part is not explicitly designated in advance by the user (step S6), the compiler 2 optimizes the optimization target part in consideration of the temperature rise by the part. Execute the conversion process. That is, the compiler 2 refers to the data of the predicted peak heat generation amount and the total heat generation amount for each subroutine described in the profile PF for the optimization target portion found in step S5, and stores the data in the library L6 (see FIG. 2). The optimum subroutine is selected from the stored plurality of low power subroutines (step S9). Next, compiler 2
Replaces each subroutine with the selected low-power subroutine to rearrange the instruction sequence (step S1).
0). FIG. 6 is a schematic diagram for explaining a specific example for selecting the optimum subroutine. In this example, the processor
This is an example of the case where an arithmetic unit for processing a complicated arithmetic operation such as sqrt (√) is included. Low power library L6 (see Figure 2)
In the library L8 (see FIG. 2), a single precision version of the subroutine used when the calculation precision is not taken into consideration is stored. On the other hand, in the library L8, the double precision version of the subroutine when the calculation precision is prioritized is stored. ing. As shown in the figure, the compiler 2 allocates the optimum library or subroutine according to the situation. Such a mapping process is particularly advantageous in the case of a graphic processor, in the case of an operation in which the heat generation amount is severe from the allowable value, but the image may be slightly rough.

Returning to FIG. 3, the compiler 2 executes the temporary execution again on the rearranged instruction sequence, and repeats the above procedure until the temperature condition is satisfied (steps S3 to S1).
0). When the temperature condition is satisfied by these procedures (step S4), the compiler 2 confirms that the process by the last rearranged instruction sequence is completed within a predetermined time (step S11). If the processing is completed within a predetermined time, both the processing speed and the heat generation match the specifications of the processor, so the final instruction string is output as the final object code OC4, and the compilation operation is terminated. If the processing is not completed within the predetermined time, both the processing speed and heat generation do not satisfy the processor specifications.
Indicates an optimization target portion, outputs an error (step S12), and ends the operation. In this way, even if the object code that satisfies the specifications of the processor in both the processing speed and the heat generation amount cannot be obtained, the problematic optimization target part is shown to the user. It is possible to start reviewing the user program without having to search for. In the present embodiment, the mode in which the optimization process is executed by the subroutine has been described, but the present invention is not limited to this, and optimization may be performed using a finer grain size than that of the subroutine, for example. This point is the same for the second to fourth embodiments described below.

(3) Second Embodiment of Compilation Method Next, a second embodiment of the compilation method according to the present invention will be described with reference to FIGS. 7 and 8. The present embodiment is a suitable mode when the processor that executes the object code or the system including the processor has a function of reducing the frequency and the power supply voltage.
FIG. 7 is a flowchart for explaining the general procedure of the compiling method of this embodiment. As is clear from the comparison with FIG. 3, the feature of this embodiment lies in step S26 representing the procedure for optimizing the program. Therefore, in the following, the description will focus on step S26.

That is, similar to the first embodiment, various parameters are fetched (step S11), a normal assembler string is created for the user program SC, and the provisional object code OC2 is output (step S22).
Next, the compiler 2 creates and outputs the profile PF by tentatively executing the provisional object code OC2 while referring to the table of heat generation amount vs. instruction and the like (step S23). Subsequently, the compiler 2 determines whether the created assembler string satisfies the temperature condition based on this profile PF (step S24).
When the created assembler string does not satisfy the temperature condition, the compiler 2 finds the optimization target part in the temporary object code OC2 based on the output profile PF (step S25).

In this embodiment, the compiler 2 automatically inserts an instruction or the like for suppressing the heat generation amount (step S2).
6). FIG. 8 shows a specific example in which the compiler 2 inserts an instruction or the like for suppressing the heat generation amount. Block B shown at the top of the figure
L2 is a block in which heat generation becomes a problem in the bar function, and is an example of an optimization target portion discovered by the compiler 2. As shown in the lower part of FIG. 8, in this embodiment, the compiler 2 adds the special instructions lowpwr and normal to the entry and exit of the bar function of the block BL2. Here, the lowpwr instruction is an instruction for reducing the frequency and the power supply voltage, and the normal instruction is an instruction for restoring the changed frequency and power supply voltage. As described above, according to the present embodiment, when the processor or the system has the function of reducing the frequency or the power supply voltage, the instruction or the like for suppressing the heat generation amount is inserted in the assembler string, so that the heat generation of the device is facilitated. Can be suppressed.

(4) Third Embodiment of Compiling Method Next, a third embodiment of the compiling method according to the present invention will be described with reference to FIGS. 9 to 11. The present embodiment is suitable for a processor having a plurality of pipelines and a pipeline in which the heat generation amount when the use is stopped is set to be smaller than the heat generation amount when the use is performed. It is a form. Such processors are typically superscalar processors or V
An example is a LIW processor. FIG. 9 is a flowchart for explaining the general procedure of the compiling method of this embodiment. Similar to the above-described third embodiment, the feature of this embodiment lies in step S46 representing the optimization processing procedure of the program. Since the other procedures of this embodiment are substantially the same as those of the second embodiment shown in FIG. 7, step S46 will be mainly described below.

First, as in the second embodiment, the compiler 2 takes in various parameters (step S4).
1) After creating a normal assembler string for the user program SC and outputting the provisional object code OC2 (step S42), the provisional object code OC2 is provisionally executed while referring to the table of heat generation amount vs. instruction. , A profile PF is created and output (step S
43). Then, the compiler 2 uses the profile P
Based on F, it is determined whether the created assembler string satisfies the temperature condition (step S44). If the created assembler string does not meet the temperature conditions, the compiler 2
Finds an optimization target part in the provisional object code OC2 based on the output profile PF (step S45). As a result, if the calorific value exceeds the limit value at a certain interval, the compiler 2
Stops issuing instructions to some of the plurality of pipelines, and further adds instructions for suppressing heat generation (step S46). 10 and 11 are schematic diagrams for specifically explaining the procedure of step 46. FIG. 10 shows operation modes of two pipelines (a pipe 0 and a pipe 1) included in a processor having a function of suppressing heat generation by receiving a nop instruction or the like. If it is found from the information of the profile PF that the heat generation amount exceeds the limit value at intervals T2 and T3, the compiler 2
Adds an instruction or the like that stops issuing instructions to the pipeline 1 to suppress heat generation. In the concrete example shown in FIG.
The compiler 2 changes the instruction from the dual issue mode for issuing an instruction or the like for operating the two pipes independently to the single issue mode for issuing an instruction or the like for operating only a single pipe. FIG. 11 shows FIG.
0 shows an operation of pipelines 0 and 1, (a) shows an operation in a dual issue mode, (b) shows an operation in a single issue mode, and (c) shows Shows a state in which the nop instruction is inserted by the compiler 2.

As described above, according to the compiling method of this embodiment, when the target hardware has a pipeline in which the amount of heat generation is suppressed during the suspension of use, the instruction for changing the operation mode is provided. Since, for example, is inserted, the object code that suppresses the heat generation amount of the device can be easily generated.

(5) Fourth Embodiment of Compiling Method Next, a fourth embodiment of the compiling method according to the present invention will be described with reference to FIG. The present embodiment is a compiling method when the procedure shown in FIG. 1 is applied to a multiprocessor system. Therefore, the description of the general procedure is omitted, and the optimization method (step S9 in FIG. 1) will be mainly described below.

Normally, in a multiprocessor system, the processing is different for each processor, so that it is necessary to synchronize the processors in each part of the program. Therefore, in a program part sandwiched between a certain synchronization time point and the next synchronization time point, a processor with light processing (short processing time) operates as a processor with heavy processing (long processing time) in the same program portion. Have to wait until the end. At this time, if the amount of heat generated is large enough to affect the normal operation of the entire device in a processor with light processing, select an instruction or subroutine that emphasizes the amount of heat generated rather than an instruction that emphasizes processing speed. It is desirable to let The feature of the compiling method of the present embodiment is that, when the optimization target part corresponds to the part waiting for synchronization and there is no problem even if the processing speed is reduced, the command of the part is an instruction that emphasizes the heat generation amount. Etc. or in the point of substituting a subroutine

FIG. 12 is a schematic diagram showing the heat generation amount generated when a certain object code is executed by a multiprocessor including processors A, B and C, in comparison with that before and after the optimization processing. As shown on the left side of the figure, in the multiprocessor shown in this example, the processors B,
Since the processing of C is lighter than that of processor A, C waits for synchronization until the processing of processor A ends. On the other hand, the heat generation amounts between the synchronization points of the processors B and C are 100 and 130, including the synchronization waiting state, which affects the normal operation of the entire device.

The compiler 2 uses the processors B,
An instruction sequence is generated for the C user program so that the heat generation amount is reduced at the expense of the processing speed. The heat generation amount after such optimization processing is shown on the right side of FIG. Due to the optimization processing, the processing speeds of the processors B and C became slower, but the heat generation amounts between the synchronization points were 50 and 60, respectively.
It can be seen that the heat generation amount of the entire device is significantly reduced.

As described above, according to the present embodiment, since the object code is generated by giving priority to the smaller heat generation amount than the processing speed for the extra synchronization waiting program portion, the hardware resources are effectively used. A compile method for suppressing the amount of heat generation while utilizing it is provided.

(6) Recording Medium The compiler described above may be stored in a storage medium such as a floppy (registered trademark) disk or a CD-ROM, and may be read by a computer and executed. As a result, the compiling method according to the present invention can be realized using a general-purpose computer. The recording medium is not limited to a portable medium such as a magnetic disk or an optical disk, and may be a fixed storage medium such as a hard disk device or a memory. Also,
The compiler described above may be distributed via a communication line (including wireless communication) such as the Internet. Further, the above-described compiler may be distributed in a state of being encrypted, modulated, or compressed via a wired line or a wireless line such as the Internet or stored in a storage medium.

(7) Storage Device and Processor The object code generated by the above-mentioned compilation method or compiler may be stored in a storage device and executed by the processor. When the processor has a built-in storage device, the object code generated by the above-described compilation method or compiler may be stored in this internal storage device and executed by the processor. As a result, a storage device or processor that can suppress the amount of heat generation while effectively utilizing hardware resources is provided.

[0035]

As described above in detail, the present invention has the following effects. That is, according to the present invention, there are provided a compiling method capable of suppressing heat generation from hardware, a compiler causing a computer to execute the compiling method, and a recording medium storing the compiling method.

Further, according to the present invention, since the object code generated by the above-described compiling method and subjected to the optimization processing is stored, a storage device capable of suppressing the heat generation amount of hardware within its specification range is provided. .

Further, according to the present invention, since the above-described storage device is provided, a processor that operates stably without generating heat beyond the specification range is provided.

[Brief description of drawings]

FIG. 1 is a graph showing a heat generation amount per unit cycle of one semiconductor chip used in a game machine.

FIG. 2 is a schematic diagram illustrating general functions of an embodiment of a compiler according to the present invention.

FIG. 3 is a flowchart showing a schematic procedure of a first embodiment of a compiling method according to the present invention.

FIG. 4 is a diagram showing a specific example of an optimization target portion designated by a user.

5A shows an example of a main function in a user program, and FIG. 5B shows the maximum total heat generation amount in each interval associated with each function in the main function shown in FIG. Indicates a value.

FIG. 6 is a schematic diagram illustrating a specific example for selecting an optimum subroutine.

FIG. 7 is a flowchart illustrating a schematic procedure of a second embodiment of a compiling method according to the present invention.

8 is a diagram specifically illustrating a flow of inserting an instruction or the like for suppressing the heat generation amount in the flow shown in FIG. 7. FIG.

FIG. 9 is a flowchart illustrating a schematic procedure of a third embodiment of a compiling method according to the present invention.

10 is a schematic diagram illustrating a main part of the compiling method illustrated in FIG.

FIG. 11 is a schematic diagram for explaining an essential part of the compiling method shown in FIG.

FIG. 12 is a schematic diagram illustrating a fourth embodiment of a compiling method according to the present invention.

[Explanation of symbols]

2 compiler BL2 block L2, L4, L6, L8 library OC2, OC4 object code PF profile SC user program T0, T1, T2, T3 time interval

Continued front page    (72) Inventor Yu Yamazaki             1st Komukai Toshiba-cho, Sachi-ku, Kawasaki-shi, Kanagawa             Ceremony Company Toshiba Microelectronics Sen             Inside F-term (reference) 5B081 CC24 CC30

Claims (12)

[Claims] 1. A procedure for tentatively generating an object code interpretable by a target hardware in response to a user program, and resulting from the hardware when the tentative object code is executed by the hardware. A step of calculating a heat generation amount, a step of determining whether or not the calculated heat generation amount satisfies the temperature condition of the hardware, and the provisional object code when the heat generation amount does not satisfy the temperature condition A compiling method comprising: a step of finding an optimization target portion that produces a relatively large amount of heat generation in the inside; and a step of performing an optimization process for suppressing the heat generation amount on the optimization target portion. 2. The step of determining whether or not the temperature condition is satisfied includes a step of comparing the heat generation amount with at least one of a limit heat generation amount and an allowable total heat generation amount of the hardware. The compiling method according to Item 1. 3. The method further comprises the step of previously creating a table of heat generation amount vs. instruction in which the heat generation amount is associated with each instruction or instruction sequence constituting the user program, and the step of calculating the heat generation amount is the heat generation amount. 3. The compiling method according to claim 1, which is a procedure for calculating the heat generation amount from the provisional object code with reference to a paired instruction table. 4. A profile representing heat generation characteristics of the temporary object code in which a heat generation amount is described for each of the instructions or instruction strings forming the temporary object code by referring to the table of heat generation amount vs. instruction. Further comprising a procedure for creating, the step of calculating the heat generation amount is a step of calculating the heat generation amount generated from the hardware based on the profile, the step of discovering the optimization target portion, in the profile 4. The compiling method according to claim 3, further comprising a step of finding a portion in which the heat generation amount can be prioritized over the execution processing speed in the provisional object code based on the basis. 5. The optimizing process further comprising a step of preliminarily classifying and preparing an instruction or an instruction sequence that can be replaced with an instruction or an instruction sequence forming the provisional object code according to the amount of heat generation. The procedure of performing includes the step of selecting an instruction or an instruction sequence that contributes to the suppression of the heat generation amount from the substitutable instruction or instruction sequence, and replacing the optimization target part with the selected instruction or instruction sequence. The compiling method according to any one of claims 1 to 4, which is characterized in that: 6. The hardware has a function of reducing a heat generation amount, and in the procedure of performing the optimization processing, an instruction or an instruction sequence for causing the hardware to execute the function is stored in the optimization target portion. The compiling method according to any one of claims 1 to 5, characterized in that the compiling method includes a procedure of inserting before and after. 7. The user program includes the instruction or the instruction string to which a directive indicating that the heat generation amount is prioritized over the execution speed at the time of compilation is added by the user in advance. 5. The compiling method according to claim 1, further comprising a step of prompting a user to perform an optimization process on an instruction or an instruction string to which the directive is added. 8. The step of finding the optimization target portion, the step of performing the optimization process, and the step of calculating the heat generation amount are repeated until the temperature condition is satisfied. 8. The compiling method according to any one of Items 1 to 7. 9. A compiler that causes a computer to execute the compiling method according to claim 1. Description: 10. A recording medium in which a compiler for causing a computer to execute the compiling method according to claim 1 is stored. 11. A storage device for storing an object code generated by the compiling method according to claim 1 and subjected to the optimization processing. 12. A processor comprising a storage device for storing an object code generated by the compiling method according to claim 1 and subjected to the optimization processing.