Source code byte alignment checking method, electronic equipment and storage medium

Abstract

The invention relates to a source code byte alignment checking method, electronic equipment and a storage medium, source codes are converted into an abstract syntax tree, a data structure is extracted according to the abstract syntax tree, and member variables and member variable information in the data structure are recorded; then loading a byte alignment rule of a target platform from a target source; member variables of the data structure are traversed, a first actual memory layout of the data structure is calculated according to member variable information and the offset, whether the first actual memory layout conforms to a byte alignment rule or not is checked, and alignment problem information is obtained; and generating an analysis report according to the alignment problem information. Static analysis is carried out by extracting source code information, and the byte alignment rule is dynamically loaded, so that the efficiency and accuracy of source code byte alignment check are improved, and the balance of flexibility and accuracy is realized.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a source code byte alignment checking method, electronic equipment and storage medium. Background Art

[0002] Byte alignment is a memory allocation mechanism in computer systems that ensures that member variables in data structures are stored in memory according to specific rules. The main purpose of byte alignment is to improve the efficiency of processor access to memory, reduce the number of cache misses, and optimize performance. However, developers usually analyze and check the byte alignment of data structures manually by reading source code. This method is inefficient and prone to errors. Summary of the invention

[0003] The present invention provides a source code byte alignment checking method, an electronic device and a storage medium, aiming to solve at least one of the technical problems existing in the prior art.

[0004] The technical solution of the present invention is a source code byte alignment checking method, comprising: Convert source code into an abstract syntax tree; Extracting a data structure according to the abstract syntax tree, and recording member variables and member variable information in the data structure; Load the target platform's byte alignment rules from the target source; Traversing the member variables of the data structure, and calculating a first actual memory layout of the data structure according to the member variable information and the offset; Check whether the first actual memory layout complies with the byte alignment rule, and obtain alignment problem information; An analysis report is generated according to the alignment problem information.

[0005] According to some embodiments of the present invention, the member variable information includes member variable type, member variable size and member variable order; Traversing the member variables of the data structure, and calculating a first actual memory layout of the data structure according to the member variable information and the offset, comprising: Initialize the offset to 0; Traversing each member variable of the data structure, calculating the required alignment padding according to the byte alignment rule, the member variable type, the member variable size, and the member variable sequence, and updating the offset to the end position of the current member variable; Based on the offset, it is determined whether the data structure complies with the byte alignment rule. If the data structure does not comply with the byte alignment rule, a tail pad is added at the end of the data structure to obtain the first actual memory layout.

[0006] According to some embodiments of the present invention, converting the source code into an abstract syntax tree includes: The source code is converted into the abstract syntax tree using a lexical analyzer and a syntax analyzer.

[0007] According to some embodiments of the present invention, the target source includes one or more combinations of a custom configuration file, a compiler default setting, and a predefined multi-platform rule base; The step of loading the byte alignment rule of the target platform from the target source includes: The byte alignment rules are loaded from one or more combinations of the custom configuration file, the compiler default settings, and the predefined multi-platform rule base.

[0008] According to some embodiments of the present invention, generating an analysis report according to the alignment problem information includes: Formulate a repair plan based on the alignment problem information; The data structure name, the member variable list, the offset, the alignment problem information and the repair solution are recorded to obtain the analysis report.

[0009] According to some embodiments of the present invention, the alignment problem information includes the location of the problem, the type of problem, and the content of the problem; Formulate a repair plan according to the alignment problem information; record the data structure name, the member variable list, the offset, the alignment problem information and the repair plan to obtain the analysis report, including: The repair plan is formulated according to the location of the problem, the type of problem and the content of the problem, and the data structure name, the member variable list, the offset, the location of the problem, the type of problem, the content of the problem and the repair plan are recorded to obtain the analysis report.

[0010] According to some embodiments of the present invention, after generating an analysis report according to the alignment problem information, the source code byte alignment checking method further includes: Based on the byte alignment rules of the plurality of target platforms, respectively calculating a second actual memory layout of the data structure; respectively checking whether the second actual memory layout complies with the byte alignment rules of the plurality of target platforms, and obtaining checking results of the plurality of target platforms; Compare the plurality of inspection results and generate a cross-platform compatibility report.

[0011] According to some embodiments of the present invention, after generating an analysis report according to the alignment problem information, the source code byte alignment checking method further includes: If the source code has been modified according to the analysis report, a source code byte alignment check is performed only on the modified portion of the source code.

[0012] The technical solution of the present invention also relates to an electronic device, which includes a memory and a processor. The memory stores a computer program, and the processor implements the source code byte alignment checking method as described above when executing the computer program.

[0013] The technical solution of the present invention also relates to a storage medium, wherein the storage medium stores a computer program, and when the computer program is executed by a processor, the source code byte alignment checking method as described above is implemented.

[0014] The beneficial effects of the present invention include: converting source code into an abstract syntax tree, extracting a data structure according to the abstract syntax tree, and recording member variables and member variable information in the data structure; then loading the byte alignment rule of the target platform from the target source; traversing the member variables of the data structure, calculating the first actual memory layout of the data structure according to the member variable information and the offset, checking whether the first actual memory layout complies with the byte alignment rule, and obtaining alignment problem information; generating an analysis report according to the alignment problem information. By extracting source code information for static analysis and combining with dynamically loading byte alignment rules, the efficiency and accuracy of source code byte alignment checking are improved, and a balance between flexibility and accuracy is achieved.

[0015] In addition, additional aspects and advantages of the present invention will be given in part in the following description, and in part will be obvious from the following description, or will be learned through practice of the present invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] Figure 1 It is an optional flow chart of a source code byte alignment checking method in an embodiment of the present invention.

[0017] Figure 2 It is an optional flow chart of the first actual memory layout of the calculation data structure in the embodiment of the present invention.

[0018] Figure 3 This is an optional flow chart for generating an analysis report based on alignment problem information in an embodiment of the present invention. DETAILED DESCRIPTION

[0019] The following will be combined with the embodiments and drawings to clearly and completely describe the concept, specific structure and technical effects of the present invention, so as to fully understand the purpose, scheme and effect of the present invention. It should be noted that the embodiments and features in the embodiments of this application can be combined with each other without conflict.

[0020] It should be noted that, unless otherwise specified, when a feature is referred to as being "fixed" or "connected" to another feature, it may be directly fixed or connected to the other feature, or it may be indirectly fixed or connected to the other feature. In addition, the descriptions of up, down, left, right, top, bottom, etc. used in the present invention are only relative to the relative positional relationship of the components of the present invention in the drawings.

[0021] In addition, unless otherwise defined, all technical and scientific terms used herein have the same meaning as those generally understood by those skilled in the art. The terms used in this specification are only for describing specific embodiments, not for limiting the present invention. The term "and / or" used herein includes any combination of one or more related listed items.

[0022] It should be understood that although the terms first, second, third, etc. may be used to describe various elements in the present invention, these elements should not be limited to these terms. These terms are only used to distinguish elements of the same type from each other. For example, without departing from the scope of the present invention, the first element may also be referred to as the second element, and similarly, the second element may also be referred to as the first element.

[0023] Reference Figures 1 to 3 In some embodiments, the technical solution of the present invention is a source code byte alignment checking method, including but not limited to steps 101 to 106. Each step is introduced in turn below.

[0024] Step 101: Convert the source code into an abstract syntax tree.

[0025] Specifically, the Abstract Syntax Tree (AST) is a tree data structure used in computer science to represent the structure of source code. It is a tree representation of the abstract syntax structure of the source code, and each node in each tree represents a structure in the source code.

[0026] In some embodiments, before converting the source code into an abstract syntax tree, the source code byte alignment checking method further includes loading a source code file.

[0027] In a specific embodiment, the LoadSourceCode function is used to load and read the source code file content.

[0028] In some embodiments, converting the source code into an abstract syntax tree includes: converting the source code into the abstract syntax tree using a lexical analyzer and a syntax analyzer.

[0029] Specifically, the lexical analyzer is used to convert a character sequence into a word sequence, and the syntax analyzer is used to analyze the grammatical structure of the source code from the word sequence generated by the lexical analyzer, and construct an abstract syntax tree that conforms to the grammatical rules of the programming language. It can be understood that the use of a lexical analyzer and a syntax analyzer can improve the efficiency of converting the source code into an abstract syntax tree.

[0030] In a specific embodiment, the source code is parsed into an abstract syntax tree using the ParseSourceCode function.

[0031] In a specific embodiment, the source code is converted into an abstract syntax tree using Clang's LibTooling or Python's AST module.

[0032] Step 102: extract the data structure according to the abstract syntax tree, and record the member variables and member variable information in the data structure.

[0033] Specifically, data structures include struct and union.

[0034] In a specific embodiment, the ExtractStructures function is used to extract the data structure from the abstract syntax tree, and the member variables and member variable information in the data structure are recorded.

[0035] Step 103: Load the byte alignment rules of the target platform from the target source.

[0036] In some embodiments, the target source includes one or more combinations of a custom configuration file, compiler default settings, and a predefined multi-platform rule library; loading the byte alignment rules of the target platform from the target source includes: loading the byte alignment rules from one or more combinations of a custom configuration file, compiler default settings, and a predefined multi-platform rule library.

[0037] It is understandable that compilers include GCC and Clang. Supports loading byte alignment rules from custom configuration files or predefined multi-platform rule libraries, which improves flexibility. Provides a flexible predefined multi-platform rule library, which can easily switch different byte alignment rules to adapt to various development environments.

[0038] In a specific embodiment, the byte alignment rules of the target platform are loaded from the target source using the LoadAlignmentRules function.

[0039] Step 104: traverse the member variables of the data structure, and calculate the first actual memory layout of the data structure according to the member variable information and the offset.

[0040] In some embodiments, the member variable information includes the member variable type, the member variable size, and the member variable order.

[0041] Reference Figure 2 As shown, the member variables of the data structure are traversed, and the first actual memory layout of the data structure is calculated according to the member variable information and the offset, including but not limited to the following steps 201 to 203.

[0042] Step 201: Initialize the offset to 0.

[0043] Step 202: traverse each member variable of the data structure, calculate the required alignment padding according to the byte alignment rule, member variable type, member variable size, and member variable order, and update the offset to the end position of the current member variable.

[0044] Step 203: judging whether the data structure complies with the byte alignment rule based on the offset; if the data structure does not comply with the byte alignment rule, adding tail padding at the end of the data structure to obtain a first actual memory layout.

[0045] Specifically, member variable types include char, int, double, etc. The unit of member variable size is byte.

[0046] In a specific embodiment, before traversing each member variable of the data structure, it also includes traversing each data structure.

[0047] In a specific embodiment, the CalculatePadding function is used to calculate the required alignment padding for each member variable of the data structure.

[0048] In a specific embodiment, whether the data structure complies with the byte alignment rule is determined based on the offset. If the data structure does not comply with the byte alignment rule, the problem is recorded and tail padding is added at the end of the data structure.

[0049] In a specific embodiment, the CalculateTailPadding function is used to calculate the number of bytes of tail padding.

[0050] Step 105: Check whether the first actual memory layout complies with the byte alignment rule, and obtain alignment problem information.

[0051] Specifically, by checking whether the first actual memory layout complies with the byte alignment rules, alignment problems such as incorrect alignment or unnecessary padding are found. In addition, by parsing the source code to generate an abstract syntax tree, and combining the byte alignment rules of the target platform, the first actual memory layout of the data structure is accurately calculated, which can cover a wider range of byte alignment problems, including simple padding bytes, complex alignment rules, and cross-platform compatibility issues.

[0052] In a specific embodiment, a rule configuration interface is used to load and obtain byte alignment rules from a target source. It is understandable that the rule configuration interface can be used to specify the load and obtain byte alignment rules according to actual needs, which enhances flexibility.

[0053] Step 106: Generate an analysis report based on the alignment problem information.

[0054] In a specific embodiment, before generating an analysis report according to the alignment problem information, the source code byte alignment checking method further includes: initializing the analysis report.

[0055] Reference Figure 3 In some embodiments, generating an analysis report based on the alignment problem information includes but is not limited to the following steps 301 to 302.

[0056] Step 301: Formulate a repair plan based on the alignment problem information.

[0057] Step 302: Record the data structure name, member variable list, offset, alignment problem information and repair plan to obtain an analysis report.

[0058] It is understandable that in addition to providing alignment problem information, the analysis report also provides corresponding repair solutions, which reduces the difficulty of repairing the source code, facilitates developers to quickly improve the source code, and improves efficiency. Specifically, the repair solution can be to insert appropriate alignment instructions.

[0059] Specifically, the source code byte alignment checking method adopts an open source development framework, which does not require the purchase of additional expensive commercial tools, thereby reducing costs.

[0060] In some embodiments, the alignment question information includes the location of the question, the question type, and the question content; Formulate a repair plan based on the alignment problem information; record the data structure name, member variable list, offset, alignment problem information and repair plan, and obtain an analysis report, including: A repair plan is formulated according to the location, type and content of the problem, and the data structure name, member variable list, offset, location, type, content and repair plan of the problem are recorded to obtain an analysis report.

[0061] It is understandable that the analysis report provides detailed alignment problem information, namely the location, type and content of the problem, which helps developers quickly understand the byte alignment problem of the source code and thus improve the source code and increase efficiency.

[0062] The application examples of the source code byte alignment checking method are as follows: The sample source code is as follows: struct Example { char a; int b; double c; }; Convert the source code into an abstract syntax tree, extract the data structure based on the abstract syntax tree, and record the member variables and member variable information in the data structure. The sample results are as follows: Data structure name: Example Member variable list: a: Type is char, size is 1 byte.

[0063] b: type is int, size is 4 bytes.

[0064] c: The type is double and the size is 8 bytes.

[0065] Example byte alignment rules are as follows: char: 1 byte alignment int: 4 byte alignment double: 8 byte alignment Example 1 actual memory layout calculation process: Initial offset: offset=0 Member variable a: The type is char and the size is 1 byte.

[0066] Required alignment is 1 byte, no padding required.

[0067] Update offset: offset=offset+1=1 Member variable b: The type is int and the size is 4 bytes.

[0068] Required alignment is 4 bytes, with 3 bytes of padding.

[0069] Update offset: offset=offset+padding+size=1+3+4=8 Member variable c: The type is double and the size is 8 bytes.

[0070] Required alignment is 8 bytes, no padding required.

[0071] Update offset: offset=offset+size=8+8=16 Tail padding: The total size of the data structure is 16 bytes, which satisfies the alignment rule.

[0072] Sample analysis report: Byte Alignment Report for struct Example: - Member 'a': Offset 0, Size 1 (Aligned) - Member 'b': Offset 4, Size 4 (Aligned after 3 bytes of padding) - Member 'c': Offset 8, Size 8 (Aligned) - Total size: 16 bytes Issues Found: - Padding added between 'a' and 'b': 3 bytes Suggestion: Consider reordering members to minimize padding. In some embodiments, after generating an analysis report according to the alignment problem information, the source code byte alignment checking method further includes: Based on the byte alignment rules of multiple target platforms, respectively calculate a second actual memory layout of the data structure; Checking respectively whether the second actual memory layout complies with the byte alignment rules of multiple target platforms, and obtaining the inspection results of the multiple target platforms; Compare multiple check results and generate a cross-platform compatibility report.

[0073] It is understandable that providing a cross-platform byte alignment rule comparison function can help developers identify differences between different platforms. And supporting multi-platform comparison improves flexibility.

[0074] The following is an example of multi-platform comparison: Check the byte alignment of the following C code on x86 and ARM platforms: struct Data { short a; int b; char c; }; Example byte alignment rules are as follows: x86 Platforms: short: 2 byte alignment int: 4 byte alignment char: 1 byte alignment ARM platform: short: 2 byte alignment int: 4 byte alignment char: 1 byte alignment Example 2 actual memory layout calculation results: x86 Platform: Member variable a: offset 0, no padding required.

[0075] Member variable b: offset 2, 2 bytes of padding.

[0076] Member variable c: offset 8, no padding required.

[0077] Total size: 12 bytes.

[0078] ARM platform: Member variable a: offset 0, no padding required.

[0079] Member variable b: offset 2, 2 bytes of padding.

[0080] Member variable c: offset 8, no padding required.

[0081] Total size: 12 bytes.

[0082] Example cross-platform compatibility report: Cross-Platform Byte Alignment Report for struct Data: - Platform x86: - Member 'a': Offset 0, Size 2 (Aligned) - Member 'b': Offset 4, Size 4 (Aligned after 2 bytes of padding) - Member 'c': Offset 8, Size 1 (Aligned) - Total size: 12 bytes - Platform ARM: - Member 'a': Offset 0, Size 2 (Aligned) - Member 'b': Offset 4, Size 4 (Aligned after 2 bytes of padding) - Member 'c': Offset 8, Size 1 (Aligned) - Total size: 12 bytes No cross-platform alignment issues detected. In some embodiments, after generating an analysis report according to the alignment problem information, the source code byte alignment checking method further includes: if the source code has been modified according to the analysis report, performing a source code byte alignment check only on the modified portion of the source code.

[0083] In a specific embodiment, during the source code byte alignment check, a cache is used to save intermediate results to further improve performance.

[0084] It can be understood that the repeated inspection process is accelerated through incremental analysis and caching mechanisms, which reduces the inspection time and resource consumption and improves development efficiency.

[0085] It can be seen that the source code is converted into an abstract syntax tree, the data structure is extracted according to the abstract syntax tree, and the member variables and member variable information in the data structure are recorded. The byte alignment rules of the target platform are loaded from the target source. The member variables of the data structure are traversed, and the first actual memory layout of the data structure is calculated according to the member variable information and the offset. It is checked whether the first actual memory layout complies with the byte alignment rules to obtain the alignment problem information. An analysis report is generated according to the alignment problem information. By extracting source code information for static analysis and combining it with the dynamic loading of byte alignment rules, the efficiency and accuracy of the source code byte alignment check are improved, and a balance between flexibility and accuracy is achieved.

[0086] In a specific embodiment, the OutputReport function is used to output the analysis report or the cross-platform compatibility report to the developer.

[0087] The embodiment of the present invention further provides an electronic device, the electronic device includes a memory and a processor, the memory stores a computer program, and the processor implements the above-mentioned source code byte alignment check method when executing the computer program. The electronic device can be any intelligent terminal including a computer.

[0088] An embodiment of the present invention further provides a storage medium storing a computer program, and when the computer program is executed by a processor, the above-mentioned source code byte alignment checking method is implemented.

[0089] It should be appreciated that the method steps in the embodiments of the present invention can be implemented or implemented by computer hardware, a combination of hardware and software, or by computer instructions stored in a non-transitory computer readable memory. The method can use standard programming techniques. Each program can be implemented in a high-level process or object-oriented programming language to communicate with a computer system. However, if necessary, the program can be implemented in an assembly or machine language. In any case, the language can be a compiled or interpreted language. In addition, the program can be run on a programmed ASIC for this purpose.

[0090] In addition, the operations of the processes described herein may be performed in any suitable order unless otherwise indicated herein or otherwise clearly contradicted by context. The processes described herein (or variations and / or combinations thereof) may be performed under the control of one or more computer systems configured with executable instructions, and may be implemented as code (e.g., executable instructions, one or more computer programs, or one or more applications) that is executed collectively on one or more processors, by hardware, or a combination thereof. The computer program includes a plurality of instructions that may be executed by one or more processors.

[0091] Further, the method can be implemented in any type of computing platform that is operably connected to a suitable computer, including but not limited to a personal computer, a minicomputer, a mainframe, a workstation, a network or distributed computing environment, a separate or integrated computer platform, or in communication with a charged particle tool or other imaging device, etc. Various aspects of the present invention can be implemented in machine-readable code stored on a non-transitory storage medium or device, whether removable or integrated into a computing platform, such as a hard disk, an optical read and / or write storage medium, a RAM, a ROM, etc., so that it can be read by a programmable computer, and when the storage medium or device is read by the computer, it can be used to configure and operate the computer to perform the process described herein. In addition, the machine-readable code, or portions thereof, can be transmitted via a wired or wireless network. When such media includes instructions or programs that implement the steps described above in conjunction with a microprocessor or other data processor, the invention described herein includes these and other different types of non-transitory computer-readable storage media. When programmed according to the methods and techniques of the present invention, the present invention can also include the computer itself.

[0092] The computer program can be applied to input data to perform the functions described herein, thereby converting the input data to generate output data stored in a non-volatile memory. The output information can also be applied to one or more output devices such as a display. In a preferred embodiment of the present invention, the converted data represents physical and tangible objects, including specific visual depictions of physical and tangible objects produced on the display.

[0093] The above is only a preferred embodiment of the present invention. The present invention is not limited to the above implementation. As long as the technical effect of the present invention is achieved by the same means, any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention shall be included in the scope of protection of the present invention. Within the scope of protection of the present invention, its technical scheme and / or implementation method may have various modifications and changes.

Claims

1. A source code byte alignment checking method, characterized in that: include: Convert source code into an abstract syntax tree; Extracting a data structure according to the abstract syntax tree, and recording member variables and member variable information in the data structure; Load the target platform's byte alignment rules from the target source; Traversing the member variables of the data structure, and calculating a first actual memory layout of the data structure according to the member variable information and the offset; Check whether the first actual memory layout complies with the byte alignment rule, and obtain alignment problem information; An analysis report is generated according to the alignment problem information.

2. A source code byte alignment checking method according to claim 1, characterized in that: The member variable information includes member variable type, member variable size and member variable order; Traversing the member variables of the data structure, and calculating a first actual memory layout of the data structure according to the member variable information and the offset, comprising: Initialize the offset to 0; Traversing each member variable of the data structure, calculating the required alignment padding according to the byte alignment rule, the member variable type, the member variable size, and the member variable sequence, and updating the offset to the end position of the current member variable; Based on the offset, it is determined whether the data structure complies with the byte alignment rule. If the data structure does not comply with the byte alignment rule, a tail pad is added at the end of the data structure to obtain the first actual memory layout.

3. A source code byte alignment checking method according to claim 1, characterized in that: The step of converting the source code into an abstract syntax tree includes: The source code is converted into the abstract syntax tree using a lexical analyzer and a syntax analyzer.

4. A source code byte alignment checking method according to claim 1, characterized in that: The target source includes one or more combinations of a custom configuration file, a compiler default setting, and a predefined multi-platform rule library; The step of loading the byte alignment rule of the target platform from the target source includes: The byte alignment rules are loaded from one or more combinations of the custom configuration file, the compiler default settings, and the predefined multi-platform rule base.

5. A source code byte alignment checking method according to claim 1, characterized in that: Generate an analysis report based on the alignment problem information, including: Formulate a repair plan based on the alignment problem information; The data structure name, the member variable list, the offset, the alignment problem information and the repair solution are recorded to obtain the analysis report.

6. A source code byte alignment checking method according to claim 5, characterized in that: The alignment question information includes the location of the question, the question type and the question content; Formulate a repair plan based on the alignment problem information; Record the data structure name, the member variable list, the offset, the alignment problem information and the repair solution to obtain the analysis report, including: The repair plan is formulated according to the location of the problem, the type of problem and the content of the problem, and the data structure name, the member variable list, the offset, the location of the problem, the type of problem, the content of the problem and the repair plan are recorded to obtain the analysis report.

7. A source code byte alignment checking method according to claim 1, characterized in that: After generating an analysis report according to the alignment problem information, the source code byte alignment checking method further includes: Based on the byte alignment rules of the plurality of target platforms, respectively calculating a second actual memory layout of the data structure; respectively checking whether the second actual memory layout complies with the byte alignment rules of the plurality of target platforms, and obtaining checking results of the plurality of target platforms; Compare the plurality of inspection results and generate a cross-platform compatibility report.

8. A source code byte alignment checking method according to claim 1, characterized in that: After generating an analysis report according to the alignment problem information, the source code byte alignment checking method further includes: If the source code has been modified according to the analysis report, a source code byte alignment check is performed only on the modified portion of the source code.

9. An electronic device, characterized in that: The electronic device includes a memory and a processor, the memory stores a computer program, and the processor implements a source code byte alignment checking method as described in any one of claims 1 to 8 when executing the computer program.

10. A storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, a source code byte alignment checking method according to any one of claims 1 to 8 is implemented.

Images