JP6326838B2 - Program processing apparatus, program processing method, and program processing program - Google Patents

Description

  The present invention relates to a program processing apparatus, a program processing method, and a program processing program capable of performing processing on a source code or intermediate code of a program.

  Converting a program into another program, intermediate code, executable file or the like so that the program can be executed more efficiently is called program optimization (hereinafter, also simply referred to as “optimization”). For example, a programmer may perform optimization by rewriting a program.

  On the other hand, compilers that convert program source code into object code that can be executed by a computer often have an optimization function that converts the program into object code that can be executed more efficiently. There are also conversion tools that read source code and output optimized source code. Such optimization using a compiler or conversion tool is important for improving the efficiency of program development by eliminating the need for optimization by a programmer. In the following description, tools or devices that perform predetermined processing on a program, such as optimization by a compiler or a conversion tool, are collectively referred to as “program processing tools” or “program processing devices”.

  Among the optimizations, there is optimization across a plurality of procedures (functions etc.) in the program. Optimization across multiple procedures is called “interprocedural optimization”. For example, there is an optimization in which a caller function is optimized using information on processing performed in another function called from a certain function.

  Interprocedural optimization will be described using an example of optimization that performs constant propagation. Note that “constant propagation” is an optimization in which a variable determined to be a constant is replaced with a constant in a preparation stage before starting the program, such as during compilation. The program T in FIG. 15A includes a function mul that returns a multiplication result of two arguments, and a function main that calls mul. Since the argument passed to mul when the function mul is called is a constant, it is understood that the return value of the function is 6 before the function mul is executed by propagating the argument. Accordingly, as shown in FIG. 15B, the program processing tool does not need to call and multiply the function mul at the time of execution by replacing the call of the function mul in the function main with the multiplication result 6. Optimize to

  Normally, a compiler compiles source code for each file. When there is a function definition for both the calling side and the called side of the function that is the target of interprocedural optimization in one file, the compiler uses the information obtained by analyzing the function definition. , The calling function can be optimized. However, if each of the calling and called function definitions of the function that is the target of interprocedural optimization is described in a separate file, the compiler must optimize the calling function. In addition, information on a function such as a function definition on the called side (for example, information on processing contents of the function) cannot be used. Therefore, there is a problem that the compiler cannot perform sufficient optimization.

  For example, in the example of FIG. 16, the function mul is described in separate files “source1.c” and “source2.c”. Therefore, when compiling the user program V, the compiler cannot use information described in the library program W that “the function mul is a process for returning a multiplication result for an argument”. For this reason, the compiler cannot perform constant propagation across a plurality of functions.

  In order to solve such a problem, some compilers have a function of embedding a part of information obtained by analyzing the source code in the generated object code. Some linkers perform optimization using information embedded in the object code when the object code is linked.

  An example of a technique for performing interprocedural optimization using analysis information of a source code embedded in an object code is disclosed in Patent Document 1.

  The system of Patent Document 1 operates as follows.

  The compiler of Patent Document 1 generates an object file including global register information from a source file. “Global register information” is information for associating a global symbol defined or referenced in a source file with a global register. A “global symbol” is a symbol (such as a variable) that is defined in a certain module (for example, one source file) and is referenced from another module. The “global register” is a register accessible from an arbitrary procedure (function or the like).

  The linker of Patent Document 1 uses global register information included in a plurality of object files generated by the compiler to perform register allocation, and then links the object files to generate an executable file. “Register allocation” is an optimization in which a large number of variables in a program are multiplexed into a small number of registers in the CPU.

  As a result of the above operation, the system of Patent Document 1 performs interprocedural optimization across a plurality of functions by using the analysis information of the source code embedded in the object file.

  If information is embedded in the object code, the size of the object code increases, and the embedded information may be limited to information with less information than information obtained by analyzing the source code. Therefore, when analysis information is embedded in the object code, there is a problem that sufficient optimization is difficult. There is also a problem that the object code cannot be optimized when the analysis information is not embedded in the object code.

  By the way, programs are often developed using libraries. A “library” is object code in which source code of a program that performs a specific process is compiled in advance. Further, the library may include a header file corresponding to a specific process (hereinafter referred to as “library procedure”) included in the library. A user program that uses a library (a program that calls a library procedure and is not included in the library) can use the library procedure by linking with the object code of the library. Note that information on whether or not a procedure is a library procedure may be obtained from library procedure list information (hereinafter referred to as “procedure list”) such as a library header file.

  Since the library is provided as object code, the compiler cannot use the source code of the library when compiling the user program. Therefore, there is a problem that sufficient optimization cannot be performed between the function of the user program and the function of the library as described above. In order to use the analysis information embedded in the object code for optimization, the analysis information needs to be embedded when compiling the library. However, in general, the library is developed by a developer different from the developer of the user program. Furthermore, the compiler and linker used for linking user programs are often unknown when compiling the library, and different compilers and linkers are often used for different user programs. Therefore, there is a problem that it is difficult for a library developer to embed analysis information corresponding to an individual compiler or an individual linker in an object code of the library. Further, as described above, there is also a problem that sufficient optimization cannot be performed with the analysis information embedded in the object code.

  Some compilers have a plug-in function. The “plug-in function” is a function in which a certain program starts another program (plug-in) that satisfies a certain specification. By using plug-ins, it is possible to extend the functions originally implemented in the program. A compiler that supports the plug-in function includes GNU gcc. By using a compiler plug-in, new functions can be introduced into the compiler without changing the compiler itself.

JP 2000-10791 A (page 4-6, FIGS. 1 and 10)

  The compiler of Patent Document 1 analyzes source code and generates object code in which information for register allocation is embedded. Information for register allocation is compact information that is generally inherent in the source code.

  However, in interprocedural optimization when calling a library function in a user program, for example, a part of code that calls a library procedure (function, etc.) based on the processing contents of the called library function (hereinafter referred to as “library procedure call”). "Code") may be replaced with optimized code. Since the operation of replacing the library procedure call code with the optimized code depends on the individual processing contents of the library procedure, it is difficult to express information for optimization in a compact manner. That is, it is difficult to embed in the object code information for additional processing to the library procedure call code in the user program, such as interprocedural optimization between the library and the user program.

Therefore, the technology of Patent Document 1 provides additional processing such as advanced interprocedural optimization between the library and the user program, that is, the library is the library procedure call code in the user program. There is a problem that it is difficult to provide additional processing depending on the processing contents of individual procedures.
(Object of invention)
An object of the present invention is to provide a program processing apparatus, a program processing method, and a program capable of providing an additional process in which a library depends on the processing content of each procedure of the library to a library procedure call code in a user program. To provide a processing program.

  The program processing apparatus of the present invention specifies a plug-in that is an executable program that performs processing on a code including a call instruction of a procedure included in a library, provided with the library, and first code of a user program including the call instruction And a user program processing means for instructing execution of the specified plug-in, and a plug-in starting means for starting the plug-in instructed to execute by designating the first code as a processing target. Features.

  The program processing method of the present invention specifies a plug-in that is an executable program that performs processing on a code including a call instruction of a procedure included in a library, provided with the library, and first code of a user program including the call instruction Is obtained, the execution of the specified plug-in is instructed, the first code is designated as a processing target, and the instructed execution is started.

  The program processing program of the present invention specifies a plug-in, which is an executable program that performs processing on a code including a procedure call instruction of a library provided in a library provided by a computer included in the program processing apparatus. User program processing means for acquiring a first code of a user program including the user program and instructing execution of the specified plug-in, and a plug for starting the plug-in instructed to execute by designating the first code as a processing target It functions as an in-starting means.

  According to the present invention, there is an effect that it is possible for the library to provide an additional process depending on the processing contents of each procedure of the library to the library procedure call code in the user program.

It is a block diagram which shows an example of a structure of the program processing apparatus in the 1st Embodiment of this invention. It is a block diagram which shows an example of a hardware configuration in case the program processing apparatus in the 1st Embodiment of this invention is a specific apparatus. It is a flowchart which shows operation | movement of the user program processing means of the program processing apparatus in the 1st Embodiment of this invention. It is a figure for demonstrating the specific example of the process sequence of the program processing apparatus in the 1st Embodiment of this invention. It is a block diagram which shows an example of a structure of the program processing apparatus in the 2nd Embodiment of this invention. It is a flowchart which shows operation | movement of the user program processing means of the program processing apparatus in the 2nd Embodiment of this invention. It is a figure for demonstrating the specific example of the process sequence of the program processing apparatus in the 2nd Embodiment of this invention. It is a block diagram which shows an example of a structure of the program processing apparatus in the 3rd Embodiment of this invention. It is a figure which shows operation | movement of the program processing apparatus in the 3rd Embodiment of this invention. It is a figure for demonstrating the specific example of the process sequence of the program processing apparatus in the 3rd Embodiment of this invention. It is a figure for demonstrating the user program and library program in another specific example of the process sequence of the program processing apparatus in the 3rd Embodiment of this invention. It is a figure for demonstrating the non-optimized program and the optimized program in another specific example of the process sequence of the program processing apparatus in the 3rd Embodiment of this invention. It is a block diagram which shows an example of a structure of the program processing apparatus in the 4th Embodiment of this invention. It is a block diagram which shows an example of a structure of the program processing apparatus in the 5th Embodiment of this invention. It is a figure for demonstrating the specific example of interprocedural optimization. It is a figure for demonstrating the problem of interprocedural optimization.

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings. In all the drawings, equivalent components are denoted by the same reference numerals, and description thereof will be omitted as appropriate.
(First embodiment)
A configuration in the present embodiment will be described.

  FIG. 1 is a block diagram showing an example of the configuration of the program processing apparatus 100 in the present embodiment.

  The program processing apparatus 100 in this embodiment uses a library 200.

  The library 200 includes a procedure code 220 and a plug-in 210.

  The library 200 may further include a header file 230. The procedure code 220 is a code of a procedure (function or the like; hereinafter referred to as “library procedure”) provided by the library 200. The code of the library procedure is, for example, object code or source code.

  The header file 230 is a file including a library procedure and a type declaration of an external variable.

  The plug-in 210 is a program that can be started from the program processing apparatus 100 and is written according to a specific interface specification. The plug-in 210 is, for example, a program that can be executed alone or a dynamic link library that is called after being dynamically linked to the program. The plug-in 210 is not limited to one having a specific form, and is an arbitrary program that performs processing on a user program code that can be activated from the program processing apparatus 100 and calls a library procedure.

  The program processing apparatus 100 designates a source code that calls a library procedure, or an intermediate code converted from the source code (hereinafter, the source code and the intermediate code are collectively referred to as “source code” for the sake of simplicity) The plug-in 210 is activated. The plug-in 210 performs predetermined processing on the source code passed from the program processing apparatus 100. The predetermined processing executed by the plug-in 210 includes arbitrary processing including, but not limited to, conversion, optimization, verification, and the like for the source code. The plug-in 210 may return the processing result to the program processing apparatus 100.

  The plug-in 210 includes procedure call code processing means 240. The procedure call code processing means 240 processes the code including the library procedure call in the source code by using the passed source code information and information on the processing contents of the library. The processing executed by the procedure call code processing means 240 includes arbitrary processing including, but not limited to, conversion, optimization, verification and the like for the library procedure call code in the source code.

  The program processing apparatus 100 according to the present embodiment is, for example, a compiler, a compiler component, or a single tool, that is, a program that performs a predetermined conversion process. Alternatively, the program processing apparatus 100 may be an apparatus such as a computer that performs conversion processing including compilation. In the present embodiment, the function realized by the program processing apparatus 100 is characterized, and it is not an essential problem whether the program processing apparatus 100 is an intangible program or a tangible apparatus.

  The program processing apparatus 100 is not limited to a specific type of tool. The program processing apparatus 100 includes user program processing means 120 and plug-in activation means 110.

  The user program processing means 120 reads the name for identifying the plug-in 210 and the source code of the user program. A user program is a program that calls a library procedure. The user program processing unit 120 instructs the plug-in activation unit 110 to activate the plug-in 210 corresponding to the library procedure based on the name of the loaded plug-in 210 with respect to the loaded source code.

  The plug-in activation unit 110 passes the source code of the user program to the designated plug-in 210 and activates the plug-in 210.

  FIG. 2 is a block diagram illustrating an example of a hardware configuration when the program processing apparatus 100 according to the present embodiment is a specific apparatus.

  The program processing device 11 includes a storage device 12, a CPU (Central Processing Unit) 13, a keyboard 14, a monitor 15, and an I / O (Input / Output) 18, which are connected via an internal bus 16. Yes. The storage device 12 stores an operation program for the CPU 13 such as the plug-in activation unit 110. The CPU 13 controls the entire program processing device 11, executes an operation program stored in the storage device 12, and executes programs such as the plug-in activation means 110 and transmits / receives data via the I / O 18. The internal configuration of the program processing apparatus 11 is an example. The program processing apparatus 11 includes only the CPU 13, the storage device 12, and the I / O 18, and may operate using a keyboard 14 and a monitor 15 that are provided outside.

  Next, the operation in this embodiment will be described.

  FIG. 3 is a flowchart for explaining the operation of the user program processing means 120 of the program processing apparatus 100 in the present embodiment.

  The user program processing means 120 reads the name of the plug-in 210 of the library 200 (step S11).

  The user program processing means 120 reads the source code of the user program (step S12). In addition, the execution order of step S11 and step S12 is an example, and is not limited to this. For example, after the process of step S12 is started, the process of step S11 may be started, or the process of step S11 and the process of step S12 may be executed in parallel.

  The user program processing means 120 instructs the plug-in activation means 110 to activate the plug-in 210 whose name has been read for the read source code (step S14).

  Next, a specific example of the processing procedure in the present embodiment will be described.

  FIG. 4 is a diagram for explaining a specific example of the processing procedure of the program processing apparatus 100 in the present embodiment.

  FIG. 4A shows a source code (“source.c”: “user program A”) of the user program in this embodiment, and FIG. 4B shows a command for starting the program processing apparatus 100 in this embodiment. FIG. 4C shows the source code (“library_source.c”: “library program C”), which is the procedure code 220 of the library 200 in this embodiment, and FIG. An error message that is an execution result of the plug-in 210 is shown.

  First, the premise for explaining a specific example of the processing procedure in the present embodiment will be described.

  The plug-in 210 provided by the library 200 is an executable program that reads the user program A, checks the normality of the argument of the library procedure call code in the user program A, and outputs an error message if there is an abnormality.

  “Div” is a procedure name included in the procedure code 220 provided by the library 200. The library procedure “div” is a function that divides a first argument that is an integer by a second argument that is an integer. “Arg-verification” is the file name of the plug-in 210 provided by the library 200. The plug-in “arg-verification” confirms the normality of the argument of the code that calls the library procedure of the library 200.

  The correspondence relationship between the above-described library procedure and the plug-in function is an example, and the present invention is not limited to this. For a specific library, a plug-in that performs an additional process for a code that calls the library procedure may be specified. For example, for a code that calls an arbitrary library procedure provided by the library 200, one plug-in “arg-verification” performs individual processing that is not limited to checking the normality of an argument according to each library procedure. May be executed.

  In the third line of the user program A, the library procedure “div (2,0)” is called.

  The above is the premise in the following processing procedure. Next, the processing procedure will be described.

  The user program processing means 120 reads the command line (FIG. 4B) at the time of starting the program processing apparatus 100, and acquires the argument of the “-plugin” option in the command line, thereby determining the name of the plug-in 210. Obtain (step S11). The user program processing unit 120 stores that the plug-in “arg-verification” is a plug-in of the library 200.

  The user program processing means 120 reads the source code of the user program (step S12).

  The user program processing means 120 instructs the plug-in activation means 110 to activate the plug-in 210 “arg-verification” of the library 200 (step S14).

  The plug-in activation unit 110 passes the source code of the user program A to the designated plug-in “arg-verification” and activates the plug-in “arg-verification”.

  The plug-in “arg-verification” reads the passed user program A, checks the normality of the argument of the library procedure call code “div (2,0)” in the user program A, and if there is an error, an error message Is output. Specifically, since the first argument that is an integer cannot be divided by the second argument that is an integer, the plug-in “arg-verification” determines that there is an abnormality, and the error message “Error: Illegal arguments” : div (2,0) "is output.

  As described above, the program processing apparatus 100 according to the present embodiment passes the source code of the user program including the library procedure call code of the library 200 to the plug-in 210 specified by the command line when the program processing apparatus 100 is activated. Then, the plug-in 210 is activated. That is, the plug-in 210 can process the library procedure call code in the user program by using information on the processing contents of the library procedure. Therefore, the program processing apparatus 100 according to the present embodiment has an effect that the library can provide an additional process depending on the processing content of each procedure in the library for the library procedure call code in the user program. .

In the present embodiment, the case where the name of the plug-in is designated as a command line option for starting the program processing apparatus 100 has been described. However, the name of the plug-in in this embodiment does not necessarily have to be specified in the command line. The name of the plug-in in this embodiment may be specified in an information source (a file, a file under a specific folder, an environment variable, etc.) other than the command line. When the name of the plug-in is described in an information source different from the command line, the program processing apparatus 100 may acquire the name of the plug-in from another information source.
(Second Embodiment)
A configuration in the present embodiment will be described.

  FIG. 5 is a block diagram showing an example of the configuration of the program processing apparatus 104 in the present embodiment.

  The program processing apparatus 104 in this embodiment uses a library 204.

  The library 204 includes a procedure code 220, a procedure list 234, and a plug-in 210.

  The procedure list 234 is a list of library procedures. The procedure list 234 further includes information for specifying the plug-in 210 that performs the additional processing related to the library procedure. When a specific plug-in corresponds to a specific library procedure, the procedure list 234 may further include information associating the specific plug-in with a specific library procedure. The procedure list 234 is, for example, a library header file. However, the procedure list 234 is not limited to the library header file. The procedure list 234 may be an arbitrary information source (file, file under a specific folder, command line option, environment variable, etc.) that holds information for specifying a library procedure and a plug-in for the library procedure. The contents of the procedure list 234 may be distributed and held in a plurality of information sources (files, files under a specific folder, command line options, environment variables, etc.).

  The program processing device 104 activates the plug-in 210 by specifying a source code for calling a library procedure. The plug-in 210 performs predetermined processing on the source code passed from the program processing device 104.

  The program processing device 104 includes user program processing means 124 and plug-in activation means 110.

  The user program processing means 124 reads the procedure list 234 and the source code of the user program, and searches for a code including a library procedure call in the user program. The user program processing unit 124 activates the plug-in 210 corresponding to the library procedure based on the information of the plug-in 210 in the read procedure list 234 for the unprocessed code including the library procedure call. Instructs the plug-in activation means 110.

  Other components are the same as those in the first embodiment.

  Next, the operation in this embodiment will be described.

  FIG. 6 is a flowchart for explaining the operation of the user program processing means 124 of the program processing apparatus 104 in the present embodiment.

  The user program processing unit 124 reads the procedure list 234 of the library 204 (step S21).

  The user program processing means 124 reads the source code of the user program and searches for unprocessed code including library procedure calls in the user program (step S22). In addition, the execution order of step S21 and step S22 is an example, and is not limited to this. In step S22, a procedure list including the library procedure may be read before searching for a code including a call to a library procedure. For example, after the process of step S22 is started, the process of step S21 may be started, or the process of step S21 and the process of step S22 may be executed in parallel.

  The user program processing means 124 determines whether or not there is an unprocessed code including a library procedure call in the user program (step S23).

  If there is no unprocessed code including a library procedure call in the user program (step S23: No), the user program processing unit 124 ends the process.

  When the unprocessed code including the library procedure call in the user program is found (step S23: Yes), the user program processing means 124 specifies the unprocessed code including the library procedure call specified in the read procedure list 234. The plug-in activation means 110 is instructed to activate the plug-in 210 corresponding to (step S24).

  Next, a specific example of the processing procedure in the present embodiment will be described.

  FIG. 7 is a diagram for explaining a specific example of the processing procedure of the program processing apparatus 104 in the present embodiment.

  FIG. 7A shows the source code (“source.c”: “user program A”) of the user program in this embodiment, and FIG. 7B shows the procedure list 234 of the library 204 in this embodiment. The source code of the header file (“library_header.h”: “header file B”) is shown in FIG. 7C. The source code (“library_source.c”: below) is the procedure code 220 of the library 204 in this embodiment. , “Library program C”), FIG. 7D shows an error message that is an execution result of the plug-in 210 in this embodiment.

  First, the premise for explaining a specific example of the processing procedure in the present embodiment will be described.

  In the user program A, the following is described as an instruction for instructing inclusion of the header file B which is a procedure list.

#include <library_header.h>
The plug-in 210 provided by the library 204 is an executable program that reads the user program A, checks the normality of the argument of the library procedure call code in the user program A, and outputs an error message if there is an abnormality.

  In the header file B provided by the library 204, the following is described as the procedure list 234.

#pragma plugin div-verification div
“Div” is a procedure name included in the procedure code 220 provided by the library 204. The library procedure “div” is a function that divides a first argument that is an integer by a second argument that is an integer. “Div-verification” is the file name of the plug-in 210 provided by the library 204. The above description indicates that the plug-in “div-verification” corresponds to the library procedure “div”. The plug-in “div-verification” confirms the normality of the argument of the corresponding library procedure “div”.

  Note that the above-described association between the library procedure and the plug-in is an example, and the present invention is not limited to this. For a specific library procedure, a plug-in that performs the processing of the procedure may be specified. For example, one plug-in may be associated with all library procedures declared in the header file B, and one plug-in may execute individual processing corresponding to each library procedure.

  In the third line of the user program A, the library procedure “div (2,0)” is called.

  The above is the premise in the following processing procedure. Next, the processing procedure will be described.

  The user program processing means 124 reads the user program A and reads the header file B which is the procedure list 234 of the library 204 by processing the include directives in the user program A (step S21). When the user program processing means 124 reads the header file B of the library 204, the user program processing means 124 finds the “#pragma plugin” directive in the header file B, and the plug-in “div-verification” corresponds to the library procedure “div”. Remember.

  The user program processing means 124 reads the source code of the user program and searches for an unprocessed code including a call to the library procedure “div” in the user program (step S22).

  Since unprocessed code including a call to the library procedure “div” is found in the user program (step S23: Yes), the user program processing unit 124 uses the plug-in “div-verification corresponding to the library procedure“ div ”. "Is started to the plug-in starting means 110 (step S24). When one plug-in is associated with all the library procedures declared in the header file B, one plug-in may execute individual processing corresponding to each library procedure. Good.

  The plug-in activation unit 110 passes the source code of the user program A to the designated plug-in “div-verification”, and activates the plug-in “div-verification”.

  The plug-in “div-verification” reads the passed user program A, checks the normality of the argument of the library procedure call code “div (2,0)” in the user program A, and if there is an error, an error message Is output. Specifically, since the first argument that is an integer cannot be divided by the second argument that is an integer, the plug-in “div-verification” determines that there is an abnormality, and the error message “Error: Illegal arguments” : div (2,0) "is output.

  As described above, when the library procedure call code of the library 204 exists in the user program, the program processing apparatus 104 according to the present embodiment stores the user program in the plug-in 210 associated with the library procedure in the procedure list 234. And the plug-in 210 is activated. That is, the plug-in 210 can process the source code of the user program by using information regarding the processing contents of the library procedure. Therefore, the program processing apparatus 104 according to the present embodiment has an effect that the library can provide an additional process depending on the processing content of each procedure in the library for the library procedure call code in the user program. .

In the present embodiment, the case where the procedure list is described in the header file provided by the library has been described. However, the procedure list in this embodiment does not necessarily have to be described in the header file. The procedure list in this embodiment may be described in an information source (a file, a file under a specific folder, a command line option, an environment variable, etc.) different from the header file. When the procedure list is described in an information source different from the header file, the program processing apparatus 104 may read the procedure list from another information source.
(Third embodiment)
As an example of “processing” according to the present invention, an example of a program conversion apparatus that performs compilation, which is “conversion” from source code to object code, will be described as a third embodiment.

  FIG. 8 is a block diagram showing an example of the configuration of the program conversion apparatus 105 in the present embodiment.

  The program conversion apparatus 105 in this embodiment uses a library 205.

  The library 205 includes an object code 225, a header file 235, and a plug-in 215.

  The header file 235 includes an instruction sentence 255 that instructs activation of the plug-in 215.

  The plug-in 215 is a program that can be started from the compiler, which is described according to the interface specification defined by the compiler. The plug-in 215 is, for example, a program that can be executed alone or a dynamic link library that is called by being dynamically linked to the program. The plug-in 215 is not limited to one having a specific form, and is an arbitrary program that can be started from a compiler.

  The compiler activates the plug-in 215 by specifying the source code or the source code. The plug-in 215 optimizes the source code passed from the compiler and returns the optimization result to the compiler.

  Plug-in 215 includes optimization means 245. The optimization unit 245 optimizes the library procedure call code in the source code by using the passed source code information and information on the processing contents of the library.

  The instruction sentence 255 is a sentence for giving an instruction to the compiler described in the library program. The directive 255 in the header file 235 instructs the compiler to start the plug-in 215 provided by the library 205.

  The program conversion apparatus 105 in this embodiment is, for example, a compiler, a component of a compiler, or a single tool, that is, a program that performs a predetermined conversion process. Alternatively, the program conversion apparatus 105 may be an apparatus such as a computer that performs conversion processing including compilation. In the present embodiment, the function realized by the program conversion apparatus 105 is characterized, and it is not an essential problem whether it is an intangible program or a tangible apparatus.

  The program conversion apparatus 105 includes an instruction sentence processing unit 125 and a plug-in activation unit 115. The program conversion apparatus 105 may further include general components of other compilers.

  The instruction sentence processing unit 125 reads an instruction sentence (for example, the instruction sentence 255) in the source code (for example, the header file 235), and performs processing specified by the instruction sentence. The directive is, for example, a C language include directive. The instruction sentence processing unit 125 may have a function of processing an instruction sentence included in a general compiler. The instruction sentence processing unit 125 reads the instruction sentence 255 instructing activation of the plug-in 215 and instructs the plug-in activation unit 115 to activate the plug-in 215 specified by the instruction sentence 255. The instruction sentence processing unit 125 may have a function of processing other instruction sentences.

  The plug-in activation unit 115 passes the source code to the designated plug-in 215 and activates the plug-in 215. The plug-in activation unit 115 receives the optimized source code or intermediate code returned from the plug-in 215. In addition to the source code, the plug-in activation unit 115 may pass information analyzed by the compiler (for example, information related to variable dependency) to the plug-in 215.

  A compiler generally refers to a program that converts source code into object code, but a program that converts source code into another source code may also be referred to as a compiler. A program that converts source code into another source code is sometimes called a source-to-source compiler or preprocessor. The program conversion apparatus 105 may be a source-to-source compiler.

  Next, the operation in this embodiment will be described.

  FIG. 9 is a diagram for explaining the operation of the program conversion apparatus 105 in the present embodiment.

  In order to use the library 205, the source code of the user program 305 in this embodiment includes the header file 235 provided by the library 205. “Include” means that, for example, the header file 235 of the library 205 is handled by the program conversion apparatus 105 as if included in the source code of the user program 305 by an include directive in the program. .

  The instruction sentence processing means 125 of the program conversion apparatus 105 first processes the include instruction sentence in the user program 305. The instruction processing unit 125 reads the header file 235 of the library 205. Next, the instruction sentence processing unit 125 processes the instruction sentence 255 in the read header file 235. As described above, in the header file 235, the instruction statement 255 for instructing activation of the plug-in 215 is described. The instruction sentence processing unit 125 instructs the plug-in activation unit 115 to activate the plug-in 215 specified by the instruction sentence 255 as processing for the instruction sentence 255.

  The plug-in activation unit 115 activates the plug-in 215 in accordance with the plug-in specification of the compiler (program conversion device 105).

  The program conversion apparatus 105 continues processing as a compiler using the source code (or intermediate code) returned from the plug-in 215. The program conversion apparatus 105 generates an object code 405, links the generated object code 405 and the object code 225 provided by the library 205, and generates an execution program 605.

  Next, a specific example of the processing procedure in the present embodiment will be described.

  FIG. 10 is a diagram for explaining a specific example of the processing procedure of the program conversion apparatus 105 in the present embodiment.

  FIG. 10A shows the source code (“source.c”: “user program E”) of the user program 305 in this embodiment, and FIG. 10B shows the header file 235 of the library 205 in this embodiment. The source code (“library_header.h”: “header file F”) is shown in FIG. 10C, and the source code of the library 205 (“library_source.c”: “library program G”) in this embodiment is shown in FIG. FIG. 10D shows a source code (not shown; hereinafter referred to as “program H”) of a program in which the user program E in the present embodiment is optimized.

  First, the premise for explaining a specific example of the processing procedure in the present embodiment will be described.

  In the user program E, the following is described as an instruction for instructing inclusion of the header file F.

#include <library_header.h>
The plug-in 215 provided by the library 205 is an executable program that reads the user program E and outputs an optimized program H.

  In the header file F provided by the library 205, the following is described as an instruction statement 255 for instructing execution of the plug-in 215.

#pragma plugin mulexpanshion
“Mulexpansion” is the file name of the plug-in 215 provided by the library 205.

  The above is the premise in the following processing procedure. Next, the processing procedure will be described.

  The instruction sentence processing unit 125 reads the header file F of the library 205 by reading the user program E and processing the include instruction sentence in the user program E.

  When reading the header file F of the library 205, the directive processing means 125 finds the “#pragma plugin” directive in the header file F. When the instruction text processing unit 125 finds the “#pragma plugin” directive, it instructs the plug-in activation unit 115 to activate the plug-in 215 (mulexpansion).

  The plug-in activation means 115 searches for an execution file “mulexpansion” in the execution path, and if found, activates the plug-in mulexpansion with the following argument.

mulexpansion “source.c” “tmp.c”
Here, the first argument is the name of the source file (user program E), and the second argument is the file name in which the plug-in 215 stores the optimization result (program H).

  The plug-in mulexpansion analyzes the passed source code (user program E) and recognizes that the library function mul is called in the form of “mul (2,3)”. The plug-in mulexpansion performs constant propagation using the library function mul that is a function that multiplies the passed arguments, and outputs the optimized program H (“tmp.c”) (“tmp. The portion of c ″ that is not relevant to the present embodiment is omitted). Plug-in mulexpansion is created by library developers. Therefore, it is clear that the plug-in mulexpansion can be optimized using the fact that the library function mul is a function that performs argument multiplication. The details of the method of performing the optimization by the plug-in 215 are not directly related to the present invention, and thus description thereof is omitted.

  The program conversion apparatus 105 continues the compilation process using “tmp.c” output by the plug-in mulexpansion.

  When the plug-in 215 is continuously activated, the program conversion apparatus 105 may further pass the output file (program H) of the preceding plug-in 215 when the subsequent plug-in 215 is activated.

  As a result of execution of the plug-in mulexpansion, the library procedure call code in the user program E “x = mul (2,3)” is replaced with the assignment statement “x = 6”. That is, when executing the user program E, only the substitution process is performed without performing the multiplication process by the library function mul. Therefore, the program conversion apparatus 105 generates the object code 405 for generating the execution program 605 that speeds up the execution of the program as compared with the case where the optimization is not performed by reducing the calculation amount.

  On the other hand, when the compiler performs optimization without using the plug-in provided by the library, since the library is provided by object code, it is difficult for the compiler to obtain information on the processing contents of the library function mul. When the information regarding the processing contents of the library function cannot be used, it is impossible to replace the library procedure call code “x = mul (2,3)” with the assignment statement “x = 6”. Therefore, the compiler generates code that calls the library function mul. Therefore, multiplication by the library function mul is executed when the execution program is executed.

  Next, another specific example of the processing procedure in the present embodiment will be described.

  FIG. 11 is a diagram for explaining a user program and a library program in another specific example of the processing procedure of the program processing apparatus 105 in the present embodiment.

  FIG. 12 is a diagram for explaining an unoptimized program and an optimized program in another specific example of the processing procedure of the program conversion apparatus 105 in the present embodiment.

  FIG. 11A shows the source code of the user program 305 (hereinafter referred to as “user program J”) in this embodiment, and FIG. 11B shows the source code of the library 205 in this embodiment (hereinafter referred to as “library program K”). ).

  First, the premise for explaining a specific example of the processing procedure in the present embodiment will be described.

  The above is the premise in the following processing procedure. Next, the processing procedure will be described.

  Next, another specific example of the processing procedure in the present embodiment will be described. This embodiment is an example when the library 205 provides a matrix operation function. The library 205 is a C ++ class library and provides a matrix class Mat.

  FIG. 11A shows source code 305 (hereinafter, “user program J”) in the present embodiment. In the user program J, an operation “A = B + C−D” is performed on the four data A, B, C, and D of the matrix class type Mat. FIG. 11B shows a source code (hereinafter, “library program K”) of the library 205 in the present embodiment. In the library program K, three operators “+”, “−”, and “=” of the matrix class are defined. Note that the program examples of the user program J and library program K schematically show the processing contents.

  When compiling the user program J by the normal compilation method, the compiler optimization section does not have information on the processing contents of the library function (that is, the operator of the matrix class), so the compiler does not perform interprocedural optimization. Generate object code that calls library functions. FIG. 12A schematically shows source code corresponding to the object code on the call side of the library function when the user program J is not optimized between procedures. As shown in FIG. 12A, three library functions corresponding to the three operators “+”, “−”, and “=” are sequentially called. The processing contents corresponding to the operators “+”, “−”, and “=” repeatedly execute addition, subtraction, and substitution for each element of the matrix, as shown in FIG. 11B. . Therefore, the expression “A = B + C−D” is subjected to a repetition process three times, once for each operator. In the non-optimized program L, an operation using three temporary matrices (tmp1, tmp2, tmp) is performed on the expression “A = B + C−D”.

  On the other hand, when the program conversion apparatus 105 converts the user program J, the plug-in 215 is provided by the developer of the library program K, so that the plug-in 215 can use information on the processing contents of the library function. Therefore, the plug-in 215 can convert the calculation “A = B + C−D” into one iteration process, as shown in FIG. Further, in the optimized program M, a temporary matrix is not necessary for execution of the calculation for the expression “A = B + C−D”. The optimized program M can reduce the calculation time and the amount of memory used compared to the non-optimized program L.

  As described above, the program conversion apparatus 105 according to the present embodiment activates a plug-in when an instruction to activate the plug-in provided by the library is given in the header file provided by the library. That is, the program conversion apparatus 105 can activate the plug-in without changing the user program that uses the library. Since the source code of the user program (or intermediate code corresponding to the source code) is passed to the plug-in, the plug-in can analyze the source code to obtain information on the user program. Since the plug-in is created by the library provider, the library provider can create a plug-in using information on the processing contents of the library. That is, the plug-in can perform interprocedural optimization by using the user program and library information. Therefore, the program conversion apparatus 105 according to the present embodiment has an effect that interprocedural optimization can be performed between the library and the user program.

  In the present embodiment, the description has been given of the case where the directive for starting the plug-in is described in the header file provided by the library. However, the directive in this embodiment does not necessarily need to be described in the header file. The directive in this embodiment may be described in the user program. If the directive is described in the user program, the user program developer must rewrite the user program, but the user program developer can control whether the plug-in is activated. effective.

As is clear from the description of the present embodiment, the effect of the program conversion apparatus 105 in this embodiment is independent of the plug-in interface specifications determined by a specific compiler and the contents of optimization executed by the plug-in. It is.
(Fourth embodiment)
A configuration in the present embodiment will be described.

  FIG. 13 is a block diagram showing an example of the configuration of the program conversion apparatus 106 in the present embodiment.

  The library 206 in the present embodiment includes a header file 236, a plug-in 216, and an object code 226.

  The header file 236 does not include an instruction sentence for instructing activation of the plug-in 216.

  The program conversion apparatus 106 in this embodiment is a compiler. The compiler 106 includes a plug-in activation unit 116 and an option processing unit 126.

  The option processing means 126 first analyzes an execution condition (command line option, environment variable, etc., hereinafter referred to as “option”) specified when the compiler 106 is started. The option processing unit 126 then instructs the plug-in activation unit 116 to execute the plug-in according to the option that indicates the execution condition of the plug-in 216 included in the execution condition.

  Other components are the same as those in the third embodiment.

  Next, the operation in this embodiment will be described.

  When the user program developer activates the compiler 106, the user program developer specifies an option to activate the plug-in 216 provided by the library 206.

  The option processing unit 126 activates the plug-in 216 provided by the library 206 according to the specified option. The option designation method is preferably explained by a document attached to the library 206.

  The operation of the plug-in activation unit 116 is the same as the operation of the plug-in activation unit 115 in the third embodiment.

  Note that the user program developer does not directly activate the compiler 106, but the user program developer may indirectly activate the compiler 106 via a development tool or the like.

  In the program conversion apparatus 106 according to the present embodiment, interprocedural optimization can be performed between the user program and the library, similarly to the program conversion apparatus 105 according to the third embodiment.

  In addition to the effect of the program conversion apparatus 105 in the third embodiment, the program conversion apparatus 106 in the present embodiment has an effect that the user program developer can specify whether or not to perform interprocedural optimization. . With this effect, for example, a developer of a user program can use the program so that interprocedural optimization is not performed when debugging the user program.

In the present embodiment, the case where the developer of the user program specifies the plug-in execution condition when starting the compiler has been described. However, the plug-in execution conditions in this embodiment are not necessarily specified by the user program developer. The plug-in execution conditions in the present embodiment may be set by storing a plug-in provided by the library in a specific directory when the library is installed. That is, the compiler 106 according to the present embodiment may automatically start a plug-in stored in a specific directory. Therefore, in the program conversion apparatus 106 according to this embodiment that automatically activates a plug-in stored in a specific directory, the developer of the user program needs to specify an execution condition for interprocedural optimization as an option at the time of compilation. There is an effect that there is no.
(Fifth embodiment)
A configuration in the present embodiment will be described.

  FIG. 14 is a block diagram showing an example of the configuration of the program conversion apparatus 107 in the present embodiment.

  The program conversion apparatus 107 in the present embodiment includes a directive processing unit 127, a plug-in activation unit 117, and a compiler activation unit 137. However, the program conversion apparatus 107 does not include a function as a compiler.

  The functions of the instruction sentence processing unit 127 and the plug-in activation unit 117 are the same as the functions of the instruction sentence processing unit 125 and the plug-in activation unit 115 in the third embodiment, respectively. However, the plug-in activation unit 117 further has a function of passing the optimized user program to the compiler activation unit 137.

  The compiler starting unit 137 has a function of starting the compiler 707 by designating an optimized user program.

  The compiler 707 is a general compiler that converts a given source code into an object code.

  Other components are the same as those in the third embodiment.

  Next, the operation in this embodiment will be described.

  In this embodiment, the user program developer activates the program conversion apparatus 107 instead of the compiler 707.

  The program conversion apparatus 107 activates the plug-in 217 provided by the library 207 in accordance with the directive statement 257 in the header file 237, similarly to the program conversion apparatus 105 in the second embodiment. After executing the plug-in 217, the program conversion apparatus 107 activates the compiler 707 by specifying the source code of the user program optimized by the plug-in 217 (or intermediate code that can be read by the compiler).

  The compiler 707 reads the designated source code and converts it into object code. The compiler 707 does not need to have an instruction sentence processing function or a plug-in activation function for processing the instruction sentence 257 for activating the plug-in 217.

  Other operations of the program conversion apparatus 107 are the same as the operations of the program conversion apparatus 105 in the third embodiment.

  Note that the program conversion apparatus 107 may receive options including options that can be received by the compiler 707, and pass the options that can be received by the compiler 707 to the compiler 707 when the compiler is activated.

  In the program conversion apparatus 107 according to the present embodiment, interprocedural optimization can be performed between the library and the user program, similarly to the program conversion apparatus 105 according to the third embodiment.

  In the program conversion apparatus 107 according to the present embodiment, in addition to the effects of the program conversion apparatus 105 according to the third embodiment, an instruction for the compiler to process a plug-in activation function or a directive for instructing execution of the plug-in There is an effect that it can be used even when the sentence processing function is not provided.

  When the program conversion apparatus 107 receives an option including an option that can be received by the compiler, and passes the option that can be received by the compiler to the compiler when the compiler is started, the developer of the user program is similar to the option of the compiler. It is possible to use the program conversion apparatus 107 by specifying various options.

  Further, the program conversion apparatus 107 in the present embodiment may receive an activation instruction for the plug-in 217 to the plug-in activation means 117 as an option, like the program conversion apparatus 106 in the fourth embodiment.

  3 and 6 may be executed by software. That is, a computer program for performing each process may be read and executed by a CPU (FIG. 2:13) provided in the program processing apparatus. Even if each process is performed using a program, the same process as the process of the above-described embodiment can be performed. The above program may be stored in a non-transitory medium such as a ROM (Read Only Memory), a RAM (Random Access Memory), a semiconductor memory device such as a flash memory, an optical disk, a magnetic disk, or a magneto-optical disk. .

  Alternatively, each process may be executed by a component such as an individual circuit.

  In addition, this invention is not limited to the above-mentioned embodiment, It can implement in various changes and deformation | transformation in the range which does not deviate from the summary of this invention.

A part or all of the above-described embodiment can be described as in the following supplementary notes, but is not limited thereto.
(Appendix 1)
A plug-in that is an executable program that performs processing on a code including a procedure call instruction included in the library, provided with the library, is identified, a first code of a user program including the call instruction is obtained, and the specification User program processing means for instructing execution of the plug-in,
Plug-in activation means for activating the plug-in instructed to execute by designating the first code as a processing target;
A program processing apparatus comprising:
(Appendix 2)
The user program processing means identifies the plug-in that is to process the first code based on the list of procedures provided with the library and including information associating the plug-in with the procedure. The program processing device according to appendix 1, wherein:
(Appendix 3)
The user program processing means searches the first code based on the list for a first partial code including the calling instruction, and processes the first partial code based on the list; The program processing apparatus according to appendix 2, characterized by specifying the plug-in and instructing execution of the specified plug-in.
(Appendix 4)
The plug-in activation means passes the first code that can be linked to a library program included in the library to the plug-in when the plug-in is activated. The program processing device according to any one of the above.
(Appendix 5)
The program processing apparatus according to any one of appendices 1 to 4, wherein the first code is a source code or an intermediate code obtained by converting the source code.
(Appendix 6)
The program processing apparatus according to any one of appendices 1 to 5, wherein the plug-in generates a second code that is a result of optimization of the call instruction portion.
(Appendix 7)
The list is a header file that the library has, and includes a directive that instructs execution of the plug-in,
7. The program processing apparatus according to claim 1, wherein the user program processing means instructs the plug-in activation means to execute the plug-in according to the instruction text.
(Appendix 8)
The program processing apparatus according to any one of appendices 1 to 6, wherein the list is given to the user program processing means as a command line option, an environment variable, or a file.
(Appendix 9)
The program processing apparatus according to appendix 6, further comprising compiler starting means for passing the second code to the compiling process when starting the compiling process for the second code.
(Appendix 10)
The program processing apparatus according to any one of appendices 1 to 9, wherein the plug-in is a program that can be executed independently.
(Appendix 11)
Identify a plug-in that is an executable program that is provided with the library and performs processing for code including a procedure call instruction of the library,
Obtaining a first code of a user program including the calling instruction;
Instructing execution of the identified plug-in,
A program processing method comprising: designating the first code as a processing target and activating the plug-in instructed to execute.
(Appendix 12)
A computer provided in the program processing device,
A plug-in that is an executable program that performs processing on a code including a procedure call instruction included in the library, provided with the library, is identified, a first code of a user program including the call instruction is obtained, and the specification User program processing means for instructing execution of the plug-in,
A plug-in activation unit that activates the plug-in instructed to execute by designating the first code as a processing target;
Program processing program to function as.

  The program processing apparatus according to the present invention can be used, for example, by a library developer to develop a plug-in that performs interprocedural optimization using the processing contents of a library and the processing contents of a user program.

  Further, the program processing apparatus according to the present invention can be used to provide a library capable of interprocedural optimization related to, for example, matrix calculation or image processing.

Claims (10)

A plug-in that is an executable program that performs processing on a code including a procedure call instruction included in the library, provided with the library, is identified, a first code of a user program including the call instruction is obtained, and the specification User program processing means for instructing execution of the plug-in,
Plug-in activation means for activating the plug-in instructed to execute by designating the first code as a processing target;
A program processing apparatus comprising: The user program processing means identifies the plug-in that is to process the first code based on the list of procedures provided with the library and including information associating the plug-in with the procedure. The program processing apparatus according to claim 1. The user program processing means searches the first code based on the list for a first partial code including the calling instruction, and processes the first partial code based on the list; The program processing apparatus according to claim 2, wherein the plug-in is specified, and execution of the specified plug-in is instructed. The plug-in activation means, when activating the plug-in, passes the first code that can be linked to a library program included in the library to the plug-in. 4. The program processing device according to any one of items 3. 5. The program processing apparatus according to claim 1, wherein the first code is source code or intermediate code obtained by converting the source code. 6. The program processing apparatus according to claim 1, wherein the plug-in generates a second code that is a result of optimization of the call instruction part. The list is a header file that the library has, and includes a directive that instructs execution of the plug-in,
4. The program processing apparatus according to claim 2, wherein the user program processing means instructs the plug-in activation means to execute the plug-in according to the instruction text. 8. The program processing apparatus according to claim 2, wherein the list is given to the user program processing means as a command line option, an environment variable, or a file. Identify a plug-in that is an executable program that is provided with the library and performs processing for code including a procedure call instruction of the library,
Obtaining a first code of a user program including the calling instruction;
Instructing execution of the identified plug-in,
A program processing method comprising: designating the first code as a processing target and activating the plug-in instructed to execute. A computer provided in the program processing device,
A plug-in that is an executable program that performs processing on a code including a procedure call instruction included in the library, provided with the library, is identified, a first code of a user program including the call instruction is obtained, and the specification User program processing means for instructing execution of the plug-in,
A plug-in activation unit that activates the plug-in instructed to execute by designating the first code as a processing target;
Program processing program to function as.

Images