CN118672588A - Intelligent contract compiling method, system, electronic equipment and object code running method - Google Patents

Abstract

The embodiment of the disclosure provides an intelligent contract compiling method, which comprises the following steps: the compiling front end converts the target intelligent contract into a corresponding first intermediate code; compiling running environment initialization configuration information of a front-end generated target intelligent contract and converting the running environment initialization configuration information into a corresponding second intermediate code, wherein the running environment initialization configuration information records first configuration information, and the first configuration information is used for indicating that a virtual register area, a stack area and a stack area are divided in a memory space when the memory space is initialized; the compiling front end generates virtual register configuration information and converts the virtual register configuration information into corresponding register configuration intermediate codes, and storage grooves at two preset fixed positions in a virtual register area are respectively used as a stack frame register and a stack pointer register in the virtual register configuration information; the compiling front end sends the intermediate code set to the compiling back end; the compiling back-end converts the intermediate code in the intermediate code set into corresponding object code.

Description

Smart contract compilation method, system, electronic device and target code operation method

Technical Field

The present disclosure relates to the field of computer technology, and in particular to a smart contract compilation method, system, electronic device, and target code running method.

Background Art

With the rapid development of blockchain technology, blockchain-based smart contract applications have become a trend. In order to improve the efficiency of smart contract execution and support cross-platform execution, the relevant technology proposes a solution to integrate a stack-based virtual machine into the target platform and use the stack-based virtual machine to execute smart contracts; among them, since the virtual machine has no physical registers, the compiler is required to compile the smart contract into an instruction sequence that does not rely on registers and can be understood and executed by the stack-based virtual machine (for example, instructions for PUSH and POP operations on the stack). When the virtual machine executes these instructions one by one, it will operate the stack according to the definition in the instruction set, thereby completing the function of the smart contract. However, in actual applications, it is found that the execution performance of smart contracts under this processing method is low, and it cannot meet the requirements of supporting the compilation of contract codes with complex logic.

Summary of the invention

In a first aspect, an embodiment of the present disclosure provides a smart contract compilation method, the compilation method is based on a compilation system, the compilation system includes a compilation front end and a compilation back end, and the compilation method includes:

The compiling front end converts the target smart contract into a corresponding first intermediate code, wherein the first intermediate code records the offset position of each local variable in the corresponding stack frame;

The compiling front end generates the target smart contract's runtime environment initialization configuration information, and converts the runtime environment initialization configuration information into the corresponding second intermediate code, wherein the runtime environment initialization configuration information records memory allocation information, and the memory allocation information includes: first configuration information, wherein the first configuration information is used to indicate that when the memory space is initialized, a virtual register area, a stack area, and a heap area are divided in the memory space, and a storage slot in the virtual register area is used as a virtual register;

The compiling front end generates virtual register configuration information and converts the virtual register configuration information into corresponding register configuration intermediate code, wherein the virtual register configuration information records that storage slots at two preset fixed positions in the virtual register area are used as stack frame registers and stack pointer registers respectively;

The compiling front end sends an intermediate code set to the compiling back end, wherein the intermediate code set includes: the first intermediate code, the second intermediate code and the register configuration intermediate code;

The compilation backend compiles the register configuration intermediate code into a corresponding register configuration target code;

The compiling backend compiles the second intermediate code into a corresponding second target code;

The compilation backend compiles the first intermediate code into a first target code based on operations on a stack frame register and a stack pointer register.

In some embodiments, the step of the compilation backend compiling the first intermediate code into a first target code based on operations on a stack frame register and a stack pointer register comprises:

The compilation backend identifies definition information and call information of each function method in the first intermediate code;

The compilation backend uses the first function method in the first intermediate code as the function method to be processed, generates a corresponding stack frame layout according to definition information and call information of the function method to be processed, and performs register allocation for variables in the function method to be processed;

The compilation backend generates a corresponding instruction sequence based on the operation of the stack frame register and the stack pointer register according to the stack frame layout of the function method to be processed and the register allocation result of the variable;

The compilation backend determines the current stack depth corresponding to when the virtual machine executes the function method to be processed;

The compilation backend determines whether the current stack depth corresponding to the function method to be processed is greater than a preset depth threshold;

If it is determined that the current stack depth is greater than the preset depth threshold, the compilation backend terminates compilation;

If it is determined that the current stack depth is less than or equal to the preset depth threshold, the compilation backend detects whether the function method to be processed is the last function method in the first target code;

If it is detected that the function method to be processed is not the last function method in the first target code, the next function method of the function method to be processed is used as a new function method to be processed, and the step of generating a corresponding stack frame layout according to the definition information and call information of the function method to be processed is executed again by the compilation backend;

If it is detected that the function method to be processed is the last function method in the first target code, it means that the compilation is completed.

In some embodiments, before the compilation backend compiles the first intermediate code into a first target code based on the operation of the stack frame register and the stack pointer register, the step further includes:

The compilation backend initializes the current stack depth to 0;

The step of determining the current stack depth corresponding to when the virtual machine executes the function method to be processed by the compilation backend includes:

The compilation backend records the number A of operands generated and the number B of operands consumed by the function method to be processed;

The compilation backend updates the current stack depth to obtain the current stack depth corresponding to the virtual machine executing the function method to be processed; wherein the updated current stack depth is equal to the current stack depth before updating plus the number A of operands generated by the function method to be processed minus the number B of operands consumed by the function method to be processed.

In some embodiments, before the step of the compilation backend compiling the first intermediate code into the first target code based on the operation of the stack frame register and the stack pointer register, and/or during the process of the compilation backend compiling the first intermediate code into the first target code based on the operation of the stack frame register and the stack pointer register, the step further includes:

The compilation backend performs code optimization on the first intermediate code.

In some embodiments, the first configuration information is further used to indicate that the first N storage slots in the memory space are used as virtual register areas, where N ≥ 2;

The first storage slot in the memory space is used as the stack frame register, and the second storage slot in the memory space is used as the stack pointer register.

In some embodiments, the register configuration intermediate code is located at the frontmost position of the intermediate code set;

The virtual register configuration information also records that the initial value of the stack frame register is the starting address of the stack area.

In some embodiments, before the step of converting the target smart contract into the corresponding first intermediate code by the compilation front end, the step further includes:

The compilation front end determines a target persistent element in the target smart contract, where the target persistent element includes: a state variable, a string constant and/or an embedded bytecode;

The compiling front end declares each of the target persistent elements as a global variable and generates global variable record information, and converts the global variable record information into a corresponding third intermediate code, wherein the global variable record information records declaration information of each global variable, the size of the space occupied by each global variable, and the size of the global variable area divided when the memory space is initialized;

The first configuration information is further used to indicate that a global variable area is also divided in the memory space when the memory space is initialized, and the virtual register area, the stack area, the global variable area and the heap area are arranged in sequence from a low address to a high address in the memory space;

The memory allocation information further includes: second configuration information, the second configuration information being used to instruct to copy the encoded data of the global variable confirmed in the target smart contract to the global variable area;

The intermediate code set also includes the third intermediate code.

In a second aspect, an embodiment of the present disclosure further provides a smart contract compilation system, the compilation system is configured to implement the compilation method provided in the first aspect, the compilation system includes: a compilation front end and a compilation back end;

The compilation front end is used to convert the target smart contract into a corresponding first intermediate code, wherein the first intermediate code records the offset position of each local variable in the corresponding stack frame; and, it is also used to generate the runtime environment initialization configuration information of the target smart contract, and convert the runtime environment initialization configuration information into a corresponding second intermediate code, wherein the runtime environment initialization configuration information records memory allocation information, wherein the memory allocation information includes: first configuration information, wherein the first configuration information is used to indicate that when the memory space is initialized, a virtual register area, a stack area, and a heap area are divided in the memory space, and the storage slots in the virtual register area are used as virtual registers; and, it is also used to generate virtual register configuration information, and convert the virtual register configuration information into a corresponding register configuration intermediate code, wherein the virtual register configuration information records that the storage slots at two preset fixed positions in the virtual register area are used as stack frame registers and stack pointer registers respectively; and, it is also used to send an intermediate code set to the compilation back end, wherein the intermediate code set includes: the first intermediate code, the second intermediate code, and the register configuration intermediate code;

The compilation backend is used to compile the register configuration intermediate code into the corresponding register configuration target code; and, the compilation backend is also used to compile the second intermediate code into the corresponding second target code; and, it is also used to compile the first intermediate code into a first target code based on operations on the stack frame register and the stack pointer register.

In a third aspect, an embodiment of the present disclosure further provides an electronic device, comprising:

one or more processors;

A memory for storing one or more programs;

When the one or more programs are executed by the one or more processors, the one or more processors implement the smart contract compilation method provided in the first aspect.

In a fourth aspect, the embodiment of the present disclosure further provides a method for executing a target code of a smart contract, which is used to execute the target code generated by the smart contract compilation method provided in the first aspect, and the method for executing the target code of the smart contract comprises:

When initializing the memory space, a virtual register area, a stack area and a heap area are divided in the memory space according to the executable code corresponding to the first configuration information in the second target code, and storage slots at two preset fixed positions in the virtual register area are configured as a stack frame register and a stack pointer register according to the register configuration target code;

When the program is running, the first target code is executed, wherein when the instruction sequence of the target function method is executed, the stack frame of the target function method is first generated in the frame area, and then the final address of the variable to be processed is obtained by adding the starting address of the stack frame of the target function method recorded in the stack frame register to the offset position of the variable to be processed, and the variable to be processed is stored or retrieved according to the final address.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG1 is a flow chart of a smart contract compilation method provided in an embodiment of the present disclosure.

FIG. 2 is a flow chart of an optional implementation method of step S7 in the embodiment of the present disclosure.

FIG3 is a flow chart of another smart contract compilation method provided by an embodiment of the present disclosure.

FIG. 4 is a schematic diagram of a partitioning of memory space in an embodiment of the present disclosure.

FIG5 is a structural block diagram of a smart contract compilation system provided in an embodiment of the present disclosure.

FIG. 6 is a schematic diagram of the structure of an electronic device provided in an embodiment of the present disclosure.

DETAILED DESCRIPTION

In order to enable those skilled in the art to better understand the technical solution of the present disclosure, the present disclosure is further described in detail below in conjunction with the accompanying drawings and specific implementation methods.

Unless otherwise defined, the technical terms or scientific terms used in the present disclosure should be understood by people with ordinary skills in the field to which the present disclosure belongs. The "first", "second" and similar words used in the present disclosure do not indicate any order, quantity or importance, but are only used to distinguish different components. Similarly, similar words such as "one", "one" or "the" do not indicate quantitative restrictions, but indicate that there is at least one. "Include" or "comprising" and similar words mean that the elements or objects appearing before the word cover the elements or objects listed after the word and their equivalents, without excluding other elements or objects.

Many specific details of the present disclosure are described below to provide a clearer understanding of the present disclosure. However, as those skilled in the art will appreciate, the present disclosure may be implemented without following these specific details.

FIG1 is a flow chart of a smart contract compilation method provided by an embodiment of the present disclosure. As shown in FIG1 , the compilation method is based on a compilation system, and the compilation system includes a compilation front end and a compilation back end; in some embodiments, the compilation front end and the compilation back end are separated at the software level, the compilation front end can better adapt to more types of high-level programming languages, and the compilation back end can be more conducive to the switching of the target platform, and the front end and the back end can achieve one-to-many and many-to-one mutual compatibility. The compilation method includes:

Step S1, the compilation front end converts the target smart contract into the corresponding first intermediate code, and the first intermediate code records the offset position of each local variable in the corresponding stack frame.

Step S2: The compile front end generates the operating environment initialization configuration information of the target smart contract, and converts the operating environment initialization configuration information into the corresponding second intermediate code.

The operating environment initialization configuration information records memory allocation information, which includes: first configuration information, which is used to indicate that when the memory space is initialized, the memory space is divided into a virtual register area, a stack area, and a heap area. The storage slots in the virtual register area are used as virtual registers.

In some embodiments, in some embodiments, the first configuration information is further used to indicate that the first N storage slots in the memory space are used as virtual register areas, where N ≥ 2;

The first storage slot in the memory space is used as the stack frame register, and the second storage slot in the memory space is used as the stack pointer register.

In practical applications, other virtual registers may be set in the virtual register area as required. In the present disclosure, it is only necessary to ensure that N≥2.

Step S3: The compile front end generates virtual register configuration information and converts the virtual register configuration information into corresponding register configuration intermediate code.

The virtual register configuration information records that two storage slots at preset fixed positions in the virtual register area are used as a stack frame register and a stack pointer register respectively.

The storage slot is used as a stack frame register and a stack pointer register. At this time, the stack frame register and the stack pointer register are virtual registers, which are essentially special data structures located in the memory for simulating the functions of the stack frame register or the stack pointer register.

In practical applications, the stack frame register and the stack pointer register play a key role in memory management and function calls.

The stack frame register is often called the frame pointer register (FP), which points to the beginning of the current function stack frame. Each function has an independent frame (also called a stack frame) on the stack, which is allocated when the function is called. At any time during the execution process, the frame pointer register points to the beginning of the current function stack frame, thereby helping to determine the location of local variables and temporary variables.

The Stack Pointer Register (SP) points to the end of the current function stack frame. It is mainly used as a memory pointer to specify the memory location at which memory is read and written. The typical use of the stack pointer register is to save the stack bits belonging to the current function, including user-passed parameters, local variables, and CPU information (such as the return address when a subroutine is called).

In general, the stack frame register and the stack pointer register work together to manage the memory fragment on the stack, namely the stack frame, to implement functions such as function calls, allocation of local variables and temporary variables, parameter passing, and saving of return addresses.

In some embodiments, the virtual register configuration information also records that the initial value of the stack frame register is the starting address of the stack area.

Step S4: The compiling front end sends the intermediate code set to the compiling back end.

Among them, the intermediate code set includes: a first intermediate code, a second intermediate code and a register configuration intermediate code.

In some embodiments, the register configuration intermediate code is located at the front end of the intermediate code set, that is, the compilation backend will first process the register configuration intermediate code, and will also set the stack frame register and stack pointer register during subsequent runtime to ensure access to variables in function methods.

Step S5: The compilation backend compiles the register configuration intermediate code into the corresponding register configuration target code.

Step S6: The compilation backend compiles the second intermediate code into a corresponding second target code.

Step S7: The compilation backend compiles the first intermediate code into a first target code based on operations on the stack frame register and the stack pointer register.

When the target code of the smart contract is subsequently run, the access to the variables in the function method is based on the stack frame register and the stack pointer register (it can also be understood as managing the stack frames corresponding to the function methods in the smart contract based on the stack frame register and the stack pointer register); specifically, when executing the instruction sequence of a target function method in the smart contract, the stack frame of the target function method is first generated in the frame area, and then the starting address of the stack frame of the target function method recorded in the stack frame register is added to the offset position of the variable to be processed, so as to obtain the final address of the variable to be processed, and then store or retrieve the variable to be processed according to the final address; such a design can improve the access processing efficiency of the variable.

It can be seen that the compilation method provided by the embodiment of the present disclosure can improve the access speed of variables when the smart contract is running, thereby improving the execution performance of the smart contract. In addition, the compilation method provided by the embodiment of the present disclosure can also adapt to the writing of complex logic contracts. For the relatively large number of temporary variables in the function, they are placed on the stack frame, avoiding the problem of being unable to retrieve, reference and assign variable values on the virtual machine stack due to too many temporary variables and too deep stack depth.

In some embodiments, before the compilation backend compiles the first intermediate code into the first target code based on operations on the stack frame register and the stack pointer register, and/or during the process of the compilation backend compiling the first intermediate code into the first target code based on operations on the stack frame register and the stack pointer register, the compilation backend also performs code optimization on the first intermediate code.

The optimization of intermediate code by the compiler backend is a complex and critical process, which aims to generate efficient and optimized target code. There are many optimization methods, and the following are some of the main optimization methods:

Constant folding and constant propagation optimization: The compilation backend recognizes and calculates constant expressions and embeds the results directly into the target code to avoid runtime computational overhead.

Common sub-expression elimination optimization: For the same expression that appears multiple times in the code, the compilation backend will only calculate it once and store the result for subsequent use, thus avoiding repeated calculations.

Dead code elimination optimization: The compilation backend detects and removes code that will never be executed, reducing the size of the target code and improving execution efficiency.

Loop optimization: For loop structures, the compilation backend will perform a series of optimizations, such as loop unrolling (unrolling small loops into multiple repeated instruction sequences) and loop invariant lifting (moving unchanged expressions in the loop to calculations outside the loop) to reduce loop overhead.

Instruction selection and reordering optimization: The compiler backend will select the optimal instruction sequence based on the instruction set and characteristics of the target platform. At the same time, the compiler backend will also reorder the instructions to reduce dependencies and improve parallelism.

Register allocation optimization: This is an important part of the optimization process. The compiler backend analyzes the data access pattern in the intermediate code and tries to allocate frequently used variables or intermediate results to registers to reduce the number of memory accesses and increase the program running speed.

Memory access optimization: The compilation backend will consider how to use the cache most effectively, including strategies such as data alignment, reducing the number of memory accesses, and improving the locality of memory accesses to reduce memory access latency.

Branch prediction optimization: For conditional branches, the compilation backend will try to predict the direction of the branch and optimize the code layout to reduce the overhead caused by branch prediction errors.

The specific process of optimizing the intermediate code of the smart contract is a conventional technology in this field and will not be described in detail here.

In some embodiments, in step S1, similar to the code conversion function of a conventional compilation front end, the compilation front end performs lexical analysis, syntactic analysis, and semantic analysis on the target source code to generate a corresponding abstract syntax tree, and parses the abstract syntax tree to obtain a corresponding first intermediate code.

Among them, lexical analysis refers to dividing the source code into individual single words (tokens). Each word has a specific meaning and type, such as keywords, identifiers, operators, etc. This process is usually implemented through regular expressions or finite automata, reading characters one by one and matching them to obtain a series of words. Syntactic analysis refers to the combination and checking of word sequences according to given grammar rules to verify whether they meet the grammatical rules; semantic analysis is the process of static semantic checking of source code to ensure that there will be no semantic errors when the program is running. This step mainly includes type checking, scope analysis, and symbol table construction; after completing the above steps, the corresponding abstract syntax tree (AST) can be generated.

The compilation front end generates the corresponding intermediate code by parsing the abstract syntax tree; the intermediate code is the bridge between the compilation front end and the back end, which enables the front end and the back end of the compilation system to be optimized and modified independently without the need for large-scale changes to the entire compilation system; the process of parsing the abstract syntax tree to generate the corresponding intermediate code generally includes the following steps: traversing the abstract syntax tree, node conversion, processing control flow, type checking and conversion, symbol table management, optimization and output of intermediate code.

Among them, "traversing the abstract syntax tree" means that the compiler front end will traverse the entire abstract syntax tree, where the traversal method can be depth-first traversal (DFS) or breadth-first traversal (BFS), depending on the design of the compiler and the characteristics of the target language. "Node conversion" means that during the traversal process, the compiler front end will access each node of the abstract syntax tree and perform corresponding operations according to the type of the node. For each node, the compiler front end will convert it into one or more intermediate code instructions, which usually represent a certain calculation or operation, such as addition, function call, etc. "Processing control flow" means that during the conversion process, the compiler front end needs to pay special attention to control flow structures, such as conditional statements (if-else), loop statements (for, while), etc. These structures are usually represented as specific node types in the abstract syntax tree. The compiler front end needs to convert these nodes into appropriate intermediate codes to correctly represent the control flow of the program. "Type checking and conversion" means that when generating intermediate codes, the compiler front end will also perform type checking and conversion, which includes checking whether the types of variables match and performing necessary type conversions to ensure the legality of the operation. "Symbol table management" means that the compilation front end maintains a symbol table, which stores the information of all variables, functions and other identifiers defined in the program; when generating intermediate code, the compilation front end will use the symbol table to resolve the reference of the identifier and generate the corresponding intermediate code instructions. "Optimization" means that in the process of generating intermediate code, the compilation front end may perform some simple optimization operations, such as constant folding, useless code deletion, etc. These optimizations can help improve the performance of the final generated target code. "Output intermediate code" means that the compilation front end outputs the generated intermediate code to an intermediate file or memory for further processing by the back end. The intermediate code is usually expressed in a form that is easy to analyze and optimize, such as three-address code or static single assignment form (SSA).

When the function method in the smart contract is executed, it will exist in the stack area as a corresponding stack frame, and the offset position of each variable involved in the function method in the corresponding stack frame will also be confirmed in step S1.

FIG2 is a flow chart of an optional implementation method of step S7 in an embodiment of the present disclosure. As shown in FIG2, in some embodiments, step S7 includes:

Step S701: The compilation backend identifies definition information and call information of each function method in the first intermediate code.

After step S701 is completed, the compilation backend takes the first function method in the first intermediate code as the function method to be processed and executes the following step S702.

Step S702: The compilation backend generates a corresponding stack frame layout according to the definition information and call information of the function method to be processed, and performs register allocation for the variables in the function method to be processed.

The stack frame layout is the memory representation of the data structure required for function method execution. It contains all the local variables, operands, return addresses and other information required for function execution.

Step S703: The compiling backend generates a corresponding instruction sequence based on the operation of the stack frame register and the stack pointer register according to the stack frame layout of the function method to be processed and the register allocation result of the variable.

Step S704: The compiling backend determines the current stack depth corresponding to the virtual machine executing the function method to be processed.

Step S705: The compiling backend determines whether the current stack depth corresponding to the function method to be processed is greater than a preset depth threshold.

If it is determined that the current stack depth is greater than the preset depth threshold, step S706 is executed; if it is determined that the current stack depth is less than or equal to the preset depth threshold, step S707 is executed.

Step S706: The compilation backend terminates the compilation.

Step S707: The compilation backend detects whether the function method to be processed is the last function method in the first target code.

If it is detected that the function method to be processed is not the last function method in the first target code, the next function method of the function method to be processed is taken as a new function method to be processed, and step S702 is executed again;

If it is detected that the function method to be processed is the last function method in the first target code, it means that the compilation is completed.

Through the above process, the problem of data overflow stack when the virtual machine runs the smart contract can be effectively avoided.

In some embodiments, before the compilation backend compiles the first intermediate code into the first target code based on the operation of the stack frame register and the stack pointer register, it also includes: the compilation backend initializes the current stack depth to 0. At this time, step S704 specifically includes: first, recording the number of operands A generated by the function method to be processed and the number of operands B consumed; updating the current stack depth to obtain the current stack depth corresponding to the virtual machine executing the function method to be processed; wherein the updated current stack depth is equal to the current stack depth before the update plus the number of operands A generated by the function method to be processed minus the number of operands B consumed by the function method to be processed.

As an example, the function method to be processed is an arithmetic addition operation c=a+b. At this time, it is necessary to first determine the addresses of the parameters a and b from the corresponding stack frame (obtained by FP address + offset address of a or b), then read the corresponding data from the corresponding address and load it onto the stack of the virtual machine, and then perform the ADD addition operation, which consumes two operands for the operation a and b, and generates one operand for the operation c. Therefore, an operation such as c=a+b actually consumes two operands to generate one operand, and these steps of generating and consuming operands can be recorded synchronously in the compilation stage.

By recording the depth of operands, we can easily locate and index whether the value of a variable is on the stack of the virtual machine. If the value of this variable is needed, first check whether it has been loaded on the stack. If so, it only needs to be completed through a copy stack operand instruction such as DUP. In this way, there is one more operand on the stack, and it is also convenient for direct operations on the top of the stack. If this variable is no longer needed, that is, its life cycle is about to end, it can be swapped to the top of the stack through the SWAP exchange instruction to facilitate calculation operations.

The execution of each pending function method consumes or generates a fixed number of operands, which record and synchronously update the current stack depth and the number of operands in the virtual machine stack. This is equivalent to the compiler backend simulating the change process of the stack depth when the virtual machine is running.

At the smart contract source code level, some elements (called persistent elements) need to be persistently recorded to ensure the reliability and consistency of these data. However, in actual applications, it is found that the existing compilation methods have various problems when compiling persistent elements. In order to effectively improve the problems that occur in the compilation process of persistent elements in the prior art, the present disclosure provides a corresponding solution.

FIG3 is a flow chart of another smart contract compilation method provided by an embodiment of the present disclosure. FIG4 is a schematic diagram of a partitioning of memory space in an embodiment of the present disclosure. As shown in FIG3 and FIG4, the technical solution of the present disclosure not only includes steps S1 to S7 in the previous embodiment, but also includes before step S1:

Step S01: The compiling front end determines the target persistent elements in the target smart contract, where the target persistent elements include: state variables, string constants and/or embedded bytecodes.

Step S02: The compiling front end declares each target persistent element as a global variable and generates global variable record information, and converts the global variable record information into a corresponding third intermediate code.

The global variable record information records the declaration information of each global variable, the size of the space occupied by each global variable, and the size of the global variable area divided when the memory space is initialized.

At this time, the first configuration information in step S2 is also used to indicate that a global variable area is also divided in the memory space when the memory space is initialized, and the virtual register area, stack area, global variable area and heap area are arranged in sequence from low address to high address in the memory space.

In addition, the memory allocation information also includes: second configuration information, and the second configuration information is used to indicate that the encoded data of the global variables confirmed in the target smart contract is copied to the global variable area.

Different from the prior art in which only the stack area and the heap area are divided in the memory space when the memory space corresponding to the program source code is allocated, the memory allocation information in the present disclosure will indicate that the memory space corresponding to the smart contract is divided into the stack area, the global variable area and the heap area when the memory space is initialized in the subsequent order, and will also indicate that the encoded data of all global variables are copied to the global variable area after the memory space is divided into the stack area, the global variable area and the heap area. .

The encoding data of global variables is generated when the compiler converts the source code of the smart contract into bytecode. It is the actual storage form of global variables on the blockchain. The encoding data contains information such as the type information, initial value, and location of global variables in the contract state storage. This information is necessary for EVM (Ethereum Virtual Machine) to execute programs and is used to correctly read, write, and manage the status of these global variables.

At this time, the intermediate code set in step S4 also includes the third intermediate code.

The existing smart contract language features themselves do not have the concept of global variables; in this application, the selected target persistent element determined in step S01 is re-declared as a global variable, and global variable record information is generated. In addition, since global variables are declared in the smart contract, the compilation system is required to allocate memory for these global variables later.

The declaration data of global variables mainly refers to the part of the source code that declares the global variable, which tells the compiler that the variable is valid and accessible throughout the contract. The declaration data usually includes the variable name, variable type, and possible initial value (in some scenarios, the initial value does not need to be determined when declaring). This part of the data is mainly used by the compiler to understand the structure and semantics of the code for subsequent compilation.

The global variable record information is used to determine the position of each global variable in the global variable area during the subsequent copying of the encoded data of all global variables to the global variable area.

In the present disclosure, at least some persistent elements in a smart contract are declared as global variables, and then the smart contract is compiled accordingly, which can effectively improve various problems that arise during the compilation process of persistent elements in the smart contract and improve compilation efficiency.

In addition, since the virtual machine does not support direct addressing access to the code area, the prior art requires that each time a global variable is accessed, the global variable must be copied to a temporary memory first; and then deleted from the temporary memory when the operation on the global variable is completed. However, when a large number of global variables are involved in a program, the global variables must be frequently copied to the temporary memory during the program execution, which affects the virtual machine's operating performance. In the technical solution of the present invention, by setting the first configuration information and the second configuration information in the memory allocation information and generating corresponding global variable recording information, the first configuration information is used to indicate that a global variable area is divided in the memory space when the memory space is initialized, and the second configuration information is used to indicate that the encoded data of the global variables confirmed in the target source code is copied to the global variable area, and the global variable recording information records the declaration information of each global variable, the size of the space occupied by each global variable and the size of the space of the entire global variable area, so that all global variables can be copied to the global variable area after the memory space initialization is completed and before entering the program running stage, which can avoid the problem of frequently copying global variables to the temporary memory during the program running process in the prior art; therefore, the technical solution of the present invention can effectively improve the access efficiency of global variables and speed up the program running speed.

In some embodiments, the target persistent element in the present disclosure includes at least one of: a state variable, a string constant, and an embedded bytecode.

In some embodiments, when the target persistent element determined in step S01 includes a state variable, step S02 includes step S02a.

Step S02a: After the compilation front end allocates storage slots for each variable in the target smart contract, the compilation front end declares the slot number of the storage slot allocated to the state variable as a global variable.

When the target persistent element determined in step S01 includes a string constant, step S02 includes step S20b.

Step S02b: The compile front end directly declares the string constant as a global variable.

When the target persistent element determined in step S01 includes embedded bytecode, step S02 includes step S02c.

Step S02c: The compile front end directly declares the string constant as a global variable.

That is, when the target persistent element includes state variables, string constants, and embedded bytecodes at the same time, the corresponding step S2 includes step S02a, step S02b, and step S02c at the same time.

In the prior art, smart contracts use and declare state variables. To facilitate code inspection and review before generating the final bytecode, an intermediate language is usually generated. When generating the intermediate language, if the state variables do not use the allocation method of global variables to record the storage location slot of the state variables in the EVM, these variables are pure digital type encodings at the intermediate language level, which is not convenient for code inspection and review, and cannot be directly matched with the state variables of the smart contract. In this application, by declaring the state variables as global variables, the state variables (global variables) in the smart contract can be bound and mapped to the global variable symbols in the intermediate language, which is convenient for inspection and review. Access to global variables is to access the storage location in the EVM, and you can quickly scan and check which codes reference and use the state variables.

In the prior art, smart contracts have access requirements for string constants. If each string constant is directly encoded in the backend to generate corresponding bytecodes, more code will be added accordingly. In the present disclosure, in order to reduce the amount of code consumption, the string constants in the smart contract are encoded after being declared as global variables at the compiler stage, and the binding relationship between the string constants and the global variables is established in the intermediate language. The access to the global variables is the access to the string constants. The backend will only generate one bytecode to reduce the amount of code. At the same time, the general global variable access method is better used to address the string constants, reducing the coupling between the front end and the back end.

In actual applications, smart contracts may have bytecode embedding requirements (for example, the sub-contract bytecode or its own runtime bytecode needs to be embedded in the sub-contract for calling the sub-contract or performing contract deployment transactions). In this application, the sub-contract bytecode or its own runtime bytecode is declared as a global variable, and the access to these bytecodes is the access addressing of the global variable. In this way, there is no need to generate other special bytecode operations, and only the global variable address of the bytecode needs to be indexed for access.

It should be noted that which persistent elements will be used as target persistent elements in step S01 can be preset according to actual needs.

The disclosed embodiment also provides a method for running the target code of a smart contract. The running method is used to run the target code generated by any smart contract compilation method provided in the previous embodiment, and the running method includes:

Step BZ1, when initializing the memory space, dividing the memory space into a virtual register area, a stack area, and a heap area according to the executable code corresponding to the first configuration information in the second target code, and configuring the storage slots at two preset fixed positions in the virtual register area as a stack frame register and a stack pointer register according to the register configuration target code;

Step BZ2, when the program is running, execute the first target code, wherein when executing the instruction sequence of the target function method, first generate the stack frame of the target function method in the frame area, then add the starting address of the stack frame of the target function method recorded in the stack frame register to the offset position of the variable to be processed to obtain the final address of the variable to be processed, and store or retrieve the variable to be processed according to the final address.

Based on the same inventive concept, the embodiment of the present disclosure also provides a smart contract compilation system. Figure 5 is a structural block diagram of a smart contract compilation system provided by the embodiment of the present disclosure. As shown in Figure 5, the program source code compilation system can implement the compilation method provided by the previous embodiment, and the compilation system includes: a compilation front end and a compilation back end.

Among them, the compilation front end is used to convert the target smart contract into a corresponding first intermediate code, and the first intermediate code records the offset position of each local variable in the corresponding stack frame; and, it is also used to generate the operating environment initialization configuration information of the target smart contract, and convert the operating environment initialization configuration information into the corresponding second intermediate code, and the operating environment initialization configuration information records the memory allocation information, and the memory allocation information includes: the first configuration information, the first configuration information is used to indicate that when the memory space is initialized, the memory space is divided into a virtual register area, a stack area and a heap area, and the storage slots in the virtual register area are used as virtual registers; and, it is also used to generate virtual register configuration information, and convert the virtual register configuration information into the corresponding register configuration intermediate code, and the virtual register configuration information records that the storage slots at two preset fixed positions in the virtual register area are used as stack frame registers and stack pointer registers respectively; and, it is also used to send the intermediate code set to the compilation back end, and the intermediate code set includes: the first intermediate code, the second intermediate code and the register configuration intermediate code.

The compilation backend is used to compile the register configuration intermediate code into the corresponding register configuration target code; and, the compilation backend is also used to compile the second intermediate code into the corresponding second target code; and, it is also used to compile the first intermediate code into the first target code based on the operation of the stack frame register and the stack pointer register.

For the specific description of the compilation front-end and the compilation back-end in the compilation system in this embodiment, reference may be made to the corresponding contents in the previous embodiments, which will not be repeated here.

Based on the same inventive concept, an embodiment of the present disclosure also provides an electronic device. Figure 6 is a schematic diagram of the structure of an electronic device provided by an embodiment of the present disclosure. As shown in Figure 6, an embodiment of the present disclosure provides an electronic device including: one or more processors 101, a memory 102, and one or more I/O interfaces 103. One or more programs are stored on the memory 102. When the one or more programs are executed by the one or more processors, the one or more processors implement any smart contract compilation method in the above embodiments; one or more I/O interfaces 103 are connected between the processor and the memory, and are configured to implement information interaction between the processor and the memory.

Among them, the processor 101 is a device with data processing capabilities, including but not limited to a central processing unit (CPU), etc.; the memory 102 is a device with data storage capabilities, including but not limited to random access memory (RAM, more specifically SDRAM, DDR, etc.), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory (FLASH); the I/O interface (read-write interface) 103 is connected between the processor 101 and the memory 102, and can realize information interaction between the processor 101 and the memory 102, including but not limited to a data bus (Bus), etc.

In some embodiments, the processor 101 , the memory 102 , and the I/O interface 103 are connected to each other via a bus 104 , and further connected to other components of the computing device.

In some embodiments, the one or more processors 101 include a field programmable gate array.

According to an embodiment of the present disclosure, a computer-readable medium is further provided. The computer-readable medium stores a computer program, wherein when the program is executed by a processor, the steps in any smart contract compilation method in the above-mentioned embodiment are implemented.

In particular, according to an embodiment of the present disclosure, the process described above with reference to the flowchart can be implemented as a computer software program. For example, an embodiment of the present disclosure includes a computer program product, including a computer program carried on a machine-readable medium, and the computer program contains a program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from a network through a communication part, and/or installed from a removable medium. When the computer program is executed by a central processing unit (CPU), the above-mentioned functions defined in the system of the present disclosure are executed.

It should be noted that the computer-readable medium shown in the present disclosure may be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. The computer-readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or device, or any combination of the above. More specific examples of computer-readable storage media may include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In the present disclosure, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in combination with an instruction execution system, device or device. In the present disclosure, a computer-readable signal medium may include a data signal propagated in a baseband or as part of a carrier wave, in which a computer-readable program code is carried. This propagated data signal may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. Computer-readable signal media may also be any computer-readable medium other than computer-readable storage media, which may send, propagate or transmit a program for use by or in conjunction with an instruction execution system, apparatus or device. The program code contained on the computer-readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, optical cable, RF, etc., or any suitable combination of the above.

The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present disclosure. In this regard, each box in the flow chart or block diagram can represent a module, a program segment or a part of the code, and the aforementioned module, program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in a different order from the order marked in the accompanying drawings. For example, two boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram and/or flow chart, and the combination of the boxes in the block diagram and/or flow chart can be implemented with a dedicated hardware-based system that performs the specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

It is to be understood that the above embodiments are merely exemplary embodiments used to illustrate the principles of the present disclosure, but the present disclosure is not limited thereto. For those of ordinary skill in the art, various modifications and improvements can be made without departing from the spirit and substance of the present disclosure, and these modifications and improvements are also considered to be within the scope of protection of the present disclosure.

Claims (10)

1. An intelligent contract compiling method, characterized in that the compiling method is based on a compiling system, the compiling system comprises a compiling front end and a compiling back end, and the compiling method comprises:

The compiling front end converts the target intelligent contract into a corresponding first intermediate code, and the first intermediate code records offset positions of all local variables in corresponding stack frames;

The compiling front end generates running environment initialization configuration information of the target intelligent contract and converts the running environment initialization configuration information into a corresponding second intermediate code, the running environment initialization configuration information records memory allocation information, and the memory allocation information comprises: the memory system comprises first configuration information, a second configuration information and a first control unit, wherein the first configuration information is used for indicating that a virtual register area, a stack area and a file area are divided in a memory space when the memory space is initialized, and a storage groove in the virtual register area is used as a virtual register;

The compiling front end generates virtual register configuration information and converts the virtual register configuration information into corresponding register configuration intermediate codes, wherein storage grooves at two preset fixed positions in the virtual register area are recorded in the virtual register configuration information and used as stack frame registers and stack pointer registers respectively;

The compiling front end sends an intermediate code set to the compiling back end, the intermediate code set comprising: the first intermediate code, the second intermediate code, and the register configuration intermediate code;

the compiling back end compiles the register configuration intermediate code into a corresponding register configuration target code;

The compiling back end compiles the second intermediate code into a corresponding second target code;

The compilation backend compiles the first intermediate code into a first object code based on operating on a stack frame register and a stack pointer register.

2. The compiling method of claim 1, wherein the compiling back-end compiles the first intermediate code into the first object code based on operating on a stack frame register and a stack pointer register comprises:

The compiling back end identifies definition information and calling information of each function method in the first intermediate code;

the compiling back end takes a first function method in the first intermediate code as a function method to be processed, generates a corresponding stack frame layout according to definition information and call information of the function method to be processed, and distributes registers of variables in the function method to be processed;

The compiling back end generates a corresponding instruction sequence based on the operation of a stack frame register and a stack pointer register according to the stack frame layout of the function method to be processed and the register allocation result of the variables;

The compiling back end determines the current stack depth corresponding to the virtual machine executing the function method to be processed;

the compiling back end judges whether the current stack depth corresponding to the function method to be processed is larger than a preset depth threshold value;

If the current stack depth is judged to be larger than the preset depth threshold, the compiling back end stops compiling;

If the current stack depth is less than or equal to the preset depth threshold value, the compiling back end detects whether the function method to be processed is the last function method in the first target code;

If the function method to be processed is not the last function method in the first object code, taking the next function method of the function method to be processed as a new function method to be processed, and executing the step of generating a corresponding stack frame layout by the compiling back end according to the definition information and the calling information of the function method to be processed again;

and if the function method to be processed is detected to be the last function method in the first target code, the compiling is completed.

3. The compiling method of claim 2, further comprising, before the compiling back-end compiling the first intermediate code into the first object code step based on operating on a stack frame register and a stack pointer register:

initializing the current stack depth to be 0 by the compiling back end;

the step of determining the current stack depth corresponding to the virtual machine executing the function method to be processed by the compiling back end comprises the following steps:

the compiling back end records the number A of operands generated by the function method to be processed and the number B of consumed operands;

The compiling back end updates the current stack depth to obtain the current stack depth corresponding to the virtual machine executing the function method to be processed; the updated current stack depth is equal to the current stack depth before updating plus the number A of operands generated by the function method to be processed minus the number B of operands consumed by the function method to be processed.

4. The compiling method according to claim 1, wherein before the step of compiling the first intermediate code into the first object code based on the operation on the stack frame register and the stack pointer register by the compiling back end and/or during the compiling back end compiling the first intermediate code into the first object code based on the operation on the stack frame register and the stack pointer register, further comprising:

And the compiling back end carries out code optimization on the first intermediate code.

5. The compiling method of claim 1, wherein the first configuration information is further used for indicating that first N storage slots in the memory space are used as virtual register areas, wherein N is equal to or greater than 2;

The 1 st slot in the memory space is used as the stack frame register, and the 2 nd slot in the memory space is used as a stack pointer register.

6. The compiling method of claim 1, wherein the register configuration intermediate code is located at a foremost position of the intermediate code set;

And the initial value of the stack frame register is also recorded in the virtual register configuration information as the starting address of the stack area.

7. The compiling method of claim 1, further comprising, before the step of converting the target smart contract into the corresponding first intermediate code by the compiling front-end:

the compiling front-end determines a target persistence element in the target smart contract, the target persistence element comprising: state variables, string constants, and/or embedded bytecodes;

The compiling front end respectively declares each target persistence element as a global variable and generates global variable record information, and converts the global variable record information into a corresponding third intermediate code, wherein the global variable record information records the declaration information of each global variable, the space size of each global variable and the space size of a global variable area divided when the memory space is initialized;

The first configuration information is further used for indicating that a global variable area is further divided in the memory space when the memory space is initialized, and the virtual register area, the stack area, the global variable area and the heap area are sequentially arranged in the memory space from a low address to a high address;

The memory allocation information further includes: second configuration information for indicating copying of encoded data of the global variable identified from the target smart contract to the global variable area;

the set of intermediate codes further includes the third intermediate code.

8. An intelligent contract compiling system, characterized in that the compiling system is configured to enable the compiling method according to any one of claims 1 to 7, the compiling system comprising: a compiling front end and a compiling back end;

The compiling front end is used for converting the target intelligent contract into a corresponding first intermediate code, and the offset position of each local variable in a corresponding stack frame is recorded in the first intermediate code; and the method is also used for generating the running environment initialization configuration information of the target intelligent contract, converting the running environment initialization configuration information into a corresponding second intermediate code, wherein the running environment initialization configuration information records memory allocation information, and the memory allocation information comprises the following components: the memory system comprises first configuration information, a second configuration information and a first control unit, wherein the first configuration information is used for indicating that a virtual register area, a stack area and a file area are divided in a memory space when the memory space is initialized, and a storage groove in the virtual register area is used as a virtual register; and is further configured to generate virtual register configuration information, and convert the virtual register configuration information into corresponding register configuration intermediate codes, the virtual register configuration information is recorded with the fact that storage grooves at two preset fixed positions in the virtual register area are respectively used as a stack frame register and a stack pointer register; and, further for sending an intermediate code set to the compilation backend, the intermediate code set comprising: the first intermediate code, the second intermediate code, and the register configuration intermediate code;

The compiling back end is used for compiling the register configuration intermediate code into a corresponding register configuration target code; the compiling back end is further used for compiling the second intermediate code into corresponding second target code; and further for compiling the first intermediate code into a first object code based on operating on a stack frame register and a stack pointer register.

9. An electronic device, comprising:

One or more processors;

A memory for storing one or more programs;

when executed by the one or more processors, causes the one or more processors to implement the compilation method of any of claims 1 to 7.

10. An object code running method of an intelligent contract, characterized in that it is used for running an object code generated by the intelligent contract compiling method according to any one of claims 1 to 7, the running method comprising:

When the memory space is initialized, dividing a virtual register area, a stack area and a stack area in the memory space according to executable codes corresponding to first configuration information in a second target code, and configuring storage grooves at two preset fixed positions in the virtual register area into a stack frame register and a stack pointer register according to the register configuration target code;

And executing the first object code when the program runs, wherein when an instruction sequence of the objective function method is executed, a stack frame of the objective function method is generated in a frame area, then a final address of a variable to be processed is obtained by adding the initial address of the stack frame of the objective function method recorded in a stack frame register with the offset position of the variable to be processed, and the variable to be processed is stored or fetched according to the final address.