JPH08305579A - Compiler processing system - Google Patents

Abstract

PURPOSE: To provide the compiler processing system in which branch predict accuracy of branch information is improved and an object program with a high execution efficiency is generated. CONSTITUTION: A compiler 102 generates a 1st object program 103 from a source program 101. Then the compiler 102 generates branch information 104a generated at execution of the 1st object program 103 and a 2nd object program 105 on which an object code to collect the branch information 104a is reflected.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a compiler processing method for creating an object program based on a source program by a compiler.

[0002]

2. Description of the Related Art In recent years, many processors support a pipeline mechanism by dividing an instruction execution process into a plurality of execution parts in order to speed up the process. In the case of a CPU having a pipeline mechanism, the number of instructions input per unit time can be increased and the instruction processing speed can be increased.

However, there are various hazards in the pipeline mechanism. These are called pipeline hazards, and these pipeline hazards are described, for example, on pages 98 to 100 of "Computer Architecture Principles Corona Publishing Co.," issued August 20, 1993.

As one of these pipeline hazards, there is a control hazard in which the next instruction changes due to a conditional branch and causes a contradiction with the instruction fetched in advance. To solve this, there is a delayed branch method. There are two techniques of branch prediction.

Among these methods, the branch prediction method predicts the branch direction in advance and fetches an instruction in the predicted direction. In that case, branch information is required. . As a method of obtaining branch information, there are a method of setting by hardware inside the processor and a method of giving it from the outside.

In the case where the branch information is externally provided, the compiler determines the branch information when compiling the source program. Such a conventional method will be described below with reference to the drawings.

FIG. 3 is a block diagram showing the flow of processing in the conventional compiler processing method. In FIG. 3, 301 is a source program, 302 is a compiler, 303 is branch information, 304 is a branch information file, 3
Reference numeral 05 is an object program.

The flow of the compiler processing method represented by the above blocks will be described below. In FIG. 3, the compiler 302 includes the source program 3
It is assumed that 01 is input. Inside the compiler 302, the branch information 303 is generated in the branch information file 304 based on the source code of the source program 301 input to the compiler 302.
Outputs an object program 305 including an instruction code reflecting the branch information 303.

[0009]

However, in the conventional compiler processing method as described above, the branch information 303
Is the source program 3 input to the compiler 302
Since it is generated inside the compiler 302 based on the 01 source code, the branch prediction accuracy of the branch information 303 is low.

Therefore, since the branch information 303 is reflected in the instruction code output from the compiler 302, the compiler 302 also outputs the object program 305 including the instruction code with low execution efficiency. Was.

In view of the above problems, the present invention provides a compiler processing method capable of improving the accuracy of branch prediction of branch information and generating an object program consisting of an instruction code with high execution efficiency. To aim.

[0012]

In order to achieve the above object, the compiler processing method according to claim 1 of the present invention is based on a source program given to a processor which can interpret a branch instruction by the compiler. In a compiler processing method for creating an object program readable by a processor, the compiler decomposes the source program into lexical parts, and a lexical analysis part for analyzing the lexical parts, and a result lexically analyzed by the lexical analysis part. A syntax analysis unit that recognizes a syntax based on the syntax and generates an intermediate code corresponding to the source program, a code generation unit that generates an instruction code corresponding to the intermediate code from the syntax analysis unit, and a code generation unit. The executed instruction code was branched when the branch instruction included in the source program was executed. An information collection instruction generation unit for adding an instruction for collecting branch information indicating whether or not the branch information generation unit generates a branch instruction including the branch information in the instruction code when the code generation unit generates the instruction code. Section and independent operation means for independently operating the information collection instruction generation section and the branch instruction generation section, and are generated by the source program and the first object program generated by the compiler from the source program. Second based on the branch information by the compiler.
The object program of is generated.

[0013]

According to the method of the first aspect, the compiler generates the first object program from the source program.

Then, the compiler generates a second object program in which the branch information generated when the first object program is executed and the object code for collecting the branch information are reflected.

[0015]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS A compiler processing system according to an embodiment of the present invention will be described below with reference to the drawings.

FIG. 1 is a block diagram showing the flow of processing in the compiler processing method of this embodiment. In FIG. 1, 101 is a source program, 102 is a compiler, 103 is a first object program, 10
Reference numeral 4 is a branch information file, and 105 is a second object program.

The flow of the compiler processing method represented by the above blocks will be described below. In FIG. 1, the compiler 102 includes a source program 1
It is assumed that 01 is input. The compiler 102 uses the source code included in the input source program 101 to generate the first object program 10
3 is output. First object program 103
Executes the operation specified by the source program 101 and generates the branch information file 104 at the time of its execution.

The branch information file 104 records branch information 104a indicating whether or not a branch condition is actually satisfied and a branch operation is performed when the first object program 103 executes a branch instruction. An example of the branch information 104a recorded in the branch information file 104 is shown in FIG.

In FIG. 2, as the branch information 104a,
In one line of the branch information file 104, an address 104b in the first object program 103 of the executed branch instruction, a content 104c of the branch instruction, a jump destination address 104d due to the branch, and success / failure information 104e of the branch operation are recorded. This branch information 104a is updated every time a branch instruction is executed.

Branch information 104a configured as described above
Is read together with the first object program 103, and the second object program 105 is output.

The second object program 105 generated from the compiler 102 in this way is the first object program 105.
Information 10 when executing the object program 103 of
4a and the object code that collects the branch information 104a are reflected, so the instruction code includes the branch information 104a with high branch prediction accuracy.

Next, the compiler 102 will be described based on its internal configuration with reference to FIG. FIG. 4 is a block diagram showing the configuration of the compiler in the compiler processing method of this embodiment. In FIG. 4, 401 is a source program, 402 is a compiler, 411 is a lexical analysis unit, 412 is a syntax analysis unit, 413 is a code generation unit, 4
14 is a branch instruction generation unit, 415 is an information collection instruction generation unit,
405 is an object program.

The operation of the compiler 402 having the above components will be described below. In FIG. 4, the compiler 402 inputs the source program 401 and generates an object program 405.

The above generation processing is performed by the lexical analysis unit 411, the syntax analysis unit 412, the code generation unit 413, the branch instruction generation unit 414, and the information collection instruction generation unit 415 shown in FIG.

The branch instruction generation unit 414 generates branch information based on the branch information file 404, and generates a branch instruction including this branch information in the instruction code output from the code generation unit 413.

The information collection instruction generation unit 415 also generates an instruction for collecting branch information indicating whether or not a branch was taken when the branch instruction was executed. The generated instructions collect branch information at the time of execution, create a branch information file for recording the branch information, and record the collected branch information.

Further, the branch instruction generation unit 414 and the information collection instruction generation unit 415 can be set externally so as to operate independently, and can be designated when the compiler is started. As described above, in the present embodiment, the compiler 102 generates the first object program 103 from the source program 101, and the compiler 1
02, the branch information 104a generated at the time of execution of the first object program 103 and the branch information 10
A second object program 105 that reflects the object code for collecting 4a is generated.

Therefore, it is possible to improve the accuracy of branch prediction of the branch information 104a, and it is possible to generate the second object program 105 composed of an instruction code with high execution efficiency.

In the above embodiment, the branch information file for storing the branch information is provided in the processor as the branch information storage location, and the branch instruction generation unit creates a branch instruction that does not include the branch information and stores the branch information. An instruction to be stored in the branch information storage location in the processor may be generated.

Further, in each of the above embodiments, the compiler may create the second object program execution file for executing the second object program based on the first object program and the branch information. .

Further, in each of the above embodiments, the first object program may be generated by using a compiler existing independently of the compiler generating the second object program.

[0032]

As described above, according to the present invention, the compiler generates the first object program from the source program, and the compiler further generates branch information generated when the first object program is executed and the branch information. It is possible to generate the second object program that is reflected by the object code for collecting information.

Therefore, the accuracy of branch prediction of branch information can be improved, and the second object program composed of an instruction code with high execution efficiency can be generated as an object program readable by the processor.

[Brief description of drawings]

FIG. 1 is an explanatory flowchart of a compiler processing method according to an embodiment of the present invention.

FIG. 2 is an explanatory diagram of branch information of the same embodiment.

FIG. 3 is a flow explanatory diagram of a conventional compiler processing method.

FIG. 4 is a configuration diagram of a compiler in the compiler processing method according to the embodiment of this invention.

[Explanation of symbols]

 101 Source Program 102 Compiler 103 First Object Program 104 Branch Information File 105 Second Object Program 411 Lexical Analysis Section 412 Syntax Analysis Section 413 Code Generation Section 414 Branch Instruction Generation Section 415 Information Collection Instruction Generation Section

Claims (4)

[Claims] 1. A compiler processing method for creating an object program readable by the processor based on a source program provided to a processor capable of interpreting a branch instruction by the compiler, wherein the compiler makes the source program lexical. Decomposes, a lexical analysis unit that analyzes the lexical phrase, recognizes the syntax based on the result of the lexical analysis in the lexical analysis unit, and a syntax analysis unit that generates intermediate code corresponding to the source program,
A code generation unit that generates an instruction code corresponding to the intermediate code from the syntax analysis unit, and whether the instruction code generated by the code generation unit is branched when a branch instruction included in the source program is executed. And an information collecting instruction generating section for adding an instruction for collecting branch information, and a branch instruction generating section for generating a branch instruction including the branch information in the instruction code when the code generating section generates the instruction code. And an independent operation means for independently operating the information collection instruction generation unit and the branch instruction generation unit, and the branch generated by the source program and the first object program generated from the source program by the compiler. A compiler processing method for generating a second object program by the compiler based on the information. 2. The compiler processing method according to claim 1, wherein the branch instruction generation unit generates a branch instruction that does not include branch information, and generates an instruction that stores the branch information in a branch information storage location in a processor. 3. The compiler process according to claim 1, wherein the compiler creates a second object program execution file that executes the second object program based on the first object program and the branch information. method. 4. The first object program, the second object program
The compiler processing method according to any one of claims 1 to 3, wherein the compiler program is generated using a compiler that exists independently of the compiler that generates the object program.