Inline assembly code analysis method and system based on large language model assistance

Abstract

The invention provides an inline assembly code analysis method and system based on large language model assistance. The inline assembly code analysis method comprises the steps that the position of an inline assembly code potentially influencing the static program analysis effect is positioned and measured in a C source code item; target code abstract point selection: constructing a calling graph based on the identified inline assembly code and selecting a position suitable for code abstract in the graph; automatic code abstract generation assisted by the large language model: guiding the large language model to analyze an inline assembly function through a cue word project and generating a code abstract in a specific format; verifying the correctness of the code abstract, namely checking the correctness of the generated code abstract through methods such as large language model self-verification; and deploying and applying the code abstract, namely deploying and applying the verified code abstract in the program analysis framework to be optimized. The method is used for overcoming the defect that an existing source code level static program analysis framework has difficulty in cross-language analysis between a source code and an inline assembly code.

Description

Technical Field

[0001] The present invention relates to the technical field of computer program analysis, and in particular to an inline assembly code analysis method and system based on a large language model. Background Art

[0002] At present, with the widespread application of complex software systems such as operating systems, databases, and browsers in various fields, the research on their security features and potential risks is particularly important. As one of the research methods, static program analysis technology provides strong support for code analysis tasks with its ability to automatically obtain target program behavior information without actually running the program. This technology mainly uses source code as input and reveals potential problems and optimization space of the program by analyzing the structure, syntax, and semantics of the code.

[0003] However, although static program analysis technology has made significant contributions to improving software security and robustness, it still faces many limitations and challenges. On the one hand, static analysis often fails to take into account completeness while pursuing reliability, which may lead to false positives in the analysis results and increase the complexity and cost of subsequent processing. On the other hand, for complex software systems, static analysis needs to process a large amount of input code, which consumes huge computing resources and time. Therefore, the existing program analysis framework sacrifices analysis accuracy to a certain extent in order to improve scalability and efficiency, but this will also have a negative impact on the analysis results.

[0004] In particular, static analysis techniques face even greater challenges when they encounter difficult-to-handle programming language features such as C inline assembly. C inline assembly allows developers to embed assembly language directly in C source code to optimize program performance or access underlying hardware. However, the instructions in the inline assembly block are not changed during the compilation process and are directly embedded in the corresponding position of the target binary program, which destroys the cross-platform nature of the C language and requires developers to be familiar with assembly syntax. More importantly, there are huge differences in syntax and semantics between inline assembly and C code, which is a cross-language analysis problem. Conventional static analysis tools have difficulty in effectively processing these code segments. At the same time, assembly code is usually architecture-specific and lacks portability, and the diverse instruction sets further increase the complexity of analysis.

[0005] In complex software systems such as the Linux kernel that need to interact with the underlying hardware and have high operating efficiency, inline assembly is widely used. However, most static program analysis frameworks targeting the Linux kernel either ignore the processing of inline assembly or only use manual intervention to perform limited processing, which greatly damages the reliability of the analysis. Therefore, how to effectively process inline assembly code has become the key to improving the accuracy and reliability of static program analysis technology.

[0006] A patent document with publication number CN111240982A discloses a source code static analysis method, including: performing lexical analysis and syntax analysis on the source code to generate an abstract syntax tree; performing semantic analysis on the abstract syntax tree to obtain a directed control flow graph and a data flow graph; traversing the directed control flow graph to obtain slice data; and searching and outputting variables that may have defects in the source code based on the data flow graph and the slice data.

[0007] With the rapid development of Large Language Model (LLM), it has gradually shown great potential in software engineering and computer security research. LLM has learned a large number of source code, description documents and use cases of open source projects in the pre-training stage, so it has rich knowledge in software and system fields and can better assist researchers in completing specific tasks. Large language models provide new opportunities to solve classic problems in static program analysis. By combining the analysis capabilities of large language models, it is expected to realize the automated processing of inline assembly code, thereby further improving the accuracy and reliability of static program analysis. Summary of the invention

[0008] In view of the defects in the prior art, the object of the present invention is to provide an inline assembly code analysis method and system based on a large language model.

[0009] According to the present invention, a large language model-assisted inline assembly code analysis method is provided, the method comprising the following steps:

[0010] Step 1: Locate the inline assembly code in the C source code project and record the mapping relationship between the source code and the inline assembly code compiled into the intermediate language;

[0011] Step 2: construct an assembly call graph based on the inline assembly code, and select a location in the graph where code summarization can be performed;

[0012] Step 3: Use the prompt word engineering to guide the large language model to analyze the function of the inline assembly and generate a code summary in a preset format;

[0013] Step 4: Verify the correctness of the generated code summary through large language model self-verification, compile-time checking, and manual assisted checking;

[0014] Step 5: Deploy and apply the validated code summaries in the program analysis framework to be optimized.

[0015] Preferably, step 1 includes: preprocessing and code optimizing macro functions and inline functions in the source code to locate the inline assembly code, and recording the mapping relationship between the source code and the intermediate language caused by the expansion of the macro function and the expansion of the inline function.

[0016] Preferably, in step 2, the assembly call graph constructed is a variant of the function call graph, including parent nodes, child nodes and edges representing function call relationships or macro expansion relationships, wherein the leaf nodes correspond to the definition and implementation of the inline assembly code.

[0017] Preferably, in step 3, the prompt word engineering includes defining the format and requirements of the code summary, as well as the detailed scope of the assembly code behavior that needs to be described, and the designed prompt word engineering drives the large language model to generate a summary that can describe the target assembly code data flow and pointer-related behavior.

[0018] Preferably, in step 4, the large language model self-verification guides the large language model to re-examine the previously given answer through additional prompt words, and correct it if it is wrong;

[0019] Compile-time checking adjusts the generated code summary according to the error information output during the compilation of the project to be tested;

[0020] Manual assisted inspection directly compares the content of the original function with the generated summary and makes adjustments.

[0021] Preferably, the program analysis framework to be optimized in step 5 includes an SVF program analysis framework and a KLEE program analysis framework.

[0022] The present invention also provides an inline assembly code analysis system based on a large language model, the system comprising the following modules:

[0023] Module 1: Locate inline assembly code in a C source code project and record the mapping between the source code and the inline assembly code compiled into the intermediate language;

[0024] Module 2: constructing an assembly call graph based on the inline assembly code, and selecting a location in the graph where code summarization can be performed;

[0025] Module 3: Use prompt word engineering to guide the large language model to analyze the functions of inline assembly and generate a code summary in a preset format;

[0026] Module 4: Verify the correctness of the generated code summary through large language model self-verification, compile-time checking, and manual assisted checking;

[0027] Module 5: Deploy and apply validated code summaries in the program analysis framework to be optimized.

[0028] Preferably, the module 1 comprises: preprocessing and code optimization of macro functions and inline functions in the source code to locate the inline assembly code, and recording the mapping relationship between the source code and the intermediate language caused by the expansion of the macro function and the inline function.

[0029] Preferably, in the module 2, the assembly call graph constructed is a variant of the function call graph, including a parent node, a child node and edges representing a function call relationship or a macro expansion relationship, wherein the leaf node corresponds to the definition and implementation of the inline assembly code.

[0030] Preferably, in the module 3, the prompt word engineering includes defining the format and requirements of the code summary, and the detailed scope of the assembly code behavior to be described, and the designed prompt word engineering drives the large language model to generate a summary that can describe the target assembly code data flow and pointer-related behavior;

[0031] In the module 4, the large language model self-verification guides the large language model to review the previously given answer through additional prompt words, and correct it if it is wrong;

[0032] Compile-time checking adjusts the generated code summary according to the error information output during the compilation of the project to be tested;

[0033] Manual assisted inspection directly compares the content of the original function with the generated summary and makes adjustments;

[0034] The program analysis framework to be optimized in the module 5 includes the SVF program analysis framework and the KLEE program analysis framework.

[0035] Compared with the prior art, the present invention has the following beneficial effects:

[0036] 1. The present invention can analyze C language inline assembly code more accurately by introducing an inline assembly code analysis method assisted by a large language model, solving the problem of difficulty in cross-language analysis between source code and inline assembly code in a static program analysis framework; the large language model has a powerful code understanding and generation capability, and can deeply understand the semantics and behavior of assembly code, thereby generating a more accurate code summary and improving the accuracy of analysis;

[0037] 2. When processing inline assembly code, traditional methods often require manual instruction set modeling, which is not only time-consuming and labor-intensive, but also prone to errors. The present invention makes full use of the domain knowledge of instruction sets of various architectures mastered by the large language model during the pre-training process, and can support inline assembly code analysis of multiple architectures, greatly reducing the time overhead of manual instruction set modeling.

[0038] 3. The automated analysis process provided by the present invention includes inline assembly code location, summary point selection, automatic summary generation, summary verification and deployment application, which realizes the pipeline operation of inline assembly code analysis; improves the efficiency of program analysis, and ensures the correctness and comprehensiveness of the generated code summary through multiple verification mechanisms, thereby improving the reliability of program analysis.

[0039] 4. The present invention is not only applicable to common program analysis frameworks such as SVF and KLEE, but also has good scalability for other general program analysis frameworks; it can be widely used in various static program analysis scenarios, providing strong support for improving software security and robustness. BRIEF DESCRIPTION OF THE DRAWINGS

[0040] Other features, objects and advantages of the present invention will become more apparent from the detailed description of non-limiting embodiments made with reference to the following drawings:

[0041] Figure 1 An overall block diagram of the automated analysis process of inline assembly code assisted by a large language model provided by a preferred embodiment of the present invention;

[0042] Figure 2 A detailed operating principle diagram of step 3 and step 4 is provided for a preferred embodiment of the present invention. DETAILED DESCRIPTION

[0043] The present invention is described in detail below in conjunction with specific embodiments. The following embodiments will help those skilled in the art to further understand the present invention, but are not intended to limit the present invention in any form. It should be noted that, for those of ordinary skill in the art, several changes and improvements can also be made without departing from the concept of the present invention. These all belong to the protection scope of the present invention.

[0044] Embodiment 1:

[0045] Reference Figure 1 and Figure 2 According to the present invention, a large language model-assisted inline assembly code analysis method is provided, the method comprising the following steps:

[0046] Step 1: Locate the inline assembly code in the C source code project and record the mapping relationship between the source code and the inline assembly code compiled into the intermediate language; preprocess and optimize the macro functions and inline functions in the source code to locate the inline assembly code, and record the mapping relationship between the source code and the intermediate language caused by the expansion of the macro function and the expansion of the inline function.

[0047] Step 2: construct an assembly call graph based on the inline assembly code, and select a location in the graph where code summarization can be performed; the constructed assembly call graph is a variant of a function call graph, including a parent node, a child node, and edges representing a function call relationship or a macro expansion relationship, wherein a leaf node corresponds to the definition and implementation of the inline assembly code.

[0048] Step 3: Guide the large language model to analyze the functions of inline assembly and generate a code summary in a preset format through the prompt word engineering; the prompt word engineering includes defining the format and requirements of the code summary, as well as the detailed scope of the assembly code behavior that needs to be described. The designed prompt word engineering drives the large language model to generate a summary that can describe the target assembly code data flow and pointer-related behavior. First, based on the code summary information obtained in the previous step, collect the relevant source code content, including detailed information such as inline assembly statements and their corresponding function declarations, macro definitions, function call chains, macro expansion chains, and code comments. Secondly, use this source code information to instantiate the prompt word template, which includes the analysis task description and code summary format, to request the large language model to analyze the code and give preliminary analysis results. Subsequently, guide the large language model to further explore whether there are program side effects that have not been considered before based on the preliminary analysis results, and supplement and improve the preliminary analysis results based on these side effects. Finally, extract the generated code summary in the specified format from the final response provided by the large language model.

[0049] Step 4: Verify the correctness of the generated code summary through large language model self-verification, compile-time checking, and manual assisted checking; large language model self-verification uses additional prompts to guide the large language model to re-examine the previously given answers and correct them if they are wrong; compile-time checking adjusts the generated code summary based on the error information output during the compilation process of the project to be tested; manual assisted checking directly compares the content of the original function with the generated summary and makes adjustments.

[0050] Step 5: Deploy and apply the verified code summary in the program analysis framework to be optimized; the program analysis framework to be optimized includes the SVF program analysis framework and the KLEE program analysis framework.

[0051] The present invention also provides an inline assembly code analysis system assisted by a large language model. The inline assembly code analysis system assisted by a large language model can be implemented by executing the process steps of the inline assembly code analysis method assisted by a large language model, that is, those skilled in the art can understand the inline assembly code analysis method assisted by a large language model as a preferred implementation of the inline assembly code analysis system assisted by a large language model.

[0052] Embodiment 2:

[0053] The present invention also provides an inline assembly code analysis system based on a large language model, the system comprising the following modules:

[0054] Module 1: Locate inline assembly code in C source code projects and record the mapping relationship between the source code and the inline assembly code compiled into the intermediate language; preprocess and optimize the macro functions and inline functions in the source code to locate the inline assembly code and record the mapping relationship between the source code and the intermediate language caused by the expansion of macro functions and inline functions.

[0055] Module 2: construct an assembly call graph based on the inline assembly code, and select a location in the graph where code summarization can be performed; the constructed assembly call graph is a variant of a function call graph, including a parent node, a child node, and edges representing a function call relationship or a macro expansion relationship, wherein a leaf node corresponds to a definition and implementation of the inline assembly code.

[0056] Module 3: Guide the large language model to analyze the functions of inline assembly and generate a code summary in a preset format through prompt word engineering; prompt word engineering includes defining the format and requirements of the code summary, as well as the detailed scope of the assembly code behavior that needs to be described. The designed prompt word engineering drives the large language model to generate a summary that can describe the target assembly code data flow and pointer-related behavior.

[0057] Module 4: Verify the correctness of the generated code summary through large language model self-verification, compile-time checking and manual assisted checking; large language model self-verification uses additional prompts to guide the large language model to re-examine the previously given answers and correct them if they are wrong; compile-time checking adjusts the generated code summary based on the error information output during the compilation process of the project to be tested; manual assisted checking directly compares the content of the original function with the generated summary and makes adjustments.

[0058] Module 5: Deploy and apply verified code summaries in the program analysis framework to be optimized; the program analysis framework to be optimized includes the SVF program analysis framework and the KLEE program analysis framework.

[0059] Embodiment 3:

[0060] The platform implemented in this embodiment has an operating system of Ubuntu 22.04 and uses the LLVM-14 compilation environment. The large language model uses the mainstream general pre-trained model on the market to meet the requirements of the present invention. The target program analysis framework to be optimized is version 2.8 of SVF (Static Value-Flow Analysis Framework).

[0061] Figure 1It is an overall block diagram of the automatic analysis process of inline assembly code assisted by a large language model provided by a preferred embodiment of the present invention.

[0062] like Figure 1 As shown, the automatic analysis process of inline assembly code based on the assistance of a large language model in this embodiment includes the following steps:

[0063] Step 1: Locate C language inline assembly. Since inline assembly is often used in macro functions and inline functions of C source code, the relevant code will be expanded to multiple usage locations during the compiler's preprocessing and code optimization process. Most static analysis frameworks perform analysis at the intermediate language level, so it is necessary to establish a mapping relationship between the inline assembly statements in the C language source code and the compiled intermediate language code, so as to provide sufficient support for the analysis of subsequent processes.

[0064] Step 2, target code summary point selection. First, the assembly call graph (AsmCallGraph) is constructed from bottom to top through inline assembly. It is a variant of the function call graph, where the parent node represents the caller, the child node represents the callee, the edge in the graph represents the function call relationship or macro expansion relationship, and all leaf nodes correspond to the definition and implementation of the inline assembly code.

[0065] On this basis, since the analysis results are different when performing code summarization at the direct call location of the inline assembly and at a higher level call location, this step tends to generate summaries for tool functions that have relatively simple functions and can be reused by other different codes, because these functions have clear semantic behaviors. On the assembly call graph, heuristic rules are used in combination with the auxiliary judgment of the large language model to select tool functions that are as high as possible and still have clear functional semantics as the target code summary point, and this is passed as input to the next step.

[0066] Step 3: Automated code summary generation assisted by a large language model. For the code summary points selected by the heuristic rules, a set of automated processes assisted by a large language model is designed based on the prompt word engineering. It can analyze the assembly code behavior according to the given source code content, and finally generate a code summary that meets the static analysis requirements. By introducing few-shot examples and chain of thought, the large language model can be guided to conduct a deeper analysis of code snippets containing inline assembly, while generating more accurate and comprehensive code summary content.

[0067] Regarding the generated summary format, it can also be regarded as a function shim. This code summary method appropriately cuts and simplifies the target function and generates a function that is also written in C source code, but the simplified function omits many code implementations including inline assembly and only contains code behaviors that program analysis focuses on, such as function parameters, return values, and the reading and writing of global variables. This can simplify function logic or provide an equivalent implementation that is easy to analyze, thereby improving the accuracy and efficiency of program analysis.

[0068] Step 4: Verify the correctness of the code summary. Since large language models generally have hallucination problems when generating answers, it is necessary to verify the correctness of the code summary they automatically generate to improve the reliability of program analysis. First, by adding an additional self-verification process to the prompt word project, the large model is guided to check its previous answers. If there are problems, corresponding measures need to be taken to make adjustments. Secondly, since the code summary needs to be compiled before application, the code summary can be checked through the compiler's error output. Finally, if the analysis scenario has high reliability requirements, a sub-step of manual verification can be introduced to further screen out improperly implemented code summaries.

[0069] Step 5, deployment and application of code summaries. The target program analysis framework for this embodiment is SVF. When deploying the code summary generated by the present invention, it is only necessary to insert the generated code summary in the form of a function shim into the C source file responsible for external API processing in the SVF-2.8 framework, and recompile the SVF framework and related tools. The application of the program analysis framework enhanced by the present invention can achieve a more accurate and reliable static analysis effect. It should be noted that although the SVF framework is used in the description process of this embodiment, the method proposed by the present invention supports most common program analysis frameworks and has good scalability.

[0070] Further, Figure 2 It is a detailed operating principle diagram of step 3 and step 4 provided in a preferred embodiment of the present invention.

[0071] like Figure 2 As shown, the automatic code summary generation assisted by the large language model in step 3 and the correctness verification of the code summary in step 4 both require the analysis capabilities of the large language model.

[0072] In the process of code summary generation, by writing the code summary format definition and the detailed scope of the code behavior of interest in the current analysis scenario in the prompt word template, the large language model can be guided to analyze the input containing inline assembly code and generate an equivalent and easy-to-analyze code summary. In the process of correctness verification, by combining the three methods, it can be determined whether the generated code summary meets the requirements and has application value. Among them, the self-verification of the large language model can be implemented as a multi-round result comprehensive voting mode, that is, driving the large language model to perform independent, multi-round evaluations on the current code summary, and combining multiple results to determine whether the current object is correct.

[0073] Those skilled in the art may understand this embodiment as a more specific description of Embodiment 1 and Embodiment 2.

[0074] Those skilled in the art know that, in addition to realizing the system and its various devices, modules, and units provided by the present invention in a purely computer-readable program code, it is entirely possible to realize the same functions in the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers by logically programming the method steps. Therefore, the system and its various devices, modules, and units provided by the present invention can be considered as a hardware component, and the devices, modules, and units included therein for realizing various functions can also be regarded as structures within the hardware component; the devices, modules, and units for realizing various functions can also be regarded as both software modules for realizing the method and structures within the hardware component.

[0075] The above describes the specific embodiments of the present invention. It should be understood that the present invention is not limited to the above specific embodiments, and those skilled in the art can make various changes or modifications within the scope of the claims, which does not affect the essence of the present invention. In the absence of conflict, the embodiments of the present application and the features in the embodiments can be combined with each other arbitrarily.

Claims

1. A method for analyzing inline assembly code based on a large language model, characterized in that: The method comprises the following steps: Step 1: Locate the inline assembly code in the C source code project and record the mapping relationship between the source code and the inline assembly code compiled into the intermediate language; Step 2: construct an assembly call graph based on the inline assembly code, and select a position in the graph where code summarization can be performed; Step 3: Use the prompt word engineering to guide the large language model to analyze the function of the inline assembly and generate a code summary in a preset format; Step 4: Verify the correctness of the generated code summary through large language model self-verification, compile-time checking, and manual assisted checking; Step 5: Deploy and apply the validated code summaries in the program analysis framework to be optimized.

2. The inline assembly code analysis method based on the assistance of a large language model according to claim 1, characterized in that: The step 1 includes: preprocessing and optimizing the macro functions and inline functions in the source code to locate the inline assembly code, and recording the mapping relationship between the source code and the intermediate language caused by the expansion of the macro function and the expansion of the inline function.

3. The inline assembly code analysis method based on the assistance of a large language model according to claim 1, characterized in that: In step 2, the constructed assembly call graph is a variant of the function call graph, including a parent node, a child node, and edges representing function call relationships or macro expansion relationships, wherein the leaf nodes correspond to the definition and implementation of the inline assembly code.

4. The inline assembly code analysis method based on the assistance of a large language model according to claim 1, characterized in that: In step 3, the prompt word engineering includes defining the format and requirements of the code summary and the detailed scope of the assembly code behavior that needs to be described. The designed prompt word engineering drives the large language model to generate a summary that can describe the target assembly code data flow and pointer-related behavior.

5. The inline assembly code analysis method based on large language model assistance according to claim 1, characterized in that: In step 4, the large language model self-verification guides the large language model to review the previously given answer through additional prompt words, and corrects it if it is wrong; Compile-time checking adjusts the generated code summary according to the error information output during the compilation of the project to be tested; Manual assisted inspection directly compares the content of the original function with the generated summary and makes adjustments.

6. The inline assembly code analysis method based on large language model assistance according to claim 1, characterized in that: The program analysis framework to be optimized in step 5 includes the SVF program analysis framework and the KLEE program analysis framework.

7. An inline assembly code analysis system based on a large language model, characterized in that: The system includes the following modules: Module 1: Locate inline assembly code in a C source code project and record the mapping between the source code and the inline assembly code compiled into the intermediate language; Module 2: constructing an assembly call graph based on the inline assembly code, and selecting a location in the graph where code summarization can be performed; Module 3: Use prompt word engineering to guide the large language model to analyze the functions of inline assembly and generate a code summary in a preset format; Module 4: Verify the correctness of the generated code summary through large language model self-verification, compile-time checking, and manual assisted checking; Module 5: Deploy and apply validated code summaries in the program analysis framework to be optimized.

8. The inline assembly code analysis system based on large language model assistance according to claim 7, characterized in that: The module 1 comprises: preprocessing and code optimization of macro functions and inline functions in source code to locate inline assembly code, and recording the mapping relationship between source code and intermediate language caused by macro function expansion and inline function expansion.

9. The inline assembly code analysis system based on large language model assistance according to claim 7, characterized in that: In the module 2, the constructed assembly call graph is a variant of the function call graph, including a parent node, a child node and edges representing a function call relationship or a macro expansion relationship, wherein the leaf nodes correspond to the definition and implementation of the inline assembly code.

10. The inline assembly code analysis system based on large language model assistance according to claim 7, characterized in that: In the module 3, the prompt word engineering includes defining the format and requirements of the code summary and the detailed scope of the assembly code behavior to be described, and driving the large language model to generate a summary that can describe the target assembly code data flow and pointer-related behavior through the designed prompt word engineering; In the module 4, the large language model self-verification guides the large language model to review the previously given answer through additional prompt words, and correct it if it is wrong; Compile-time checking adjusts the generated code summary according to the error information output during the compilation of the project to be tested; Manual assisted inspection directly compares the content of the original function with the generated summary and makes adjustments; The program analysis framework to be optimized in the module 5 includes the SVF program analysis framework and the KLEE program analysis framework.

Images