CN102231109A - Traceless manageable automatic source code instrumentation method - Google Patents

Abstract

A traceless and manageable source code automatic insertion method, the steps include: 40: start, open a project; 41: define a file filter, match the required insertion projects, and keep the matched projects; 42: Then use the file filter to filter the instrumented source files; 43: select the specific application type of automatic instrumentation, and define the code for the corresponding type of instrumentation; 44: use the syntax tree structure to match, according to the automatic instrumentation The specific application type is used to locate the position of the corresponding insertion point, and insert the code at the corresponding position to generate a new source file; 45: compile the new source file to generate a new executable bytecode file, and save it; 46: Generate executable file, end. The main features of this method are visualization of the instrumentation code, centralized management of the insertion code, traceless instrumentation process, automatic positioning of instrumentation points, scalable automatic instrumentation, and high efficiency of automatic instrumentation.

Description

Untraceable and manageable source code automatic instrumentation method

technical field

The invention relates to dynamic analysis of computer programs, and mainly relates to a traceless and manageable source code stub insertion method. The method includes five parts: visualization of insertion points, management of insertion points, positioning of insertion points, automatic insertion framework, and optimization of automatic insertion performance.

Background technique

Program analysis usually uses static program analysis and dynamic program analysis to automatically analyze program behavior, thereby improving software quality. Dynamic program analysis often collects the dynamic running behavior of programs by means of instrumentation. Some program behaviors related to the operating environment can only be collected through instrumentation, but static program analysis cannot be analyzed. During the software development process, the code reviewer uses the source code instrumentation method to review the code after the code writing stage is completed. Usually, the reviewer has the right to read the source code but is inconvenient to modify the code. By analyzing the running behavior of the program, the errors in the code can be found as early as possible, so as to improve the software quality. Source code instrumentation can make full use of program semantics, visually display instrumented code, and will not increase the complexity of code logic.

The program instrumentation technology is to insert some probes into the program on the basis of ensuring the original logical integrity of the program under test, and throw out the characteristic data of the program operation through the execution of the probes. Through the analysis of these data, we can obtain The control flow and data flow information of the program, and then obtain dynamic information such as logic coverage, so as to achieve the method of testing. The program instrumentation technology inserts probes into the program under test, and then obtains the control flow and data flow information of the program through the execution of the probes, so as to achieve the purpose of testing. Therefore, according to the time of probe insertion, it can be divided into object code instrumentation and source code instrumentation.

Existing instrumentation methods mainly include three types of methods: assertion mechanism, bytecode instrumentation, and aspect-oriented instrumentation. The assertion mechanism directly adds instrumentation code to the source file, which will reduce the readability of the code. Bytecode instrumentation directly modifies the bytecode file, the source code of the inserted bytecode cannot be visualized, and the correctness of the code insertion process cannot be guaranteed. Aspect-oriented stubbing increases the horizontal aspect relationship on the basis of the vertical inheritance relationship of the program, which increases the logical complexity of the program.

At present, the instrumentation technology mainly has the problems of the visualization of the instrumentation point and its code, the management of the inserted code, the automatic positioning of the instrumentation point, and the low performance of the automatic instrumentation.

Contents of the invention

In view of the above problems, the present invention aims to provide a source code insertion method, which not only supports manual insertion, but also supports batch automatic insertion. Its main features are instrumentation code visualization, centralized management of insertion code, traceless instrumentation process, automatic positioning of instrumentation points, automatic instrumentation scalability, and automatic instrumentation efficiency.

The present invention is achieved through the following technical solutions:

A traceless and manageable source code automatic piling method, the steps include:

Step 40: start, open a project;

Step 41: Define a file filter, match the required projects for stub insertion, and keep the matched projects;

Step 42: Then use the file filter to filter the inserted source file;

Step 43: Select the specific application type of automatic stub insertion, and define the code for the stub insertion required by the corresponding type;

Step 44: use syntax tree structure matching, locate the position of the corresponding insertion point according to the specific application type of automatic insertion, and insert code at the corresponding position to generate a new source file;

Step 45: The new source file is compiled to generate a new executable bytecode file, and saved;

Step 46: generate an executable file, end.

This automatic instrumentation method provides a meta-instrumentation type reuse framework, including a meta-instrumentation operation combiner and a meta-instrumentation type pool, where,

The meta-instrumentation type pool includes multiple meta-instrumentation types, and supports adding new meta-instrumentation types;

The meta-insertion operation combiner combines multiple meta-insertion types together, and completes various types of instrumentation operations on the syntax tree by traversing the syntax tree once;

The meta-instrumentation type supports the instrumentation of different types of instrumentation, and each meta-instrumentation type can only be instrumented for a certain type of meta-instrumentation.

In the step 41, the required project for stubbing is matched, including matching packages, files, and methods in the project.

In described step 42, the step of described source file filtering comprises:

Step 60: start: source file filtering is to filter all source files in a certain workspace;

Step 61: First judge whether the workspace contains other projects, if not, go to step 64, if yes, go to step 62;

Step 62: Match the project name, if it matches, go to step 63, if not, return to step 61 and continue to check whether there is a next project;

Step 63: If the project name matches, it means that the project needs to be inserted, add it to the set of inserted projects, and then jump back to step 61;

Step 64: Perform package filtering, first determine whether the projects in the project collection contain other packages (the description of other packages here: Java projects include multiple packages, filter them one by one, and see if there are any other packages that have not been filtered .Package refers to the concept of package in the java language), if not then jump to step 67 and start to filter the file, if there is then enter step 65;

Step 65: Match the package name, if it matches, then enter step 66, if it does not match, then return to step 64 and continue to check whether there is a next package;

Step 66: Match the package name, if it matches, it means that the package needs to be instrumented, add it to the instrumentation package collection, and then jump back to step 64;

Step 67: Determine whether the package in the package collection contains other source files, if not, jump to step 6b, and if yes, go to step 68;

Step 68: Match the source file name, if it matches, go to step 69 to match the method, otherwise jump back to step 67;

Step 69: Matching method, if it matches, go to step 6a, otherwise jump back to step 67;

Step 6a: Add matching source files to the file matching collection;

Step 6b: After matching all project names, package names, file names and method names in the project, the file filtering operation is completed.

In the step 62, matching the project name is to match the project name with the project name regular expression;

In the step 65, matching the package name is to match the package name with the package name regular expression;

In the step 66, matching the package name is to match the package name with the package name regular expression;

In the step 68, matching the source file name is to match the source file name with the source file name regular expression;

In the step 69, the matching method is to match the method name of the method in the source file with the method name regular expression.

In the step 44, the positioning of stubs can be realized through syntax tree matching. This part uses the visitor mode for matching, and the steps of syntax tree matching and inserting code include:

Step 70: Start: The instrumentation of source files is performed file by file, and then instrumentation is performed according to different instrumentation types; instrumentation types include method, IF branch, Switch branch, While branch, Do-while branch and For branch type;

Step 71: check whether there is a next source file, if not, then enter step 7h, end; if there is, then enter step 72;

Step 72: First compile the source file into a syntax tree, and then visit each node in the Visitor mode. The operation steps of several types of stubs under the Visitor model are as follows:

Step 73: first determine whether the syntax tree has a next node;

Step 74: Determine whether the method type is included according to the selected stub type, if it is included and the node is a method body node, then go to step 75, otherwise go to step 76;

Step 75: Insert the instrumentation code of the method type defined by the analyst into the corresponding node in the abstract syntax tree;

Step 76: Determine whether the IF branch type is included according to the selected stub type, if it is included and the node is an IF branch node, then go to step 77, otherwise go to step 78;

Step 77: Insert the IF branch type instrumentation code defined by the analyst in advance into the corresponding node in the abstract syntax tree;

Step 78: Determine whether the Switch branch type is included according to the selected stub type, if it is included and the node is a Switch branch node, then enter step 79, otherwise jump to step 7a;

Step 79: Insert the Switch branch type instrumentation code defined by the analyst in advance into the corresponding node in the abstract syntax tree;

Step 7a: Determine whether the While branch type is included according to the selected stub type, if it is included and the node is a While branch node, go to step 7b, otherwise skip to step 7a;

Step 7b: Insert the While branch type instrumentation code defined by the analyst into the corresponding node in the abstract syntax tree;

Step 7c: Determine whether the Do-While branch type is included according to the selected stub type, if it is included and the node is a Do-While branch node, then enter step 7d, otherwise jump to step 7a;

Step 7d: Insert the Do-While branch type instrumentation code defined by the analyst into the corresponding node in the abstract syntax tree;

Step 7e: Determine whether the For branch type is included according to the selected stub type, if it is included and the node is a For branch node, then go to step 7f, otherwise jump to step 7a;

Step 7f: Insert the instrumentation code of the For branch type defined by the analyst in advance into the corresponding node in the abstract syntax tree;

Step 7g: After completing the syntax tree instrumentation, convert the syntax tree into a source code file, and then proceed to step 73 to perform instrumentation for the next source file;

Step 7h: The instrumentation of all files is completed, and the whole process ends.

The automatic insertion scheme of the present invention is carried out for a specific application type, and the automatic positioning of the insertion point is performed by using the structure matching of the abstract syntax tree, and the automatic positioning of the insertion point is the key point of the automatic insertion part. After positioning, add the syntax tree of the code fragment to the corresponding position in the syntax tree of the original file, then convert the generated new syntax tree into source code, and finally compile the new file into a bytecode file, and the resulting bytecode The file can be run directly.

The entire automatic instrumentation process is performed file by file. First, compile the original file and instrumentation code into a syntax tree, and then traverse the syntax tree of each file to check whether it has a syntax tree structure that matches the instrumentation type. After finding the matching syntax tree node, merge the syntax tree corresponding to the instrumentation type code into the syntax tree of the original file.

The syntax tree structure matching uses the Visitor design pattern, which traverses the entire syntax tree node by node, and then realizes the matching of the tree structure.

In order to improve the efficiency of automatic post insertion, the present invention provides a file filtering method and a meta-insertion type reuse framework for automatic post insertion.

The file filtering method can be used to filter the files to be compiled to reduce the number of files to be compiled. During program analysis, only part of the code in the entire workspace (or project) needs to be analyzed. The analyst already has an understanding of the structure of the workspace (or project), and uses the analyst’s existing knowledge to optimize the automatic pile insertion process. The analyzer defines some regular expressions to filter the files, and the matching files (projects or packages) will be kept. Through the above scheme, the number of required compilation files will be greatly reduced.

Furthermore, in automatic instrumentation, if the instrumentation process of each meta-instrumentation type needs to traverse the syntax tree once, then the overhead will be very high when using multiple meta-instrumentation types for instrumentation. The cost of the whole process is mainly reflected in the compilation of the original file, and the time cost of compiling the file into a syntax tree is high. The present invention provides a framework for reusing meta-instrumentation types to solve this problem. The meta-instrumentation type reuse framework mainly includes: meta-instrumentation type pool, meta-instrumentation operation combiner, wherein the meta-instrumentation type pool contains multiple meta-instrumentation types. Each meta-instrumentation type is for a specific type and defines the structure matching of the instrumentation point, but the meta-instrumentation type cannot directly operate on the syntax tree, and needs to be used in conjunction with the meta-instrumentation operation combiner . The meta-instrumentation combiner will traverse the syntax tree of the file, and modify the syntax tree according to the structure defined by the meta-instrumentation type. The meta-instrumentation type pool supports the definition and addition of new instrumentation types, thereby realizing the extension of automatic instrumentation for different application types.

The invention saves the post-inserting code by using the mark, distinguishes the post-inserting code from the original code, and improves the visualization ability of the post-inserting code. The flag can display the corresponding instrumentation code at the instrumentation position without interfering with the editing work of the original file. At the same time, all instrumentation flags can be managed centrally, thereby improving the management ability of instrumentation codes. The invention also utilizes syntax tree structure matching to realize automatic positioning of the insertion point, and the automatic positioning can effectively realize the automatic insertion function. On the abstract syntax tree, automatic instrumentation adds instrumentation code at the resulting location, and then converts the new syntax tree into a source file. In order to improve the efficiency of automatic pile insertion, the present invention also designs a framework for file filtering and meta-instrumentation type reuse. All the above operations are completed in the background without modifying the user's original files, and the whole process is a traceless process.

Attached content

Figure 1 is a complete flowchart of automatic pile insertion.

Fig. 2 is a frame diagram of meta-instrumentation type reuse of automatic instrumentation.

Fig. 3 is a flow chart of file filtering in automatic post insertion.

Fig. 4 is a flow chart of syntax tree matching and code insertion in automatic stub insertion.

Detailed ways

The technical scheme of the present invention will be described in further detail below with reference to the accompanying drawings.

A traceless and manageable source code automatic insertion method, this method is carried out for a specific application type, using the structure matching of the abstract syntax tree to automatically locate the insertion point, the automatic positioning of the insertion point and the automatic insertion part focus. After positioning, add the syntax tree structure of the code fragment to the corresponding position in the syntax tree structure of the original file, convert the generated new syntax tree into source code and compile it into bytecode, and the resulting bytecode can be run directly. The complete flowchart of automatic pile insertion is shown in Figure 1, including the following steps:

Step 40: the start of the entire automatic pile insertion process, at this time open a project and prepare to analyze it through pile insertion;

Step 41: Define a file filter. The file filter uses regular expressions to match the required instrumentation projects (packages, files, methods), and the matched ones will be retained;

Step 42: Then use the filter defined above to filter the inserted files, and use the analyst's existing knowledge of the project files to improve the automatic insertion performance;

Step 43: Select the type of stub required, and define the code of the stub required for the relevant type;

Step 44: Then use syntax tree structure matching to locate the position of the insertion point according to different insertion types, and insert the code at the corresponding position to finally generate a new file;

Step 45: Compile the above-mentioned new files to generate new executable bytecode files, and save these files;

Step 46: Finally, an executable file is generated, and the original file information will not be modified in the whole process, and the whole process is a traceless process.

In the automatic instrumentation scheme, a file filtering scheme and a meta-instrumentation type reuse framework are provided to improve the efficiency of instrumentation. The frame diagram of meta-instrumentation type reuse for automatic instrumentation is shown in Figure 2. The framework is mainly composed of two parts: meta-instrumentation operation combiner and meta-instrumentation type pool. Among them, the meta-instrumentation type supports different types of instrumentation, and each meta-insertion can only be instrumented for a certain type. The meta instrumentation type pool contains multiple meta instrumentation types and supports adding new meta instrumentation types. The meta-instrumentation combiner is used to combine multiple meta-instrumentation types together, and completes multiple types of instrumentation operations on the syntax tree by traversing the syntax tree once.

The file filtering scheme reduces the number of compiled files by reducing the set of instrumented files. During the instrumentation process, not every file needs to be instrumented. Compiling some irrelevant files and traversing the syntax tree will waste a lot of time. File filtering will greatly reduce the size of the instrumentation file set. The flowchart of automatic instrumentation file filtering is shown in Figure 3, including the following steps:

Step 60: Automatically inserting file filtering is to filter all files in a certain workspace;

Step 61: first check whether the workspace contains other projects, if not, jump to step 64 to start packet filtering, and if so, go to the next step;

Step 62: Match the project name with the regular expression of the project name, if it matches, enter the next step, if not, return to step 61 and continue to check whether there is a next project;

Step 63: The project name matches the regular expression, indicating that the project needs to be instrumented, add it to the instrumentation project collection, and then jump back to step 61;

Step 64: first check whether the projects in the project collection contain other packages, if not, jump to step 67 to start filtering files, and if so, go to the next step;

Step 65: Match the package name with the regular expression of the package name, if it matches, then enter the next step, if not, return to step 64 and continue to check whether there is a next package;

Step 66: The package name matches the regular expression, indicating that the package needs to be instrumented, add it to the instrumentation package collection, and then jump back to step 64;

Step 67: First check whether the packages in the package collection contain other files, if not, go to step 6b, and if so, go to the next step;

Step 68: Match the file name with the regular expression of the file name, if it matches, go to the next step to match the method name, otherwise jump back to step 67;

Step 69: Check whether the file contains a method that matches the regular expression of the method name, if it matches, go to the next step, otherwise jump back to step 67;

Step 6a: Add the matched files to the file matching collection;

Step 6b: After matching all project names, package names, file names and method names in the project, the file filtering operation is completed.

Insertion positioning can be realized through syntax tree matching. This part uses the visitor pattern in the design mode for matching. The flow chart of syntax tree matching and code insertion is shown in Figure 4, including the following steps:

Step 70: The instrumentation of files is performed file by file, and then instrumentation is performed according to different instrumentation types. The following process includes the method, IF branch, Switch branch, While branch, Do-while branch, and For branch types. The tree structure is matched and instrumented.

Step 71: Check whether there is a next file, if not, end, otherwise enter the next step;

Step 72: Compile the file into a syntax tree for subsequent instrumentation and positioning. Next, we will visit each node in the Visitor mode. The following steps describe the operations of several types of instrumentation under the visitor model;

Step 73: first determine whether the syntax tree has a next node;

Step 74: Determine whether the method type is included according to the selected stub type, if it is included and the node is a method body node, then go to the next step, otherwise go to step 76;

Step 75: inserting the instrumentation code of the method type defined by the analyst into the abstract syntax tree;

Step 76: Determine whether the IF branch type is included according to the selected stub type, if it is included and the node is an IF branch node, then go to the next step, otherwise go to step 78;

Step 77: Insert the IF branch type instrumentation code defined by the analyst into the abstract syntax tree;

Step 78: Determine whether the Switch branch type is included according to the selected stub type, if it is included and the node is a Switch branch node, then go to the next step, otherwise go to step 7a;

Step 79: Insert the Switch branch type instrumentation code defined by the analyst in advance into the abstract syntax tree;

Step 7a: Determine whether the While branch type is included according to the selected stub type, if it is included and the node is a While branch node, then go to the next step, otherwise go to step 7a;

Step 7b: Insert the While branch type instrumentation code defined by the analyst in advance into the abstract syntax tree;

Step 7c: Determine whether the Do-While branch type is included according to the selected stub type, if it is included and the node is a Do-While branch node, then go to the next step, otherwise go to step 7a;

Step 7d: Insert the Do-While branch type instrumentation code defined by the analyst into the abstract syntax tree;

Step 7e: Determine whether the For branch type is included according to the selected stub type, if it is included and the node is a For branch node, then go to the next step, otherwise go to step 7a;

Step 7f: Insert the instrumentation code of the For branch type defined by the analyst into the abstract syntax tree;

Step 7g: After the syntax tree instrumentation is completed, convert the syntax tree into a source code file, and then proceed to the next step to instrument the next file;

Step 7h: The instrumentation of all files is completed, and the whole process ends;

Finally, compile the generated new file to generate a bytecode file containing the original file and instrumented code, and run these files to obtain the running result of the instrumented file.

The technical solution of the present invention uses the mark to edit and save the inserted code, and the inserted mark can distinguish the inserted code from the original code, and can display the inserted code at the inserted position, which can effectively improve the readability of the program. The instrumentation flag does not affect the editing work of the source program, and the centralized management of the instrumentation point improves the usability of the instrumentation flag. The invention improves the positioning accuracy by using syntax tree structure matching, compiles the original source code file into a syntax tree, performs structure matching, modifies the syntax tree, and finally converts the syntax tree into a source code file. In addition, in order to improve the matching efficiency, the scheme also proposes a file filtering method and a meta-insertion type reuse framework. The file filtering method effectively reduces the number of files to be compiled and traversed, and the meta-instrumentation type reuse framework enables multiple instrumentation types to be completed in one syntax tree traversal.

Finally, it should be noted that the above steps are only used to illustrate the technical solution of the present invention rather than limit it. Although the above steps have described the present invention in detail, those skilled in the art should understand that the specific technologies of the present invention can still be modified or some technologies can be equivalently replaced; without departing from the spirit of the technical solutions of the present invention, they should cover In the scope of the technical solutions claimed in the present invention.

Claims (6)

1. A traceless and manageable source code automatic insertion method, characterized in that the steps include: Step 40: start, open a project; Step 41: Define a file filter, match the required projects for stub insertion, and keep the matched projects; Step 42: Then use the file filter to filter the inserted source file; Step 43: Select the specific application type of automatic stub insertion, and define the code for the stub insertion required by the corresponding type; Step 44: use syntax tree structure matching, locate the position of the corresponding insertion point according to the specific application type of automatic insertion, and insert code at the corresponding position to generate a new source file; Step 45: The new source file is compiled to generate a new executable bytecode file, and saved; Step 46: generate an executable file, end. 2. The traceless and manageable source code automatic instrumentation method according to claim 1, characterized in that the automatic instrumentation method provides a meta-instrumentation type reuse framework, including a meta-instrumentation operation combiner and a meta-instrumentation type pool, where The meta-instrumentation type pool includes multiple meta-instrumentation types, and supports adding new meta-instrumentation types; The meta-insertion operation combiner combines multiple meta-insertion types together, and completes various types of instrumentation operations on the syntax tree by traversing the syntax tree once; The meta-instrumentation type supports the instrumentation of different types of instrumentation, and each meta-instrumentation type can only be instrumented for a certain type of meta-instrumentation. 3. The traceless and manageable source code automatic insertion method according to claim 1, characterized in that in the step 41, matching the required insertion project includes matching the packages, files, and method. 4. The traceless and manageable source code automatic insertion method according to claim 3, characterized in that in step 42, the step of filtering source files comprises: Step 60: start: source file filtering is to filter all source files in a certain workspace; Step 61: First judge whether the workspace contains other projects, if not, go to step 64, if yes, go to step 62; Step 62: Match the project name, if it matches, go to step 63, if not, return to step 61 and continue to check whether there is a next project; Step 63: If the project name matches, it means that the project needs to be inserted, add it to the set of inserted projects, and then jump back to step 61; Step 64: Filter the package, first judge whether the project in the project collection contains other packages, if not, jump to step 67 to start filtering the file, if there is, go to step 65; Step 65: Match the package name, if it matches, then enter step 66, if it does not match, then return to step 64 and continue to check whether there is a next package; Step 66: Match the package name, if it matches, it means that the package needs to be instrumented, add it to the instrumentation package collection, and then jump back to step 64; Step 67: Determine whether the package in the package collection contains other source files, if not, jump to step 6b, and if yes, go to step 68; Step 68: Match the source file name, if it matches, go to step 69 to match the method, otherwise jump back to step 67; Step 69: Matching method, if it matches, go to step 6a, otherwise jump back to step 67; Step 6a: Add matching source files to the file matching collection; Step 6b: After matching all project names, package names, file names and method names in the project, the file filtering operation is completed. 5. The traceless and manageable source code automatic insertion method according to claim 4, characterized in that In the step 62, matching the project name is to match the project name with the project name regular expression; In the step 65, matching the package name is to match the package name with the package name regular expression; In the step 66, matching the package name is to match the package name with the package name regular expression; In the step 68, matching the source file name is to match the source file name with the source file name regular expression; In the step 69, the matching method is to match the method name of the method in the source file with the method name regular expression. 6. The traceless and manageable source code automatic instrumentation method according to claim 1, characterized in that in the step 44, the instrumentation location can be realized through syntax tree matching, and this part uses the visitor mode for matching, and the syntax tree The steps to match and insert codes include: Step 70: Start: The instrumentation of source files is performed file by file, and then instrumentation is performed according to different instrumentation types; instrumentation types include method, IF branch, Switch branch, While branch, Do-while branch and For branch type; Step 71: check whether there is a next source file, if not, then enter step 7h, end; if there is, then enter step 72; Step 72: First compile the source file into a syntax tree, and then visit each node in the Visitor mode. The operation steps of several types of stubs under the Visitor model are as follows: Step 73: first determine whether the syntax tree has a next node; Step 74: Determine whether the method type is included according to the selected stub type, if it is included and the node is a method body node, then go to step 75, otherwise go to step 76; Step 75: Insert the instrumentation code of the method type defined by the analyst into the corresponding node in the abstract syntax tree; Step 76: Determine whether the IF branch type is included according to the selected stub type, if it is included and the node is an IF branch node, then go to step 77, otherwise go to step 78; Step 77: Insert the IF branch type instrumentation code defined by the analyst in advance into the corresponding node in the abstract syntax tree; Step 78: Determine whether the Switch branch type is included according to the selected stub type, if it is included and the node is a Switch branch node, then enter step 79, otherwise jump to step 7a; Step 79: Insert the Switch branch type instrumentation code defined by the analyst in advance into the corresponding node in the abstract syntax tree; Step 7a: According to the selected stub type, judge whether the While branch type is included, if it is included and the node is a While branch node, then go to Step 7b, otherwise jump to Step 7a; Step 7b: Insert the While branch type instrumentation code defined by the analyst into the corresponding node in the abstract syntax tree; Step 7c: Determine whether the Do-While branch type is included according to the selected stub type, if it is included and the node is a Do-While branch node, then go to step 7d, otherwise jump to step 7a; Step 7d: Insert the Do-While branch type instrumentation code defined by the analyst into the corresponding node in the abstract syntax tree; Step 7e: Determine whether the For branch type is included according to the selected stub type, if it is included and the node is a For branch node, then go to step 7f, otherwise jump to step 7a; Step 7f: Insert the instrumentation code of the For branch type defined by the analyst in advance into the corresponding node in the abstract syntax tree; Step 7g: After completing the syntax tree instrumentation, convert the syntax tree into a source code file, and then proceed to step 73 to perform instrumentation for the next source file; Step 7h: The instrumentation of all files is completed, and the whole process ends.

Images