JP2014044678A - Compiler evaluation device, method, and program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a compiler evaluation technique which allows a single compiler to check whether or not a source program and an execution program match with each other.SOLUTION: A compiler evaluation device 10 includes: a first holding unit 11 that holds a source program which is described in a programming language; a second holding unit 12 that holds an execution program into which the source program has been compiled so as to be executed by a processor; a test data generation unit 15 that generates test data on the basis of at least either the source program or execution program; a third holding unit 13 that holds the test data and transmits it to execution means (a target CPU 21) of the execution program; an interpreter 17 that inputs the test data and executes the source program; and a determination unit 18 that compares an execution result of the execution means (the target CPU 21) and an execution result of the interpreter 17 and determines whether they match with each other.

Description

  The present invention relates to a compiler evaluation technique for compiling a source program into an execution program.

It is desirable that a source program written in a programming language be compiled into an execution program that can be directly understood by the target machine, with the contents completely matched.
The match or mismatch between the source program and the execution program compiled from the source program can be confirmed as follows, for example.

That is, a plurality of source program compilers are prepared, and a plurality of execution programs that operate in different operating environments are generated. Then, it is possible to indirectly detect a compiler bug by giving the same input value to a plurality of generated execution programs and comparing the obtained output values.
In these two types of compilers, it is very unlikely that the same bug exists at a common location. For this reason, if there is a discrepancy in the output results, the presence of a bug in one of the compilers is estimated (for example, Patent Documents 1 and 2).

JP-A-2005-141406 JP 2004-227129 A

The above-described confirmation work of matching / mismatching between the source program and the execution program requires two types of compilers from different manufacturers that are expected to have mismatched bug positions.
However, depending on the CPU, it may be difficult to obtain two types of compilers in this way. In this case, it is impossible to confirm the match / mismatch between the source program and the execution program.

  The present invention has been made in consideration of such circumstances, and an object of the present invention is to provide a compiler evaluation technique capable of confirming the match / mismatch between a source program and an execution program with a single compiler.

  In the compiler evaluation apparatus, a first holding unit for holding a source program described in a programming language, a second holding unit for holding an execution program compiled so that the source program can be executed by a processor, the source program, and the A test data generation unit that generates test data based on at least one of the execution programs, a third holding unit that holds the test data and sends the test data to the execution unit of the execution program, and inputs the test data to the source program An interpreter to be executed, and a determination unit that determines whether or not the execution result of the execution unit of the execution program and the execution result of the interpreter match are determined.

  According to the present invention, there is provided a compiler evaluation technique capable of confirming a match / mismatch between a source program and an execution program with a single compiler.

1 is a block diagram showing a compiler evaluation apparatus according to a first embodiment of the present invention. The figure which shows an example of the function which comprises a source program. The figure which shows the execution program corresponding to the function of the source program shown in FIG. The flowchart which shows the algorithm of the test data generation part in 1st Embodiment. The table | surface which shows the test data in 1st Embodiment. The flowchart which shows the algorithm of an interpreter. The flowchart which shows the algorithm of a determination part. The table | surface which shows the determination result based on the test data in 1st Embodiment. The flowchart which shows the algorithm of the test data generation part in 2nd Embodiment. The table | surface which shows the test data in 2nd Embodiment. The table | surface which shows the determination result based on the test data in 2nd Embodiment. The block diagram which shows the compiler evaluation apparatus which concerns on 3rd Embodiment of this invention. The flowchart which shows the algorithm of the target CPU emulator in 3rd Embodiment. The block diagram which shows the compiler evaluation apparatus which concerns on 4th Embodiment of this invention. The block diagram which shows the modification of the compiler evaluation apparatus which concerns on 4th Embodiment. The figure which shows an example of the source program in which the internal range (a, b) was set. The figure which shows an example of the execution program in which the comparison range (A, B) was set. The flowchart which shows the algorithm of the range setting part in 4th Embodiment. The table | surface which shows the determination result of the execution result in the program (range a, A) by which the range was set in 4th Embodiment. The table | surface which shows the determination result of the execution result in the program (range b, B) by which the range was set in 4th Embodiment. The flowchart which shows the algorithm of the range setting part in 5th Embodiment. The table | surface which shows the determination result of the execution result in the program (range a, A) by which the range was set in 5th Embodiment. The table | surface which shows the determination result of the execution result in the program (range b, B) by which the range was set in 5th Embodiment. (A) The figure which shows the algorithm which extracts an input variable from an execution program in the method of extracting an input variable from an execution program, (B) The example which extracts the input variable from an execution program in the method of extracting an input variable from an execution program is shown Figure.

(First embodiment)
Hereinafter, embodiments of the present invention will be described with reference to the accompanying drawings.
As shown in FIG. 1, a compiler evaluation apparatus 10 according to the first embodiment includes a first holding unit 11 that holds a source program described in a programming language, and an execution program that is compiled so that the source program can be executed by a processor. A second holding unit 12 that holds the test data, a test data generation unit 15 that generates test data based on at least one of the source program and the execution program, and execution means (target CPU 21) for holding the test data and executing the program Whether or not the third holding unit 13 to be sent out, the interpreter 17 that inputs test data and executes the source program, and the execution result of the execution means (target CPU 21) of the execution program and the execution result of the interpreter 17 match. A determination unit 18 for determining That.

The first holding unit 11 externally inputs and holds a source program described in a programming language.
FIG. 2 shows an example of a function constituting the source program, and FIG. 3 shows an execution program corresponding to the function of the source program shown in FIG.

The source program is created on the assumption that the programmer reads and writes, and is configured by arranging a plurality of functions in units of functions that execute a series of processes.
The function is a combination of program paths defined by if, while, do-while, for, switch, etc., receives an input variable, and delivers an execution result.

The compiler 14 acquires a source program from the first holding unit 11 and compiles it into an execution program that can be executed by the processor (target CPU 21).
Since the processor cannot directly understand the source program, processing is performed by an execution program represented by binary code as shown in FIG.

The test data generation unit 15 in the first embodiment generates test data (FIG. 5) based on a combination of input variables (int a, int b) extracted in units of functions (FIG. 2) constituting the source program. Is.
Then, the generated test data (FIG. 5) is held in the third holding unit 13.

The algorithm of the test data generation unit 15 in the first embodiment will be described based on the flowchart of FIG. 4 (see FIGS. 1 and 2 as appropriate).
The test data generation unit 15 reads the source program from the first holding unit 11 (S11), and extracts input variables (int a, int b) of the source program (S12).

  Then, the execution program is read from the second holding unit 12 (S13), and the input variables (R1, R2) of the execution program are extracted (S14).

  FIG. 24A is a diagram showing an algorithm for extracting input variables from the execution program. As shown in FIG. 24A, the execution program is disassembled, the source program and the execution program are compared, and the input variable of the execution program corresponding to the input variable of the source program is determined.

  FIG. 24B is a diagram illustrating an example of extracting input variables from the execution program. As in the example of FIG. 24B, the assembler corresponding to “c = 0” is “LDI R10,0”, c and R10 are corresponding, and the assembler corresponding to “a ++” is “ADDI R1, R1,” The assembler corresponding to “while (a <b)” is “CMP R1, R2”, and b and R2 are determined to correspond to “while (a <b)”.

  Furthermore, as shown in FIG. 5, the test data generation unit 15 outputs test data for all combinations of input variables (S15).

When variables a and b are 8 bits, the range of values of variables a and b is -128 to +127, so all combinations of input variables are
(a, b): (-128, -128), (-128, -127), ..., (+ 127, + 127)
It becomes. The test data is required to be 2 to the 16th power.

If the variables a and b are 16 bits, the range of values of the variables a and b is -32768 to +32767, so all combinations of input variables are
(a, b): (-32768, -32768), (-32768, -32767), ..., (+ 32767, + 32767)
It becomes. Test data is required to be 2 to the power of 32.

The test data can be generated based on one of the input variables extracted from the source program and the execution program by the method described above.
In FIG. 5, a part of the large number of test data is shown.

The third holding unit 13 sends the held test data to the interpreter 17 and execution program execution means (target CPU 21).
Execution means (target CPU 21) of the execution program in the first embodiment is provided in the external device 20.
For this purpose, the compiler evaluation apparatus 10 according to the first embodiment is connected to the external device 20 to determine whether the source program and the execution program match.

The target CPU 21 acquires an execution program from the second holding unit 12 and inputs and executes a plurality of test data having different combinations of input variables from the third holding unit 13. Then, the target CPU 21 outputs this execution result to the determination unit 18.
The interpreter 17 acquires a source program from the first holding unit 11 and inputs and executes a plurality of test data having different combinations of input variables from the third holding unit 13. Then, the interpreter 17 outputs the execution result to the determination unit 18.

The algorithm of the interpreter 17 will be described based on the flowchart of FIG. 6 (see FIG. 1 as appropriate).
The interpreter 17 reads the source program from the first holding unit 11 (S21), performs syntax analysis of the source program, and generates an intermediate code (S22).
The interpreter 17 reads the test data from the third holding unit 13 (S23), executes the intermediate code (S24), and outputs the execution result to the determination unit 18 (S25).

The determination unit 18 compares the execution result of the execution means (target CPU 21) of the execution program and the execution result of the interpreter 17 to determine whether or not they match.
Here, among the execution results for a plurality of test data, in order to compare the execution results of the source program and the execution program for the same test data, the same test data is sequentially input to the source program and the execution program. It is possible to apply a method of comparing the execution results in order, or a method of sorting and comparing the execution results of the source program and the execution program with respect to the same test data by adding test data identification information to the effective results. it can.

  Then, the determination unit 18 transmits a determination result of coincidence or mismatch to the result output unit 19, and further transmits a determination result as to whether or not the compiler 14 includes a bug based on the determination result to the result output unit 19. .

The algorithm of the determination part 18 is demonstrated based on the flowchart of FIG. 7 (refer FIG.1 and FIG.8 suitably). Here, FIG. 8 is a table showing determination results based on the test data in the first embodiment.
The determination unit 18 executes the execution results (c, R10) of the test data having the same combination of input variables ([int a, int b], [R1, R2]) from the execution means (target CPU 21) and the interpreter 17 of the execution program. ) Are read (S31).
Then, these two execution results (c, R10) are compared to determine whether or not they match (S32), and a determination result of “match” or “mismatch” is output (S33, S34).
If even one of the generated test data results in a “mismatch” determination, it is certified that the compiler 14 contains a bug, and if all match, it is certified that no bug is found, A message to that effect is displayed (S35).

(Second Embodiment)
Next, a second embodiment of the present invention will be described with reference to FIG.
Note that in the compiler evaluation apparatus 10 in the second embodiment, the other configurations except for the operation of the test data generation unit 15 are the same as those in the first embodiment, and thus redundant description is omitted.

The test data generation unit 15 in the second embodiment generates test data (FIG. 10) based on a combination of execution or non-execution of program paths extracted in units of functions (FIG. 2) constituting the source program. is there.
Here, the program path is an instruction that controls the execution order of data processing defined by if, while, do-while, for, switch, and the like.

Based on the flowchart of FIG. 9, the algorithm of the test data generation part 15 in 2nd Embodiment is demonstrated (refer FIG. 1 suitably).
Here, steps S41 to S44 in FIG. 9 correspond to steps S11 to S14 in FIG.

The structure analysis of the program path defined by if, switch, while, do-while, for, etc., constituting the function of the source program is performed (S45).
For variables used for conditional branching of the control structure, test data for executing all program paths is generated. In this case, a method that uses a value that randomly assigns a value and executes all program paths, a method that obtains a value that executes all program paths from conditional branch conditions, and the like are used.
Then, as shown in FIG. 10, the test data generation unit 15 outputs corresponding test data for all combinations of execution or non-execution of the program path (S46).

Based on the flowchart of FIG. 7, the algorithm of the determination part 18 in 2nd Embodiment is demonstrated (refer FIG.1 and FIG.11 suitably). FIG. 11 is a table showing determination results based on test data in the second embodiment.
The determination unit 18 executes test data having the same combination of program path execution or non-execution ([int a, int b], [R1, R2]) from the execution means (target CPU 21) and the interpreter 17 of the execution program. Each result (c, R10) is read (S31).

Then, these two execution results are compared to determine whether or not they match (S32), and a determination result of “match” or “mismatch” is output (S33, S34).
If even one of the generated test data results in a “mismatch” determination, it is certified that the compiler 14 contains a bug, and if all match, it is certified that no bug is found, A message to that effect is displayed (S35).
According to the second embodiment, it is possible to reduce the number of test data for performing a match / mismatch determination, and it is possible to simplify recognition of whether or not a bug is included in the compiler 14.

(Third embodiment)
Next, a third embodiment of the present invention will be described with reference to FIG.
The compiler evaluation apparatus 10 according to the third embodiment is the same as the first embodiment and the second embodiment except that the execution unit of the execution program is an emulator 22 built in to emulate the target CPU. Common with form. In FIG. 12, parts having the same configuration or function as those in FIG. 1 are denoted by the same reference numerals, and redundant description is omitted.

  The emulator 22 acquires an execution program from the second holding unit 12 and inputs a plurality of test data from the third holding unit 13 for execution. Then, the emulator 22 outputs the execution result to the determination unit 18.

The algorithm of the emulator 22 of the target CPU will be described based on the flowchart of FIG. 13 (see FIG. 12 as appropriate).
The emulator 22 reads the execution program from the second holding unit 12 (S51). Then, the test data is read from the third holding unit 13 and the execution program is executed (S52), and the execution result is output to the determination unit 18 (S53).
According to the third embodiment, it is possible to determine the match / mismatch between the source program and the execution program with only one computer.

(Fourth embodiment)
Next, a fourth embodiment of the present invention will be described with reference to FIG.
FIG. 14 is a block diagram showing the basic configuration of the compiler evaluation apparatus in the fourth embodiment, and FIG. 15 shows a modification of the fourth embodiment. 14 and 15 correspond to FIGS. 1 and 12, respectively.
In FIGS. 14 and 15, portions having the same configuration or function as those in FIGS. 1 and 12 are denoted by the same reference numerals, and redundant description is omitted.

  The compiler evaluation apparatus 10 according to the fourth embodiment sets an internal range (a, b) of a function (FIG. 16) constituting a source program and also executes the execution program (FIG. 16) corresponding to the internal range (a, b). A range setting unit 16 for setting the comparison range (A, B) of 17) is further provided.

  Based on the flowchart of FIG. 18, the algorithm of the range setting part 16 in 4th Embodiment is demonstrated (refer FIG. 14 suitably). Note that FIG. 19 shows the determination result of the match / mismatch of the execution results in the range-set program (range a, A) in the fourth embodiment, and FIG. 20 shows the execution result in the range-set program (range b, B). Match / mismatch judgment results are shown.

The range setting unit 16 reads the source program from the first holding unit 11 (S61), and sets the internal range (a, b) of the function (S62).
Examples of the method for setting the internal range include a method of specifying a #pragma instruction in the source program, a method of specifying a file in what number line to what line of the source program, and the like.
Then, the execution program is read from the second holding unit 12 (S63), and the comparison range (A, B) of the execution program corresponding to the internal range (a, b) is set (S64).

The test data generation unit 15 generates test data based on at least one of the internal range (a, b) of the source program and the comparison range (A, B) of the execution program.
According to the fourth embodiment, since the internal range is further set in the functions constituting the program, it is possible to reduce the number of test data for determining match / mismatch, and whether or not the compiler 14 includes a bug. Can be simplified.

(Fifth embodiment)
Next, a fifth embodiment of the present invention will be described with reference to FIG.
In the compiler evaluation apparatus 10 according to the fifth embodiment, the range setting unit 16 (FIGS. 14 and 15) has an internal range (a, b: FIG. 16) and a comparison range (A, B) with the program path of the source program as a unit. : Except for the point of setting FIG. 17), the other configurations are the same as those in the fourth embodiment, and thus redundant description is omitted.

  Based on the flowchart of FIG. 21, the algorithm of the range setting part 16 in 5th Embodiment is demonstrated (refer FIG. 14 suitably). FIG. 22 shows the determination result of the match / mismatch of the execution results in the range-set program (range a, A) in the fifth embodiment, and FIG. 23 shows the execution result in the range-set program (range b, B). Match / mismatch judgment results are shown.

The range setting unit 16 reads the source program from the first holding unit 11 (S71), and extracts the program path defined by if, switch, while, do-while, for, etc. that constitutes the function of the source program (S72). ).
Then, the execution program is read from the second holding unit 12 (S73), and the comparison range (A, B) of the execution program corresponding to the internal range (a, b) is set (S74).

The test data generation unit 15 generates test data based on at least one of the internal range (a, b) of the source program and the comparison range (A, B) of the execution program.
According to the fifth embodiment, since an internal range is further set for each function constituting the program in units of program paths, the number of test data for determining match / mismatch can be reduced, and the compiler 14 has a bug. It can simplify the certification of inclusion.

  According to the compiler evaluation apparatus of at least one embodiment described above, a compiler bug can be obtained by comparing the execution result directly obtained from the source program with the execution result directly obtained from the execution program against the generated test data. It becomes possible to evaluate the presence or absence of.

Although several embodiments of the present invention have been described, these embodiments are presented by way of example and are not intended to limit the scope of the invention. These embodiments can be implemented in various other forms, and various omissions, replacements, changes, and combinations can be made without departing from the scope of the invention. These embodiments and their modifications are included in the scope and gist of the invention, and are also included in the invention described in the claims and the equivalents thereof.
The components of the compiler evaluation apparatus can be realized by a computer processor and can be operated by a compiler evaluation program.

  DESCRIPTION OF SYMBOLS 10 ... Compiler evaluation apparatus, 11 ... 1st holding | maintenance part, 12 ... 2nd holding | maintenance part, 13 ... 3rd holding | maintenance part, 14 ... Compiler, 15 ... Test data generation part, 16 ... Range setting part, 17 ... Interpreter, 18 ... Determination unit, 19 ... result output unit, 20 ... external device, 21 ... target CPU, 22 ... emulator.

Claims (8)

A first holding unit for holding a source program written in a programming language;
A second holding unit holding an execution program compiled so that the source program can be executed by a processor;
A test data generation unit that generates test data based on at least one of the source program and the execution program;
A third holding unit for holding the test data and sending it to the execution means of the execution program;
An interpreter for inputting the test data and executing the source program;
A compiler evaluation apparatus comprising: a determination unit that compares the execution result of the execution unit of the execution program and the execution result of the interpreter to determine whether or not they match.   The compiler evaluation apparatus according to claim 1, wherein the test data generation unit generates the test data based on a combination of input variables extracted in units of functions constituting the source program.   The compiler evaluation apparatus according to claim 1, wherein the test data generation unit generates the test data based on a combination of execution or non-execution of a program path extracted with a function constituting the source program as a unit.   4. The compiler evaluation apparatus according to claim 1, wherein the execution unit of the execution program is an emulator built in to emulate a target CPU or the target CPU provided in an external device. 5. . A range setting unit for setting an internal range of functions constituting the source program and setting a comparison range of the execution program corresponding to the internal range;
5. The compiler evaluation apparatus according to claim 1, wherein the test data generation unit generates test data based on at least one of an internal range of the source program and a comparison range of the execution program.   The compiler evaluation apparatus according to claim 5, wherein the range setting unit sets the internal range and the comparison range in units of a program path of the source program. Holding a source program written in a programming language;
Holding an execution program compiled so that the source program can be executed by a processor;
Generating test data based on at least one of the source program and the execution program;
Holding the test data and sending the test data to the execution means of the execution program;
Inputting the test data and executing the source program;
And comparing the execution result of the execution program and the execution result of the source program to determine whether or not they match each other. On the computer,
Holding a source program written in a programming language;
Holding an execution program compiled so that the source program can be executed by a processor;
Generating test data based on at least one of the source program and the execution program;
Holding the test data and sending the test data to the execution means of the execution program;
Inputting the test data and executing the source program;
A compiler evaluation program for executing the step of comparing the execution result of the execution program and the execution result of the source program to determine whether or not they match.

Images