JP2011191985A - Symbolic execution support program, method and device - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To properly recognize an execution path without generating a useless path condition. <P>SOLUTION: In this method, from a program of an analysis object, a repetition block matched with a pattern of changing a repetition control variable, searching a specific case and executing specific processing in the specific case is extracted. In the program of the analysis object, the extracted repetition block and a block immediately after the repetition block are substituted for a biantennary structure for executing the specific processing in the case of truth, executing the processing of the block immediately after in the case of false, and including a predicate function concerning the truth/false, and a logical restriction is generated for the predicate function included in the biantennary structure. In the symbolic execution of the program after conversion processing, when detected that the predicate function is processed, the path condition at the appearing position of the predicate function is generated from the logical restriction associated with the predicate function and is added and registered to the management data of a symbolic execution part. <P>COPYRIGHT: (C)2011,JPO&INPIT

Description

  The present technology relates to a symbolic execution technology.

  Symbolic execution is also called symbol execution and is used, for example, when testing and verifying a program. The basics of symbolic execution are described in detail in, for example, Tetsuo Tamai, Koichi Fukunaga, “Symbol Execution System”, Information Processing, pp18-28, 1982/01/15, etc. Please refer to that. .

  Symbolic execution is a technique in which a program is simulated with symbols that represent numerical values and the results are evaluated instead of inputting specific numerical values into variables included in the program. For example, consider a case where a program as shown in FIG. 1 is executed symbolically. In this program, if statements are described in (1) to (3). Also assume that variables x and y are specified as symbols in symbolic execution. When such a program is executed symbolically, a control flow schematically shown in FIG. 2 is obtained. In FIG. 2, the rectangular boxes excluding processes 1 to 4 represent logical constraints (that is, path conditions) that must be satisfied when an assignment statement or conditional statement is passed through symbolic execution. The condition is accumulated every time it passes through an assignment statement or conditional statement. In the example of FIG. 2, a path condition of (z = x + 5) is accumulated when x + 5 is substituted for z, and a path condition of (z = x + 5 and z> = 10) in the if statement of (1) and (z = Pass conditions of x + 5 and z <10) are stacked. Thereafter, two more pass conditions are stacked in the if statement of (2), and two more pass conditions are stacked in the if statement of (3).

  After such symbolic execution, whether or not the path condition can be satisfied is determined using, for example, a SAT (satisfiability) or SMT (satisfiability modulo theory) solver. In the example of FIG. 2, the path condition (z = x + 5 and z> = 10 and x <= 10) generated after the branch of (2) is determined to be unsatisfactory, and it can be seen that the process 2 is not executed. . Note that symbolic execution may be used in combination with a model checking engine such as JPF (Java (registered trademark) Path Finder).

  As described above, in symbolic execution, all satisfying execution paths are automatically generated in the conditional branch, thereby enabling comprehensive execution of the program. However, there is a possibility that combination explosion occurs due to its comprehensiveness, and in particular, there are problems that a lot of combinations that are not originally required for symbolic execution are generated by an algorithm specific to the implementation language, and unnecessary search is repeated.

  FIG. 3 shows an example of such a program. FIG. 3 searches for a product having the same pid as a given pid, and outputs “stock is enough” if the stock is more than the quantity qnt, and outputs “not enough stock” if the stock is less than the quantity qnt. If there is no product having the same pid as the given pid, the program outputs “No applicable product”. When symbolic execution is performed on such a program, a control flow as shown in FIG. 4 is obtained. It is assumed that data.size is “10”. In the program as shown in FIG. 3, as shown in FIG. 4, when pid matches at the first case, when pid matches at the second case,. . . Pass conditions are accumulated for all cases, such as when the pid matches at the tenth case and when the pid does not match even at the tenth case.

  In such a case, the path condition is generated according to the number of cases of the number of elements in the data set on the symbolic execution even though it is originally uninterested in the number of matches. It causes a combination explosion due to a useless combination.

  A technique called bounded execution of a repetitive structure part conventionally used in bounded model checking (BLAST) or the like is known for such a combination explosion caused by a repetitive structure such as a for statement. However, in general, there is a problem that the number of repetitions cannot be fixed with an optimal length. Specifically, for all repeated structures of the program, regardless of its contents, it is bounded as “within a fixed number of times” (for example, up to 5 times for loops), so it is useless. A loop can remain.

JP 2009-87355 A JP-A-11-272503

  Therefore, an object of the present technology is to provide a technology for enabling an execution path to be properly grasped without generating a useless path condition in symbolic execution.

  In this symbolic execution support method, (A) a specific case is searched by repeatedly changing a control variable from an analysis target program stored in a program data storage unit, and a specific process is performed in the specific case. (B) In the program to be analyzed, in the program to be analyzed, the extracted repeated block and the block immediately after the repeated block are subjected to a specific process when true and false A conversion processing step for performing the processing of the immediately following block and performing a conversion process for replacing with a bifurcated structure including a predicate function relating to the truth, and storing the converted program in the converted program storage unit; (C) A logical constraint is generated for the predicate function included in the bifurcated structure, and the path condition data case And (D) detecting that the predicate function stored in the path condition data storage unit is being processed during symbolic execution of the converted program stored in the post-conversion program storage unit And generating a path condition at the appearance position of the predicate function from the logical constraint associated with the predicate function and additionally registering it in the management data of the symbolic execution unit.

  In symbolic execution, an execution path can be properly grasped without generating useless path conditions.

FIG. 1 is a diagram illustrating an example of a program. FIG. 2 is a diagram showing a control flow of the program of FIG. FIG. 3 is a diagram illustrating an example of a program. FIG. 4 is a diagram for explaining a problem of the conventional technique. FIG. 5 is a functional block diagram of the symbolic execution support apparatus. FIG. 6 is a functional block diagram of the symbolic execution support apparatus. FIG. 7 is a diagram showing a main flow of the present embodiment. FIG. 8 is a diagram illustrating a processing flow of preprocessing. FIG. 9 is a diagram illustrating an example of the analysis target program. FIG. 10 is a diagram illustrating an example of the extracted for block. FIG. 11 is a diagram for explaining a repeated pattern to be extracted. FIG. 12 is a diagram for describing registration in the existence check table. FIG. 13 is a diagram illustrating an example of the existence check table. FIG. 14 is a diagram illustrating a processing flow of preprocessing. FIG. 15 is a diagram illustrating an example of the generated if block. FIG. 16 is a diagram illustrating an example of a predicate function declaration. FIG. 17 is a diagram illustrating an example of the converted program. FIG. 18 is a diagram illustrating an example of a path condition table. FIG. 19 is a diagram for schematically explaining symbolic execution. FIG. 20 is a diagram illustrating an example of an execution path grasped by symbolic execution. FIG. 21 is a diagram illustrating a processing flow of symbolic execution time processing. FIG. 22 is a diagram showing an example of a control flow of the program shown in FIG. FIG. 23 is a functional block diagram of a computer.

  5 and 6 show functional block diagrams of the system according to the embodiment of the present technology. FIG. 5 shows a functional block diagram of the symbolic execution support device used in the preprocessing stage. The symbolic execution support apparatus includes an input unit 101, an input data storage unit 102, a processing target specifying unit 103, a check pattern storage unit 104, an existence check table storage unit 105, a two-branch structure generation unit 106, and a post-conversion A program storage unit 107 and a path condition table storage unit 108 are included.

  The input unit 101 accepts designation of a program to be analyzed and designation of variables related to symbolic execution from a user or the like, and stores those data in the input data storage unit 102. The check pattern storage unit 104 stores data on a pattern for extracting a repetitive block to be processed in the present embodiment. The processing target specifying unit 103 includes a loop extraction unit 1031 and a pattern check unit 1033, performs processing using data stored in the input data storage unit 102 and the check pattern storage unit 104, and an existence check table that is a processing result. Is stored in the existence check table storage unit 105.

  The bifurcated structure generation unit 106 includes an if block generation unit 1061 and a path condition table generation unit 1063, performs processing using data stored in the input data storage unit 102 and the existence check table storage unit 105, and obtains a processing result As a result, a post-conversion program is generated and stored in the post-conversion program storage unit 107. Similarly, a path condition table is generated as a processing result and stored in the path condition table storage unit.

  Next, FIG. 6 shows a configuration at the time of symbolic execution. The symbolic execution unit 200 is a module that performs an existing symbolic execution, and manages a function stack 211 that accumulates functions executed in a program to be analyzed, and a branch management table 213 for recording a control flow. . The branch management table 213 registers, for each branch point, a path condition when the branch condition is true and a path condition when it is false. Various symbolic execution units 200 are distributed, and may be, for example, Symbolic PathFinder, which is an extension of Java (registered trademark) PathFinder.

  The symbolic execution unit 200 processes the converted program stored in the converted program storage unit 107. During the execution of the symbolic execution unit 200, the path condition dynamic addition unit 151 introduced in the present embodiment uses the data stored in the path condition table storage unit 108 to the symbolic execution unit 200. Processing is to be performed. Note that the path condition dynamic addition unit 151 and the symbolic execution unit 200 may be integrated with the symbolic execution support device, or a symbolic execution device including the path condition dynamic addition unit 151 and the symbolic execution unit 200 is separately prepared. Sometimes it is done.

  Next, the operation of the system shown in FIGS. 5 and 6 will be described with reference to FIGS. In the present embodiment, preprocessing is first performed (step S1), and symbolic execution processing is performed using the result of the preprocessing (step S3).

  First, the preprocessing will be described with reference to FIGS. First, the input unit 101 receives a program to be analyzed and designation of a variable related to symbolic execution from the user, acquires the program to be analyzed, and stores it in the input data storage unit 102 together with the data of the variables (FIG. 8: step). S11). As for the program to be analyzed, a file containing the program is read from a storage device of the same device or acquired from another computer connected via a network.

  In the present embodiment, for example, a case where a program as shown in FIG. 9 is processed is considered. FIG. 9 is a part of the program, but variables item1 to 10, pid1, and qnt1 are variables related to symbol execution. Further, the purchase method is called once, and pid1 to which the product ID is input and qnt1 to which the quantity is input are passed. Further, the purchase method is basically the program shown in FIG.

  Then, the processing target specifying unit 103 reads the analysis target program stored in the input data storage unit 102 (step S13), and the loop extraction unit 1031 of the processing target specifying unit 103 repeats the repetitive block in the analysis target program. (For example, a for block) is extracted and stored in a storage device such as a main memory (step S15). Depending on the language, while or the like may be used, so that repeated blocks are detected according to the program language used in the analysis target program. In the case of the program of FIG. 9, a for block as shown in FIG. 10 is extracted.

  Then, the pattern check unit 1033 of the processing target specifying unit 103 specifies one unprocessed repetitive block among the specified repetitive blocks (step S17). After that, the pattern check unit 1033 uses the check pattern data stored in the check pattern storage unit 104 to check whether the identified repetitive block matches the repetitive block pattern that can be handled in this embodiment. (Step S19).

  In the present embodiment, it is confirmed whether or not it matches a pattern in which whether or not specific data exists is checked while rotating. Specifically, as shown in FIG. 11, a condition that determines whether or not the data is specific data (condition in the if statement) in the for loop, and a repetitive control variable (here i) Includes a condition that the procedure related to the repeated control variable i is not defined in processing other than a statement that sets the current data, and a condition that the loop is repeated as much as the size of the data set to be confirmed.

  If either of these conditions is not met, it is unclear whether the path condition can be logically correct when the simple bifurcated structure described below is corrected, and it is determined that it does not fit. Shall.

  If the identified repetitive block does not match the pattern as described above, the process proceeds to step S33 in FIG. On the other hand, when the identified repeated block matches the pattern as described above, the pattern check unit 1033 reads the condition part of the if statement in the repeated block (that is, whether or not it is specific data) from the analysis target program. A condition that determines whether or not, called an “if conditional statement”), a current data setting statement that sets current data by a repetitive control variable, a processing block that is true in an “if” conditional statement, and a false in an “if” conditional statement Are extracted and registered in the presence check table in the presence check table storage unit 105 (step S23). The processing shifts to the processing in FIG.

  For example, as shown in FIG. 12, in relation to the for block shown in FIG. 10, the if conditional statement D, the current data setting statement E, and the if conditional statement D are executed and the repeated control variable i is executed. A processing block F that does not include a procedure and a block G that is executed when the if conditional statement D is false and immediately after the for block are extracted and registered in the existence check table.

  FIG. 13 shows an example of the existence check table. In the example of FIG. 13, the existence condition field for the if conditional statement, the current data setting column for the current data setting statement, the processing block (true) column executed when true, and the case of false The processing block to be executed (false) column is included, and the extracted data D to G are registered as shown in FIG.

  Shifting to the description of the processing in FIG. 14, the if block generation unit 1061 of the two-branch structure generation unit 106 repeats the control variable i of the current data setting statement registered in the presence check table in the presence check table storage unit 105. Is changed to a predetermined fixed value (step S25).

  Thereby, the search range of the set data such as the target array or list is represented by one element. For example, assuming that i = 0, in the example of FIG. However, when the entire repetitive block currently focused on is called a plurality of times, the same element is used when the search conditions are the same, and different elements are used when the search conditions are different. For example, in the case of the program shown in FIG. 9, the purchase method is called only once, and therefore, the for block is searched with only one condition pid1. On the other hand, if the purchase method is called twice and a different condition of pid2 is passed the second time, the current data setting statement is changed as i = 1 instead of i = 0. That is, Item item = data.get (1) is changed.

  Then, the if block generation unit 1061 converts the repeated block and the block immediately after the repeated block into an if block according to the existence check table, and stores the converted program in the converted program storage unit 107 (step S27).

  Specifically, a predicate function that is true or false is introduced, and the predicate function is adopted for a newly introduced if conditional statement. When the predicate function is true, the current data setting statement registered in the existence check table and the processing block when true are executed. When the predicate function is false, the predicate function is registered in the existence check table. An if block that executes a processing block in the case of false is generated, and the for block to be processed of the analysis target program stored in the input data storage unit 102 in the if block and the immediately following for block Replace with block. When there are two or more for blocks, the second and subsequent for blocks are replaced with the program stored in the post-conversion program storage unit 107 and processed immediately before. Further, the variable data related to symbolic execution stored in the input data storage unit 102 is also stored in the converted program storage unit 107.

  For example, an if block as shown in FIG. 15 is generated. In the example of FIG. 15, a predicate function called _EXIST1 is introduced. For such a predicate function, a rule such as _EXIST + number may be determined in advance and determined in this step. In the example of FIG. 15, the contents of the current data setting column and the contents of the processing block (true) column of the existence check table are embedded in the processing block in which _EXIST1 is true, and the processing block in which _EXIST1 is false is embedded. The contents of the processing block (false) of the existence check table are embedded.

  Further, the if block generation unit 1061 generates a block that declares the predicate function adopted in the conditional statement of the if block, and adds it to the front of the if block (step S29). For example, as shown in FIG. 16, a block that declares the predicate function as a dummy function is generated.

  After performing such processing, the if block generation unit 1061 stores the processed program in the converted program storage unit 107. In the example described above, a converted program as shown in FIG. 17 is generated and stored in the converted program storage unit 107.

  Further, the path condition table generating unit 1063 of the two-branch structure generating unit 106 registers the predicate function and its logical constraint adopted in the conditional statement of the if block in the path condition table in the path condition table storage unit 108 (step S31). ). Since it is a predicate function introduced temporarily, the logical constraint may be determined so that it can be distinguished from other logical constraints. For example, a logical constraint _exist1 may be used for the predicate function _EXIST1.

  The path condition table is, for example, a table as shown in FIG. A logical constraint is registered in association with the function name.

  In this way, a program as shown in FIG. 19 is obtained as a rough structure of the program, and if this is executed symbolically, a control flow as shown in FIG. 20 is grasped. That is, the newly introduced if statement branches into the case of path condition_exist1 and the case of path condition not (_exist1). Thereafter, different processes, that is, block 1 or block 2 are executed.

  Thereafter, the processing target specifying unit 103 determines whether all repeated blocks have been processed (step S33). If there is an unprocessed repeated block, the process target identifying unit 103 returns to step S17 via the terminal C. On the other hand, when all the repeated blocks have been processed, the process returns to the original process.

  In this way, the preprocessing to be performed before the symbolic execution is performed is completed. By performing such conversion, it is possible to avoid a situation in which the number of combinations of path conditions is unnecessarily increased in a for block that confirms the existence of data that satisfies a specific condition. However, even if the symbolic execution unit 200 performs symbolic execution as usual, the predicate function of the newly introduced if conditional statement is not treated as a symbol.

  Therefore, the path condition dynamic adding unit 151 executes the symbolic execution time process so that an appropriate path condition is inserted at an appropriate position.

  The symbolic execution process will be described with reference to FIGS. 21 and 22. The symbolic execution unit 200 starts executing the converted program stored in the converted program storage unit 107 in response to an instruction from the user or the like or an instruction from the processing target specifying unit 103 (step S41). The symbolic execution unit 200 symbol-executes the converted program by a known method. At the time of symbol execution, as shown in FIG. 6, the functions to be executed in the post-conversion program are loaded on the function stack 211, and the path condition when the branch condition is true at the branch point and the false path condition are Assume that it is registered in the management table 213.

  Therefore, until the symbolic execution ends (step S43), the path condition dynamic addition unit 151 performs the following processing. The path condition dynamic adding unit 151 monitors the function stack 211 described above (step S45), the latest function name loaded in the function stack 211, and the function in the path condition table in the path condition table storage unit 108. Compare the function name registered in the name column. Then, the path condition dynamic adding unit 151 determines whether or not the latest function name loaded in the function stack 211 matches the function name in the path condition table (step S47). If the latest function name loaded in the function stack 211 does not match the function name in the path condition table, the process returns to step S43.

  On the other hand, when the latest function name loaded in the function stack 211 matches one of the function names in the path condition table, the path condition dynamic adding unit 151 passes the path condition table in the path condition table storage unit 108. , A true and false path condition is generated from the logical constraint registered in association with the function name determined to match the latest function name loaded in the function stack 211, and the branch management table together with the branch point Registered in 213 (step S49). After this process, the process returns to step S43.

  For example, in the case of a path condition table as shown in FIG. 18, since the function name is _EXIST1 (), the branch point can be automatically specified as if (_EXIST1 ()). Further, since the corresponding logical constraint _exist1 is obtained, a true path condition included in the immediately preceding record of the branch management table 213 or a true path condition including _exist1 is generated, and similarly the branch management table A false path condition including a true path condition or a false path condition included in the record immediately before 213 and not (_exist1) is generated, and additionally registered in the branch management table 213 together with the branch point.

  In this way, by adding a record to the branch management table 213, it is possible to reflect the effect of converting a repetitive block into an if block. That is, it is possible to avoid a combination of useless path conditions due to a repetitive structure, and it is possible to grasp the control flow in a simple logically correct form.

  For example, if attention is paid only to the repetitive block and the immediately following block in FIG. 9, a control flow as shown in FIG. Compared with FIG. 3, it is branched when there is corresponding data and when there is no corresponding data, and when there is corresponding data, it only branches depending on whether the quantity is sufficient or insufficient. The path is removed so that the execution path of the program can be expressed simply but logically.

  Although the embodiment of the present technology has been described above, the present technology is not limited to this. For example, the functional block diagrams shown in FIG. 5 and FIG. 6 are examples, and may differ from actual program module configurations.

  As for the processing flow, as long as the processing result does not change, the order of the steps may be changed or may be executed in parallel.

  Note that the symbolic execution support apparatus described above is a computer apparatus, and as shown in FIG. 23, a display connected to a memory 2501, a processor (CPU 2503), a hard disk drive (HDD) 2505, and a display device 2509. A control unit 2507, a drive device 2513 for a removable disk 2511, an input device 2515, and a communication control unit 2517 for connecting to a network are connected by a bus 2519. An operating system (OS) and an application program for executing the processing in this embodiment are stored in the HDD 2505, and are read from the HDD 2505 to the memory 2501 when executed by the CPU 2503. If necessary, the CPU 2503 controls the display control unit 2507, the communication control unit 2517, and the drive device 2513 to perform necessary operations. Further, data in the middle of processing is stored in the memory 2501 and stored in the HDD 2505 if necessary. In an embodiment of the present technology, an application program for performing the above-described processing is stored in a computer-readable removable disk 2511 and distributed, and installed from the drive device 2513 to the HDD 2505. In some cases, the HDD 2505 may be installed via a network such as the Internet and the communication control unit 2517. Such a computer apparatus realizes various functions as described above by organically cooperating hardware such as the CPU 2503 and the memory 2501 described above, the OS, and necessary application programs.

  The above-described embodiment can be summarized as follows.

  In this symbolic execution support method, (A) a specific case is searched by repeatedly changing a control variable from an analysis target program stored in a program data storage unit, and a specific process is performed in the specific case. (B) In the program to be analyzed, in the program to be analyzed, the extracted repeated block and the block immediately after the repeated block are subjected to a specific process when true and false A conversion processing step for performing the processing of the immediately following block and performing a conversion process for replacing with a bifurcated structure including a predicate function relating to the truth, and storing the converted program in the converted program storage unit; (C) A logical constraint is generated for the predicate function included in the bifurcated structure, and the path condition data case And (D) detecting that the predicate function stored in the path condition data storage unit is being processed during symbolic execution of the converted program stored in the post-conversion program storage unit And generating a path condition at the appearance position of the predicate function from the logical constraint associated with the predicate function and additionally registering it in the management data of the symbolic execution unit.

  By executing such processing, it is possible to appropriately grasp the execution path without generating a useless path condition.

  In addition, the conversion process described above adds the declaration of the predicate function to the analysis target program, the current data setting statement for identifying the current case with the repeat control variable, and the repeat control variable as a fixed value. And a process for replacing with the current data setting sentence set in (1). You will be able to perform symbolic execution under the correct grammar.

  In addition, the pattern described above may be a pattern including a condition that the control variable is not repeatedly used in a specific process. This is because when a repetitive control variable is used, it may be different from a simple bifurcated structure.

  Furthermore, the conversion processing step described above includes, from the analysis target program, a current data setting statement for identifying the current case with a repetitive control variable, a specific processing block included in the extracted repetitive block, A step immediately after the extracted repetitive block may be extracted and associated and registered in the existence check table, and a two-branch structure may be generated using data associated with the existence check table. . In this way, an appropriate bifurcated structure can be generated.

  A program for causing a computer to perform the processing described above can be created, such as a flexible disk, a CD-ROM, a magneto-optical disk, a semiconductor memory (for example, ROM), a hard disk, etc. Stored in a computer-readable storage medium or storage device. Note that data being processed is temporarily stored in a storage device such as a RAM.

  The following supplementary notes are further disclosed with respect to the embodiments including the above examples.

(Appendix 1)
From a program to be analyzed stored in the program data storage unit, a repeated control variable is changed to search for a specific case, and a repeated block that matches a pattern of executing a specific process in the specific case is extracted. Steps,
In the program to be analyzed, the extracted repeated block and the block immediately after the repeated block are subjected to the specific processing when true and the processing of the immediately following block is performed when false. A conversion process step of performing a conversion process to replace with a bifurcated structure including a predicate function relating to true / false, and storing the converted program in the converted program storage unit;
Generating a logical constraint for the predescription word function included in the two-branch structure and storing it in a path condition data storage unit;
When it is detected that the predescription function stored in the path condition data storage unit is being processed during symbolic execution of the converted program stored in the post-conversion program storage unit, the predicate function A step of generating a path condition at the appearance position of the previous description word function from the associated logical constraint and additionally registering it in the management data of the symbolic execution unit;
Is a symbolic execution support program for causing a computer to execute.

(Appendix 2)
The conversion process is
A process of adding a declaration of a predescription function to the program to be analyzed;
A process of replacing a current data setting statement for identifying the current case with the repetition control variable with a current data setting statement in which the repetition control variable is set to a fixed value;
A symbolic execution support program according to appendix 1, including:

(Appendix 3)
The symbolic execution support program according to Supplementary Note 1 or 2, wherein the pattern includes a condition that a repetitive control variable is not used in the specific process.

(Appendix 4)
The conversion processing step includes:
From the analysis target program, a current data setting statement for specifying the current case with the repetition control variable, the block of the specific process included in the extracted repetition block, and the extracted repetition block Extracting the block immediately after and registering it in the presence check table in association with each other;
Generating the bifurcated structure with data associated with the presence check table;
The symbolic execution support program according to any one of supplementary notes 1 to 3, including:

(Appendix 5)
From a program to be analyzed stored in the program data storage unit, a repeated control variable is changed to search for a specific case, and a repeated block that matches a pattern of executing a specific process in the specific case is extracted. Steps,
In the program to be analyzed, the extracted repeated block and the block immediately after the repeated block are subjected to the specific processing when true and the processing of the immediately following block is performed when false. A conversion process step of performing a conversion process to replace with a bifurcated structure including a predicate function relating to true / false, and storing the converted program in the converted program storage unit;
Generating a logical constraint for the predescription word function included in the two-branch structure and storing it in a path condition data storage unit;
When it is detected that the predescription function stored in the path condition data storage unit is being processed during symbolic execution of the converted program stored in the post-conversion program storage unit, the predicate function A step of generating a path condition at the appearance position of the previous description word function from the associated logical constraint and additionally registering it in the management data of the symbolic execution unit;
A symbolic execution support method executed on a computer.

(Appendix 6)
From a program to be analyzed stored in the program data storage unit, a repeated control variable is changed to search for a specific case, and a repeated block that matches a pattern of executing a specific process in the specific case is extracted. A processing target specifying part;
In the program to be analyzed, the extracted repeated block and the block immediately after the repeated block are subjected to the specific processing when true and the processing of the immediately following block is performed when false. A two-branch block generation unit that performs conversion processing to replace with a two-branch structure including a predicate function relating to true / false, and stores the converted program in the converted program storage unit;
A path condition table generating unit that generates a logical constraint for the pre-description word function included in the bifurcated structure and stores the logical constraint in a path condition data storage unit;
When it is detected that the predescription function stored in the path condition data storage unit is being processed during symbolic execution of the converted program stored in the post-conversion program storage unit, the predicate function A path condition dynamic addition unit that generates a path condition at the appearance position of the predescription word function from the associated logical constraint and additionally registers it in the management data of the symbolic execution unit;
A symbolic execution support device.

DESCRIPTION OF SYMBOLS 101 Input part 102 Input data storage part 103 Processing object specific | specification part 104 Check pattern storage part 105 Existence check table storage part 106 Two-branch structure production | generation part 107 Converted program storage part
108 path condition table storage unit 1031 loop extraction unit 1033 pattern check unit 1061 if block generation unit
1063 Path condition table generation unit 151 Path condition dynamic addition unit 200 Symbolic execution unit

Claims (6)

From a program to be analyzed stored in the program data storage unit, a repeated control variable is changed to search for a specific case, and a repeated block that matches a pattern of executing a specific process in the specific case is extracted. Steps,
In the program to be analyzed, the extracted repeated block and the block immediately after the repeated block are subjected to the specific processing when true and the processing of the immediately following block is performed when false. A conversion process step of performing a conversion process to replace with a bifurcated structure including a predicate function relating to true / false, and storing the converted program in the converted program storage unit;
Generating a logical constraint for the predescription word function included in the two-branch structure and storing it in a path condition data storage unit;
When it is detected that the predescription function stored in the path condition data storage unit is being processed during symbolic execution of the converted program stored in the post-conversion program storage unit, the predicate function A step of generating a path condition at the appearance position of the previous description word function from the associated logical constraint and additionally registering it in the management data of the symbolic execution unit;
Is a symbolic execution support program for causing a computer to execute. The conversion process is
A process of adding a declaration of a predescription function to the program to be analyzed;
A process of replacing a current data setting statement for identifying the current case with the repetition control variable with a current data setting statement in which the repetition control variable is set to a fixed value;
The symbolic execution support program according to claim 1, comprising: The symbolic execution support program according to claim 1, wherein the pattern includes a condition that a repetitive control variable is not used in the specific process. The conversion processing step includes:
From the analysis target program, a current data setting statement for specifying the current case with the repetition control variable, the block of the specific process included in the extracted repetition block, and the extracted repetition block Extracting the block immediately after and registering it in the presence check table in association with each other;
Generating the bifurcated structure with data associated with the presence check table;
4. The symbolic execution support program according to claim 1, comprising: From a program to be analyzed stored in the program data storage unit, a repeated control variable is changed to search for a specific case, and a repeated block that matches a pattern of executing a specific process in the specific case is extracted. Steps,
In the program to be analyzed, the extracted repeated block and the block immediately after the repeated block are subjected to the specific processing when true and the processing of the immediately following block is performed when false. A conversion process step of performing a conversion process to replace with a bifurcated structure including a predicate function relating to true / false, and storing the converted program in the converted program storage unit;
Generating a logical constraint for the predescription word function included in the two-branch structure and storing it in a path condition data storage unit;
When it is detected that the predescription function stored in the path condition data storage unit is being processed during symbolic execution of the converted program stored in the post-conversion program storage unit, the predicate function A step of generating a path condition at the appearance position of the previous description word function from the associated logical constraint and additionally registering it in the management data of the symbolic execution unit;
A symbolic execution support method executed on a computer. From a program to be analyzed stored in the program data storage unit, a repeated control variable is changed to search for a specific case, and a repeated block that matches a pattern of executing a specific process in the specific case is extracted. A processing target specifying part;
In the program to be analyzed, the extracted repeated block and the block immediately after the repeated block are subjected to the specific processing when true and the processing of the immediately following block is performed when false. A two-branch block generation unit that performs conversion processing to replace with a two-branch structure including a predicate function relating to true / false, and stores the converted program in the converted program storage unit;
A path condition table generating unit that generates a logical constraint for the pre-description word function included in the bifurcated structure and stores the logical constraint in a path condition data storage unit;
When it is detected that the predescription function stored in the path condition data storage unit is being processed during symbolic execution of the converted program stored in the post-conversion program storage unit, the predicate function A path condition dynamic addition unit that generates a path condition at the appearance position of the predescription word function from the associated logical constraint and additionally registers it in the management data of the symbolic execution unit;
A symbolic execution support device.

Images