JP5038760B2 - Source code conversion apparatus and source code conversion method - Google Patents

Description

  The present invention relates to a source code conversion apparatus and a source code conversion method for converting a source code into a plurality of patterns.

  In an embedded system, the performance of source code is often prioritized. However, temporal performance and spatial performance are often in a trade-off relationship, and it is necessary to fully consider the trade-off. Especially in an embedded system, a platform (CPU or the like) frequently changes, and the compiler is changed each time. In addition, compilers used in embedded systems have different levels of optimization depending on how the code is written. However, it is not desirable to increase the cost of acquiring know-how for optimizing source code.

  It is also possible to use an optimization option in an embedded system. For example, if you want to use the same object file for the test version and the product version, or if it is difficult to use the source code in the debugger, the optimization option is used. You can also imagine situations where you do not want to use options.

  Therefore, the source code used in the embedded system needs to be described according to the compiler and performance requirements. However, the same compiler is not always used at the time of development, and the demands in terms of performance also differ depending on the target system, such as CPU and memory loading. Therefore, it is necessary to know what source code is the source code suitable for the development environment.

  For this purpose, it is desirable to select an optimum one by testing many source codes. When the compiler is changed, if the source code optimized for the original compiler is left as it is, the readability may still be lowered even though the opportunity for optimization is not missed or necessary. These trials require many combinations of source code, but it is not practical to generate them manually. When actually reading the source code in the field, there may be remnants written around the original compiler, and in this case, the readability is lowered.

Therefore, a system for optimizing the source code has been proposed (see Patent Document 1). In this system, a part of the code used in the loop process is deleted from the source code, thereby improving the processing speed and reducing the code size.
JP-A-7-36707

  When optimizing the source code, there are the following problems.

  In human trials, it is necessary to have a compiler manual and trials in order to know what description method is good in a certain development environment. However, there are many writing systems that generate equivalent functions, and it is not a realistic task in time but a problem for people to try them one by one.

  In the compiler, it is necessary to optimize the code so that it operates efficiently on the target machine. In addition, the conversion is performed so that it can be easily used (optimized) in the later stage of compilation, but this method cannot be evaluated by the user and fed back, and cannot be used by other compilers. Therefore, it becomes a big problem in fields where the development environment changes and compilers often change.

  Furthermore, although a method of receiving a trade-off selection from the user by option setting is also used, the granularity of the setting is rough, and detailed setting cannot be performed. Although it is necessary to consider speed priority so as to be within several tens of kilobytes, only simple conditions such as speed priority and memory priority can be determined.

  Furthermore, it will be determined whether it is possible in advance what optimization by the compiler, it is possible that variations in the optimization occurs due calligraphy. For this reason, there is a possibility that the optimization may be hindered when the compiler is changed, or the readability may remain lowered even though the optimization is not affected.

  In case tools, it is desirable to reverse engineer source code and output models. In addition, it is desirable to (semi) automatically generate source code from a model. Although this method seems to output the source code from the source code as a whole, there are the following restrictions.

  ・ In reverse engineering, only source code corresponding to what can be expressed in a diagram corresponding to the case tool can be converted. Some also specify the format of the source code. This makes it difficult to input source code that has already been written into the case tool.

  ・ Some optimizations are performed when generating source code from a model. However, since optimization is performed based on information on the model, it is not possible to consider parts that are not in the model. In order to perform optimization, the programmer needs to write the source code in a model or specified format. If the source code already exists, rewriting to the specified format is required.

  In the refactoring tool, it is desirable to reduce as much as possible the part of the source code that needs to be corrected according to the user's instructions. At this time, it is certain that there will be fewer errors etc. compared to manual rewriting, but it does not generate multiple source codes at once, and it is necessary to know to what extent the user should fix to some extent There is. Therefore, with this method, it is not possible to greatly reduce the effort at the time when know-how related to the compiler is not accumulated, that is, in a situation where trial and error are necessary.

  The present invention has been made in view of the above problems, and a source code conversion apparatus and source code conversion capable of converting an original source code into a source code having an appropriate pattern from a variety of conversion patterns as much as possible. It aims to provide a method.

In order to solve the above problems, a source code conversion apparatus according to the present invention includes an analysis unit that analyzes a structure of a source code to create a structure tree, and a memory that stores a pattern table indicating a plurality of conversion patterns of the source code And a consistency analysis unit that creates a combination of conversion formulas by comparing a pattern table stored in the storage unit against the policy and a policy for converting the source code A matching unit that includes a creation unit that converts source code based on a combination of the converted conversion formulas, and a feedback analysis unit that creates compiler characteristics based on a plurality of patterns of source code created in advance by the creation unit. The pattern table is checked against the compiler characteristics created by the feedback analysis unit and the policy. Characterized by creating a combination of conversion formulas.

Further, the source code conversion method according to the present invention includes an analysis unit, a storage unit that stores a pattern table indicating a plurality of conversion patterns of the source code, a consistency analysis unit having a policy for converting the source code, a creation unit, a source code conversion method in the source code conversion apparatus and a feedback analyzer, the analyzer is an analyzing step of creating a tree structure by analyzing the structure of the source code, the coincidence analysis parts includes a consistent analysis step of creating a combination of conversion equation against the pattern table to the policy, the creation unit, a source code based on a combination of the conversion formulas created by the matching analysis step a generating step of converting said feedback analyzer is Sosuko plurality of patterns created beforehand by the creation step Anda feedback analysis step of creating a compiler characteristics based on de, in conformity analyzing step of definitive after the compiler characteristics is created, the coincidence analysis unit, the compiler characteristics and the policy of the pattern table It is characterized by creating a combination of conversion formulas in light of the above.

  According to the source code conversion device and the source code conversion method according to the present invention, it is possible to convert the original source code into a source code having an appropriate pattern from as many conversion patterns as possible.

  Embodiments of a source code conversion apparatus and a source code conversion method according to the present invention will be described in detail with reference to the accompanying drawings.

[First Embodiment]
FIG. 1 is a system configuration diagram showing a first embodiment of a source code conversion apparatus according to the present invention.

  The source code conversion device 1 according to the first embodiment is a device such as a PC (Personal Computer) that converts the source code 20, a syntax analysis unit 2 that performs syntax analysis of the source code 20 and creates a syntax tree, A context analysis unit 3 that performs context analysis on the syntax tree created by the syntax analysis unit 2, a variation pattern storage unit 4 that stores a variation pattern of the syntax, and a conversion policy that stores a variation pattern stored in the variation pattern storage unit 4 Variation pattern matching analysis unit 5 that creates a combination of conversion formulas against 40, and variation generation that converts multiple patterns of source code 20 based on the combination of conversion formulas created by variation pattern matching analysis unit 5 Part 6 and variation generation part 6 Includes compiling and profiling, the compiler profiler static analysis tools 7 for analysis, the source code 20A which is more generated.

  It is assumed that the source code 20 to be converted by the source code conversion apparatus 1 is obtained by applying the existing source code 20 whose operation has been confirmed to a preprocessor (preprocessing system) according to the grammar of a programming language such as C language.

  The syntax analysis unit 2 parses the source code 20 and outputs the analysis result in a structural tree format as shown in FIG. In each node of the structure tree, line number, reserved word, numerical value, conditional expression, assignment expression, unary operation expression, and scope information are stored.

  The line number information is used to specify the changed part at the time of conversion. A reserved word is a word that is defined in a programming language specification and cannot be defined as a variable name or function name, and “if”, “for”, “while”, “return”, “true”, etc. are reserved words. There are many programming languages. This reserved word information is used when converting into a conditional statement of another format. The numerical information is information such as whether or not it is a power of 2, for example. The conditional expression is a variable used for an equality operation, and is used in a conditional statement such as “if”, for example. Information on this conditional expression is used for conversion to a “switch” sentence or the like. An assignment expression or a unary operation expression is used to check whether it is used as a counter for repeated statements. A scope is the scope of a variable or function.

  The context analysis unit 3 follows the analysis result (structure tree) of the syntax analysis by the syntax analysis unit 2, and adds information derived from the context, that is, the context of the code, to the structure tree.

  For example, it is confirmed whether a variable used in a conditional expression of a “while” statement is used as a counter (third expression of a “for” statement) in a sub-statement (loop statement). When a newly defined variable in the scope hides a variable that has already been defined, a new variable name that is not hidden is generated and recorded in the node.

  The variation pattern storage unit 4 stores a variation pattern table 30 as shown in FIG. 3 in advance. The variation pattern table 30 is a table that describes various patterns for generating variations of multiplication and division using a repetition sentence, a conditional sentence, and a power of two.

  For example, in the variation pattern table 30 shown in FIG. 3, three types of patterns A, B, and C are shown as patterns of the source code 20. The first line of pattern A (column “1A”) is indicated as “for (<A>; <b>; <C>) <D>”, and the first line of pattern B (“1B”) (<B>) [<D> <C>]] is indicated in the column (1), and the first line of the pattern C (column (1C)) “<A>; do {<D>; <C>} while (<B>);”. These 1A, 1B, and 1C are synonymous with different patterns. Similarly, 2A, 2B, 2C, and 3A, 3B, 3C are also synonymous.

  The variation pattern matching analysis unit 5 compares the conversion policy 40 indicating the policy for performing source code conversion with the variation pattern table 30, and determines the conversion policy of the conversion policy 40 from each conversion pattern of the variation pattern table 30. Find matching syntax. For example, in the case of a repetitive sentence, it is assumed that portions that match <A>, <B>, <C>, and <D> shown in FIG. At this time, the variation pattern coincidence analysis unit 5 deletes a conversion formula for generating an unnecessary variation based on the conversion policy 40.

  As shown in FIG. 4, the conversion policy 40 indicates a policy for selecting a pattern that is not used for specifying a variation or a function that is not converted when converting, and is stored in advance by the variation matching analysis unit. Yes. The conversion policy 40 is also provided with an index such as readability in order to effectively suppress the conversion pattern. The variation pattern matching analysis unit 5 converts the source code 20 based on the conversion policy 40.

  In the conversion policy 40 shown in FIG. 4, “Readable” specifies a conversion pattern with high readability by continuously describing the cells in FIG. 3 (for example, “1A”). When a plurality of cells are specified in the conversion policy 40, the cell written first (left side) has higher readability. “Unuse” specifies a cell or function that is not used as a conversion pattern. This is to suppress unnecessary conversion that does not particularly contribute to conversion, performance, or the like that significantly reduces readability.

  In “Not Optimize Function”, a function that is not converted is designated. In “Not Optimize File”, a file not to be converted is designated. In “Optimize Priority”, an item (Speed, RomSize, StackSize, RamSize, etc.) to be prioritized at the time of conversion is designated.

  When a trade-off occurs between the conversion policies 40, the conversion policy 40 written above is prioritized.

Typical examples of the conversion policy in the conversion policy are given in the following (1) to (6). (1) to (4) are policies for optimizing a predetermined compiler, and (5) to (6) are policies for improving the readability of the source code 20.
(1) Since indirect memory access using a pointer is difficult to optimize, the pointer access is localized.
(2) Since “do” to “while” generally consumes the least amount of ROM, “do” to “while” are preferentially used.
(3) Since the “if” statement generally consumes the least ROM size, it is unified with the “if” statement.
(4) Exclude patterns corresponding to compiler bugs.
(5) “if” to “else” statements are used for exclusive conditional branching.
(6) When the “switch” sentence can be used, the “switch” sentence is used.

  Further, the variation pattern matching analysis unit 5 generates a combination of conversion formulas. The scope for conversion can be known from the information of the file name of the source code 20 and the line number of the source code 20 obtained at the time of parsing. The conversion formula is a conversion formula that can be handled by a character string conversion tool such as sed (a program for processing regular text data used in a command line environment such as UNIX (registered trademark)) based on regular expressions.

  Then, the variation pattern matching analysis unit 5 connects the conversion expressions generated for each cell of the variation pattern table 30 as a list, and generates a list for each combination of conversion expressions.

  The variation generation unit 6 uses the combination of conversion formulas created by the variation pattern matching analysis unit 5 and converts the variation pattern of the original source code 20 before the parsing by the syntax analysis unit 2 into the combination of conversion formulas. Generate only for.

  The compiler / profiler / static analysis tool 7 is a compiler / profiler / static analysis tool 7 suitable for the development environment, and is provided as necessary. The static analysis tool 7 is used when the user evaluates the source code 20 </ b> A generated by the variation generation unit 6.

  The source code conversion apparatus 1 performs source code conversion processing for converting the source code 20 into a plurality of source codes 20A having various variations equivalent to the original code. The procedure when the source code conversion apparatus 1 performs the source code conversion process will be described based on the flowcharts shown in FIGS. 5, 6, 8, and 9.

  First, the syntax analysis unit 2 analyzes the data structure of the source code 20 and creates a structure tree (S101).

  Next, the context analysis unit 3 performs context analysis. As the context analysis, the context analysis unit 3 extracts, for example, a third expression extraction process (third syntax of the three syntaxes specified in the “for” sentence) of the “for” sentence (third expression is extracted). S103), for example, a calculation expression extraction process (S105) for extracting a bit shiftable calculation expression, for example, a hidden variable detection process (S107) for detecting a local variable hidden by a global variable.

  FIG. 6 is a flowchart illustrating a procedure in which the context analysis unit 3 performs the third expression extraction process. When converting a loop statement such as a “while” statement into a “for” statement, the context analysis unit 3 uses the third expression of the “for” statement (the third of the three syntaxes specified in the “for” statement). Are extracted, and the third expression is determined from them.

  First, the context analysis unit 3 acquires the structural tree created by the syntax analysis unit 2 (S201). Further, the context analysis unit 3 acquires a variable group used in a repetitive conditional expression such as a “while” sentence from the structural tree acquired in S201 (S203).

  The context analysis unit 3 acquires the syntax from the variable group acquired in S203 (S205). Then, the context analysis unit 3 determines whether or not the syntax acquired in S205 refers to a variable used in the third expression candidate of the “for” sentence (S207). It is assumed that the third formula candidate of the “for” sentence has already been selected in the process of S219 described later. If the variable is referenced (Yes in S207), for example, if it is used for increment or the like, it is not the third expression of the “for” statement. It removes from 3 type candidates (S209). If no third formula candidate has been selected, the process proceeds directly to S211.

  The context analysis unit 3 determines whether or not the syntax acquired in S205 includes an assignment statement (including a unary operation) (S211). When the syntax does not include an assignment expression (No in S211), the context analysis unit 3 returns to S205 and acquires the next syntax (S205).

  When the syntax includes an assignment statement (Yes in S211), the context analysis unit 3 obtains the assignment statement included in the syntax obtained in S205, and sets it as a check target assignment statement (S213). The context analysis unit 3 acquires a variable to be assigned from the assignment statement (S215).

  The context analysis unit 3 determines whether or not the variable acquired in S213 is in the variable group used in the conditional expression (variable group acquired in S203) (S217). If the variable is in the variable group (Yes in S217), the context analysis unit 3 sets the assignment sentence to be examined as the third expression candidate of the “for” sentence (S219). The third formula candidate of this “for” sentence is used in the processes of S207 and S209.

  When the variable is not in the variable group (No in S217), the context analysis unit 3 determines whether or not there is an unprocessed assignment statement in which the processing from S215 to S217 is not performed in the syntax acquired in S205. (S221). If there is an unprocessed assignment statement (Yes in S221), the context analysis unit 3 returns to S213 and sets the unprocessed assignment expression as the assignment statement to be examined.

  When there is no unassigned assignment statement, that is, when the processing from S213 to S217 (or S219) is performed on all assignment statements (No in S221), or the assignment statement is the third expression of the “for” statement. When it is determined as a candidate (S219), the context analysis unit 3 determines whether there is an unprocessed syntax (S223). If there is an unprocessed syntax (Yes in S213), the process returns to S205 to acquire the next syntax (S205), and the processes from S207 to S223 are performed again.

  When there is no unprocessed syntax, that is, when the processing from S205 to S221 (or S219) is performed for all syntaxes, the context analysis unit 3 uses the “for” statement as the assignment statement to be examined in S213. Is determined as the third equation (S225).

  Further, the context analysis unit 3 adds the third expression of the “for” sentence determined in S225 to the structural tree (S227). The added structure tree is shown in FIG. Like description A shown in FIG. 7, in the structure tree shown in FIG. 2, information on “third expression when“ for ”sentence is used” and “can be used as the third expression of“ for ”sentence” is provided. Added.

  If the variable used in the third expression determined in S225 is first defined in the variable group acquired in S203, the context analysis unit 3 sets this as the first of the “for” sentence. As an expression, information of “first expression when“ for ”sentence is used” ”is added to the structure tree.

  In this way, the third type candidate extraction process is performed by the context analysis unit 3.

  Next, the context analysis unit 3 performs calculation formula extraction processing for extracting a bit shiftable calculation formula (S105). A procedure in which the context analysis unit 3 performs the calculation expression extraction process will be described based on a flowchart shown in FIG.

  First, the context analysis unit 3 acquires a structural tree to which the third expression candidate of the “for” sentence is added in S225 (S301). Further, the context analysis unit 3 acquires a variable group used in a repetitive conditional expression such as a “while” sentence from the structural tree acquired in S301 (S303).

  The context analysis unit 3 acquires the syntax from the variable group acquired in S303 (S305). Then, the context analysis unit 3 determines whether or not there is a constant value that is a power of 2 in the syntax acquired in S305 (S307). When there is a constant value that is a power of 2 (Yes in S307), the context analysis unit 3 acquires the constant value (S309).

  The context analysis unit 3 determines whether or not the constant value acquired in S309 is used for multiplication and division (S311). When the constant value acquired in S309 is used for multiplication / division (Yes in S311), the context analysis unit 3 assumes that the constant value can be bit-shifted (S313). Then, the context analysis unit 3 adds the fact that the constant value can be bit-shifted to the structural tree acquired in S301 (S315). Specifically, as in the description B shown in FIG. 7, the information “power of 2” is added to the structure tree shown in FIG.

  When the constant value acquired in S309 is not used for multiplication / division (No in S311), the context analysis unit 3 assumes that the low value is not bit-shiftable (S317). In this case, the context analysis unit 3 does not add to the structural tree acquired in S301.

  When the processing of S315 or S317 is completed, or when there is no constant value that is a power of 2 in the syntax acquired in S305 (No in S307), the context analysis unit 3 uses the variable group acquired in S303. It is determined whether or not there is an unprocessed syntax that has not been processed from S305 to S315 (or S317) (S319).

  If there is an unprocessed syntax (Yes in S319), the context analysis unit 3 returns to S305 and acquires an unprocessed syntax. When there is no unprocessed syntax, that is, when the processing from S305 to S315 (or S317) is performed for all the syntaxes in the variable group acquired in S303 (No in S319), the context analysis unit 3 Ends the calculation formula extraction process.

  When completing the calculation formula extraction process, the context analysis unit 3 performs a hidden variable detection process (S107) that detects a local variable that is hidden by a global variable, for example. A procedure when the context analysis unit 3 performs this concealment variable detection process will be described based on the flowchart shown in FIG.

  A plurality of local variables are used in the source code 20, but since local variables are functions that are locally declared, there may be many local variables having the same definition in the same source code 20. If there are multiple local variables with the same definition, it becomes difficult to identify individual local variables. In order to prevent this, the context analysis unit 3 performs a concealment variable detection process for detecting a local variable having the same definition.

  The context analysis unit 3 acquires the structural tree for which the calculation formula extraction processing has been completed (S401). Further, the context analysis unit 3 acquires a global variable from the structural tree acquired in S401 (S403). The context analysis unit 3 creates a variable list by listing the global variables acquired in S403 (S405).

  The context analysis unit 3 acquires a variable group used in a repetitive conditional expression such as a “while” sentence from the structural tree acquired in S401 (S407). Further, the context analysis unit 3 acquires the syntax from the variable group acquired in S407 (S409).

  The context analysis unit 3 determines whether there is an unprocessed local variable (S411). The unprocessed local variable is a local variable that is not subjected to the processing of S413 to S421 described later.

  If there is an unprocessed local variable (Yes in S407), the context analysis unit 3 acquires this local variable (S413). Then, the context analysis unit 3 determines whether the variable list created in S405 includes the same definition (for example, the same name) as the local variable acquired in S413 (S415).

  If the local variable is included in the variable list (Yes in S415), the local variable is duplicated with other local variables or global variables, so this local variable is not included in the variable list. Change to a variable (S417). At this time, the local variable is changed, for example, by changing the name.

  The context analysis unit 3 adds the local variable to the variable list (S419). At this time, if the local variable is changed in S417, the context analysis unit 3 adds the changed local variable to the variable list, and the local variable is not included in the variable list (No in S415). In step S413, the local variable acquired in step S413 is added to the variable list.

  The context analysis unit 3 adds a local variable to the structure tree (S421). Also in this case, as in S419, the context analysis unit 3 adds the changed local variable to the structure tree when the local variable is changed in S417, and the local variable is not included in the variable list. In (No in S415), the local variable acquired in S413 is added to the structure tree. Specifically, as in description C shown in FIG. 7, information on “alias candidates” of local variables is added to the structure tree shown in FIG.

  The context analysis unit 3 determines whether there is an unprocessed syntax that has not been processed from S409 to S421 (S423). If there is an unprocessed syntax (Yes in S423), the process returns to S409, an unprocessed syntax is acquired, and the processing from S411 to S421 is performed. If there is no unprocessed syntax (No in S423), the context analysis unit 3 ends the hidden variable detection process.

  When the concealment variable detection process by the context analysis unit 3 ends, the variation pattern matching analysis unit 5 analyzes the matching of the variation patterns based on the conversion policy 40.

  First, the variation pattern matching analysis unit 5 acquires the variation pattern table 30 (FIG. 3) stored in the variation pattern storage unit 4 (S111). Further, the variation pattern matching analysis unit 5 acquires the conversion policy 40 (FIG. 4) stored therein (S113).

  The variation pattern coincidence analysis unit 5 compares the variation pattern table 30 acquired in S111 with the conversion policy 40 acquired in S113, selects one or a plurality of variation patterns that conform to the conversion policy 40, and each source code A combination of conversion formulas for converting 20 is created (S115).

  Then, the variation generation unit 6 converts the original source code 20 based on the combination of conversion formulas created by the variation pattern matching analysis unit 5 in S115, and generates the source code 20A of each variation pattern (S117). ).

  In addition, although the example which performs 3rd type | formula extraction processing, calculation formula extraction processing, and concealment variable detection processing separately was demonstrated as 1st Embodiment, it is not restricted to this, The process which acquires syntax (S205, S305, S409) )) May be performed in parallel, so that each process may be performed in parallel. At this time, it is assumed that the processes of S403 and S405 have been performed in advance.

  Further, after the source code 20 is converted into a plurality of patterns of source code 20A by using the source code conversion device 1, the user applies the compiler, profiler, and static analysis tool 7 to the source code 20A through a compiler or conversion. It is recommended to determine the conversion pattern to be used by evaluating the source code.

  Furthermore, in the first embodiment, it has been described as an example that the local variable is concealed by the global variable or another local variable in the concealment variable detection process. However, the present invention is not limited to this, and the global variable is concealed by the local variable. The same processing is performed even if it is.

  According to the source code conversion device 1, by selecting as many conversion patterns as possible from a plurality of variation patterns for the source code 20, it is possible to convert the source code 20A into various patterns of source code 20A.

  Further, according to the source code conversion apparatus 1, by setting the conversion policy 40 so as not to obviously perform unnecessary conversion, the source code 20 can be converted to the source code 20A having a desired pattern. It becomes possible.

  Further, according to the source code conversion device 1, when the source code 20 is converted, for example, when a local variable is concealed in a global variable, the concealment of the variable is performed by simply converting using only the variable name. May occur. By grasping the location where the variable is concealed, it is possible to remove the concealed portion or convert only that portion by designating the conversion range.

[Second Embodiment]
A second embodiment of the source code conversion apparatus and source code conversion method according to the present invention will be described with reference to FIGS. In addition, the same code | symbol is attached | subjected to the structure same as 1st Embodiment, and the overlapping description is abbreviate | omitted.

  FIG. 10 is a system configuration diagram showing a source code conversion apparatus 1A according to the second embodiment. Similarly to the first embodiment, the source code conversion device 1A of the second embodiment is a device such as a PC (Personal Computer) that converts the source code 20, and performs syntax analysis of the source code 20 to obtain a syntax tree. A syntax analysis unit 2 to be created, a context analysis unit 3 that performs context analysis on the syntax tree created by the syntax analysis unit 2, a variation pattern storage unit 4 that stores a variation pattern of the syntax, and a variation pattern storage unit 4 A variation pattern matching analysis unit 5A that creates a combination of conversion formulas by comparing the variation pattern stored by the conversion policy 40A, and source code 20 based on the combination of conversion formulas analyzed by the variation pattern consistency analysis unit 5A Variation students that convert multiple patterns And part 6, and a compilation and profiling, the compiler profiler static analysis tool 7 for analysis, a.

  As in the first embodiment, the source code 20 to be converted by the source code conversion device 1A is preprocessor (pre-processed) that has already been verified in accordance with the grammar of a programming language such as C language. System).

  The source code conversion apparatus 1A of the second embodiment is different from the source code conversion apparatus 1 of the first embodiment in that a compiler characteristic 50 is used when creating a conversion formula by the variation pattern matching analysis unit 5A. is there. The source code conversion apparatus 1A of the second embodiment analyzes and profiles a plurality of patterns of source code 20 obtained by performing source code conversion in advance, creates a compiler characteristic 50 as feedback information, and adds this compiler characteristic 50 The source code 20 is converted using the conversion policy 40.

  Therefore, the conversion policy 40A held by the variation pattern matching analysis unit 5A of the source code conversion device 1A includes a description linked with the compiler characteristic 50 as shown in FIG.

  For example, “Optimize Priority” specifies items (Speed, RomSize, StackSize, RamSize, and Readable) to be prioritized when the source code 20 is converted. “Speed” gives priority to time efficiency, “RomSize” gives priority to ROM size reduction, “StackSize” gives priority to stack size reduction, “RamSize” gives priority to RAM size reduction , “Readable” is used when priority is given to readability. If multiple items are specified, the left item takes precedence. When the source code conversion apparatus 1A performs source code conversion, conversion that is known not to contribute to these items is not performed.

  “Optimize RomSize” specifies in bytes how much ROM size should be reduced during source code conversion. If the RomSize is reduced by a specified amount compared to the source code 20 before the conversion, the conversion giving priority to the RomSize reduction is not performed. Until then, priority is given to the conversion that contributes to the reduction of RomSize.

  “Optimize Running Time” specifies how much the execution performance should be improved during source code conversion. If the execution time can be reduced by the specified number, source code conversion is not performed. When this conversion policy 40 is specified, conversion that contributes to improvement in execution efficiency is preferentially converted.

  “Optimize Running Time%” specifies that a frequently executed part is preferentially converted. The specified numerical value indicates the ratio of the conversion location to the execution time. If the percentage of execution time is exceeded, the remaining files and functions are not converted. Convert from a function with a long execution time, and stop conversion when the cumulative value of the converted function exceeds the percentage of the execution time.

  As shown in FIG. 12, the compiler characteristic 50 describes the result of compiling and profiling variously converted source code 20A. The compiler characteristic 50 describes that there is no difference if there is no significant difference between conversions as a result of profiling. The compiler characteristics 50 are described for each compiler option if there is a difference in the profiling result depending on the compile option. The compiler characteristic 50 is combined with the conversion policy 40 to bring about an effect of suppressing the amount of code conversion.

  For example, “Speed” describes how much the speed performance of the source code has changed due to source code conversion. This item is represented by a cell name in the variation pattern table 30 shown in FIG. 3 and a numerical value in parentheses. The numerical value in parentheses is an increase / decrease of the speed with respect to the cell name pattern shown on the leftmost side, and is described in a required time (in microseconds). That is, the first line of the compilation characteristics shown in FIG. 12 means that the required time is +30 μsec in the “B1” pattern compared to the “A1” pattern. If specific numerical values cannot be described, the numerical values may be described in order from the left in ascending order.

  “RomSize”, “StackSize”, and “RamSize” describe how much the ROM size (stack size, ram size) is converted in each pattern of the variation pattern table 30 shown in FIG. These items are represented by a cell name in the variation pattern table 30 and a numerical value in parentheses. The numerical value in parentheses is an increase / decrease amount with respect to the cell name pattern shown on the leftmost side, and is described in units of bytes.

  In “RunningTimeRate”, a scenario name is defined, and the execution time ratio of each function in the scenario is described. For example, as shown in FIG. 12, the scenario name is described in parentheses, and the ratio (% unit) of the execution time at the time of profiling is described after the function name.

  “BUG” describes a conversion pattern that may cause a compiler bug or a compilation error when the converted source code 20A is compiled. For example, it is described by the cell name of the variation pattern table 30.

  Here, the relationship between the conversion policy 40A and the compiler characteristic 50 will be described. Items prioritized by “Optimize Priority” in the conversion policy 40A are acquired from the compiler characteristic 50, and items that do not contribute to the prioritized items are detected. Conversions that do not contribute to this priority item are not performed during source code conversion. When a plurality of items are written, conversion that does not contribute to all items is not performed at the time of source code conversion.

  When a numerical value is specified after “Optimize RomSize” in the conversion policy 40A, if the ROM size is reduced by the numerical value (unit is regarded as bytes) compared to the source code 20 before conversion, the ROM size reduction is performed. Do no conversion to be performed. The amount of ROM size reduction at this time is calculated based on the compiler characteristics 50. As for the order of conversion, conversion is performed preferentially from items that can easily reduce the ROM size if there is no other priority. If nothing is described in the compiler property 50, it is ignored.

  If the execution time is reduced by the numerical value designated by “Optimizing RunningTime” in the conversion policy 40A, the source code 20 is not converted. How much execution time can be reduced is calculated based on the compiler characteristics 50. When this item is specified, an item whose execution time is easy to be reduced is selected based on the compiler characteristics 50, and conversion is performed preferentially from the item which is easy to reduce. If nothing is described in the compiler property 50, it is ignored.

  The numerical value specified by “Optimizing RunningTimeRate” in the conversion policy 40A indicates the proportion of the execution time. Conversion is performed from a function with a long execution time, and the conversion is stopped when the cumulative value of the converted function exceeds the proportion of the execution time. The execution time is acquired from the compiler characteristic 50. If nothing is described in the compiler property 50, it is ignored.

  Next, the procedure when the source code conversion apparatus 1A performs the source code conversion process will be described based on the flowchart shown in FIG.

  First, the source code conversion apparatus 1A performs the same processing as S101 to S109 as the processing of S501 to S509. Note that description of the processing of S501 to S509 is omitted.

  When the variation pattern matching analysis unit 5A obtains the variation pattern table 30 shown in FIG. 3 from the variation pattern storage unit 4 (S509), it obtains the conversion policy 40 shown in FIG. 11 and the compiler characteristic 50 shown in FIG. 12 (S511). ).

  The variation pattern coincidence analysis unit 5A compares the variation pattern table 30 acquired in S509 with the conversion policy 40A and the compilation characteristics acquired in S511, and determines one or more variation patterns suitable for the conversion policy 40A and the compilation characteristics. A plurality of selections are made, and combinations of conversion formulas for converting the source code 20 are created (S513).

  Then, the variation generation unit 6 converts the original source code 20 based on the combination of conversion formulas created by the variation pattern matching analysis unit 5A in S513, and generates the source code 20A of each variation pattern (S515). ).

  The compile / profiler / static analysis tool 7 evaluates the converted source code 20A by applying it to the compiler, profiling or analyzing the source code 20A generated in S515, and performs variation pattern matching analysis. This is described in the compiler characteristics 50 held by the unit 5 (S517).

  According to the source code conversion apparatus 1A of the second embodiment, the compiler characteristics 50 relating to speed, memory size, etc. are acquired as feedback information for source code conversion, which is effective for speed improvement and memory size reduction based on the compiler characteristics 50. It becomes possible to prioritize source code conversion.

  Further, according to the source code conversion device 1A of the second embodiment, at the time of source code conversion, conversion that does not contribute to optimization is reduced, or a specific part (for example, only a part that occupies 80% of execution time) is optimized. It becomes possible to do.

  In particular, in an embedded system, there are scenes that do not need to be optimized as long as they fall within the required constraints. Therefore, it is possible to avoid unnecessary optimization and prevent unnecessary readability degradation.

  Furthermore, in the source code conversion apparatus 1A of the second embodiment, by acquiring the compiler characteristics 50, it is possible to avoid conversion that causes a bug in the compiler.

  In the first embodiment and the second embodiment, the function for carrying out the invention is recorded in advance in the apparatus. However, the present invention is not limited to this, and the same function is downloaded from the network to the apparatus. Alternatively, the same function stored in the recording medium may be installed in the apparatus.

  The recording medium may be in any form as long as it can store a program such as a CD-ROM and can be read by the apparatus.

  Further, the function obtained by installing or downloading in advance may be realized in cooperation with an OS (operating system) or the like inside the apparatus.

1 is a system configuration diagram showing a first embodiment of a source code conversion apparatus according to the present invention. The figure which shows the data structure before conversion of a source code. The figure which shows an example of a variation pattern table | surface. The figure which shows an example of the conversion policy used with the source code converter of 1st Embodiment. The flowchart which shows the procedure of the source code conversion process by the source code conversion apparatus of 1st Embodiment. The flowchart which shows the procedure of the 3rd type | mold extraction process by the source code converter of 1st Embodiment. The figure which shows the data structure after conversion of a source code. The flowchart which shows the procedure of the calculation formula substitution process by the source code converter of 1st Embodiment. The flowchart which shows the procedure of the concealment variable detection process by the source code converter of 1st Embodiment. The system block diagram which shows 2nd Embodiment of the source code conversion apparatus which concerns on this invention. The figure which shows an example of the conversion policy used with the source code converter of 2nd Embodiment. The figure which shows an example of the compiler characteristic used with the source code conversion apparatus of 2nd Embodiment. The flowchart which shows the procedure of the source code conversion process by the source code conversion apparatus of 2nd Embodiment.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1, 1A Source code converter 2 Syntax analysis part 3 Context analysis part 4 Variation pattern memory | storage part 5, 5A Variation pattern coincidence analysis part 6 Variation generation part 7 Compiler / profiler / static analysis tool 20, 20A Source code 30 Variation pattern Table 40, 40A Conversion policy 50 Compiler characteristics

Claims (2)

An analysis unit that analyzes the structure of the source code and creates a structural tree;
A storage unit for storing a pattern table indicating a plurality of conversion patterns of the source code;
A consistency analysis unit that has a policy for converting the source code and creates a combination of conversion formulas by comparing the pattern table stored in the storage unit with the policy;
A creation unit that transforms source code by transforming a structural tree created by the analysis unit based on a combination of conversion formulas created by the consistency analysis unit;
A feedback analysis unit for creating compiler characteristics based on a plurality of patterns of source code created in advance by the creation unit;
The coincidence analysis unit is a source code conversion device that generates a combination of conversion expressions by comparing the pattern table with the compiler characteristics generated by the feedback analysis unit and the policy . A source comprising: an analysis unit; a storage unit for storing a pattern table indicating a plurality of conversion patterns of source code; a consistency analysis unit having a policy for converting source code; a creation unit; and a feedback analysis unit A source code conversion method in a code conversion device, comprising:
The analyzing unit, an analysis step of creating a tree structure by analyzing the structure of the source code,
The consistency analysis unit creates a combination of conversion expressions by comparing the pattern table with the policy, and a consistency analysis step,
The creation unit converts the source code based on a combination of conversion formulas created by the consistency analysis step; and
A feedback analysis step in which the feedback analysis unit creates compiler characteristics based on a plurality of patterns of source code created in advance by the creation step;
Have
Wherein in the matching analysis steps definitive after the compiler characteristics is created, the coincidence analysis unit, against the pattern table to the compiler characteristics and the policy to create a combination of conversion formulas, source code conversion method.

Images