CN115167862A - Patch method and related equipment - Google Patents

Abstract

The embodiments of the present application provide a patching method and related equipment. The method includes: in the process of compiling an original file, generating a compilation information table, the original file is a file in the WebAssembly binary format, the compilation information table records the function index of the original function, and the original file is in the WebAssembly binary format. The function is the function in the original file; during the compilation process of the patch file, a function correspondence table is generated according to the compilation information table. The patch file is a file in the WebAssembly binary format. The function correspondence table records the correspondence between the original function and the patch function. The patch function is the function in the patch file; during the loading process of the original file, the function address of the original function in the function index space is replaced with the function address of the patch function according to the function correspondence table, and the function index space is generated during the loading process of the original file. With the embodiments of the present application, it is possible to use patches to perform function-level replacement and update of WebAssembly applications.

Description

Patch method and related equipment

technical field

The present application relates to the field of computer technology, and in particular, to a patching method and related equipment.

Background technique

There is no patch solution implemented for WebAssembly applications yet. If you want to replace a specific function in the WebAssembly file, you need to recompile the entire source file to get the .wasm file in the new binary format after the function is replaced, which is in the form of a new version of the application. Load and run in the WebAssembly virtual machine.

SUMMARY OF THE INVENTION

The embodiments of the present application provide a patch method and related equipment, which can implement function-level replacement and update of a WebAssembly application by using a patch.

In a first aspect, an embodiment of the present application provides a patching method, which includes: in the process of compiling an original file, generating a compilation information table, wherein the original file is a file in the WebAssembly binary format, and the compilation information table records the original file. a function index of a function, where the original function is a function in the original file; during the compilation process of the patch file, a function correspondence table is generated according to the compilation information table, wherein the patch file is a file in the WebAssembly binary format, The function correspondence table records the correspondence between the original function and the patch function, and the patch function is a function in the patch file; during the loading process of the original file, the function index is indexed according to the function correspondence table. The function address of the original function in the space is replaced with the function address of the patch function, wherein the function index space is generated during the loading process of the original file. In the embodiment of the present application, in the process of compiling to obtain the original file in the WebAssembly binary format, a compilation information table is generated, and the compilation information table records the function index of the original function in the original file; after compiling to obtain the patch file in the WebAssembly binary format In the process of compiling, a function correspondence table is generated according to the function index of the original function in the compilation information table and the function index of the patch function in the patch file, and the function correspondence table records the correspondence between the original function and the patch function; that is, from the compilation information table Obtain the function index of the original function from , obtain the function index of the patch function from the patch file, record the function index of the original function and the function index of the patch function in the function correspondence table, thereby generating the function correspondence table; During the process, a function index space will be generated. The function index space records the function address of the original function, and the function correspondence table records the corresponding relationship between the original function and the patch function. Therefore, the function address of the patch function can be obtained from the patch file, and then According to the correspondence between the original function and the patch function recorded in the function correspondence table, replace the function address of the original function in the function index space with the function address of the patch function; because in the function index space, the function address of the original function is replaced by the patch function The function address of the later function application is the patch function, so as to realize the function-level replacement and update of the WebAssembly application using the patch. It should be understood that the original function or patch function described in the embodiments of the present application does not refer to a function, but refers to a type of function; for example, the original function refers to the general name of the functions that need to be patched, and the patch function refers to the general name of the functions used for patching. .

In a possible implementation manner, the functions in the patch file have one and only patch functions. In the embodiment of the present application, the functions in the patch file include and only the patch function, that is, any function in the patch file is a function that is beneficial to the patch, which is conducive to making the patch file smaller in size and required for downloading and loading. short time.

In a possible implementation manner, the replacing the function address of the original function in the function index space with the function address of the patch function according to the function correspondence table includes: judging whether or not according to the function correspondence table The patch function exists; if the patch function exists, obtain the function address of the patch function from the code segment of the patch file; replace the function address of the original function in the function index space with the The function address of the patch function described above. In the embodiment of the present application, during the loading process of the original file, the function address of the original function is obtained from the original file and added to the function index space; when patching is required, the function correspondence table can be used to determine whether the original function needs to be updated. Replace, when the corresponding relationship between the original function and the patch function is recorded in the function correspondence table, it indicates that the original function needs to be replaced with a patch function. In this way, it can be judged whether there is a patch function according to the function correspondence table. Obtain the function address of the patch function from the code segment of the file, and then replace the function address of the original function in the function index space with the function address of the patch function; in other words, instead of adding the function address of the original function to the function index space, The function address of the patch function is added to the function index space, thereby realizing the replacement of the original function by the patch function.

In a possible implementation manner, the compilation information table further records the size of the memory segment of the original file; the method further includes: during the compilation process of the patch file, obtaining from the compilation information table The size of the memory segment of the original file; the code segment of the patch file is compiled according to the size of the memory segment of the original file and the data offset of the patch function. In the embodiment of the present application, if the patch function involves a memory operation, the memory operation of the code segment of the patch file needs to be corrected; in this case, the compilation information table generated in the process of compiling the original file also records the original file In the process of compiling and obtaining the patch file, the memory segment size of the original file is obtained from the compilation information table, and the memory segment size of the original file and the data offset of the patch function are used as the new offset, and write Enter the code segment of the patch file, so that the patch function can perform memory operations normally.

In a possible implementation manner, the compilation information table further records a function index of a called function, and the called function is a function called by the original function; the method further includes: in the patch file During the compiling process, the function index of the called function is obtained from the compilation information table; the code segment of the patch file is compiled according to the function index of the called function. In the embodiment of the present application, if the original function involves calling other functions, after the original function is replaced by the patch function, the patch function also involves calling the function originally called by the original function, and the code segment of the patch file needs to be corrected; this kind of In this case, the compilation information table also records the function index of the called function, and the called function is the function called by the original function; in the process of compiling to obtain the patch file, the function index of the called function is obtained from the compilation information table, and the The function index of the called function compiles the code segment written into the patch file, so that after replacing the original function with the patch function by means of a patch, the patch function can also call the function originally called by the original function.

In a possible implementation manner, the called function is a function directly called by the original function, the code segment of the patch file includes a direct calling instruction, and the direct calling instruction includes a function of the called function index. In the embodiment of the present application, if the called function is a function directly called by the original function, then after the original function is replaced by the patch function, the called function is also the function directly called by the patch function; in this case, the compilation information table The function index of the called function is also recorded; therefore, after obtaining the function index of the called function from the compilation information table, and writing the function index of the called function into the direct calling instruction of the code segment of the patch file, the patch function can be implemented. After directly calling the called function, after replacing the original function with the patch function by means of a patch, the patch function can also directly call the function originally called directly by the original function.

In a possible implementation manner, the compilation information table further records the function signature index of the called function and the element segment size of the original file; the called function is indirectly called by the original function function; the compiling the code segment of the patch file according to the function index of the called function includes: acquiring the function signature index of the called function from the compilation information table; according to the function index of the called function Index compiling the element segment of the patch file to obtain the element index of the called function; compiling the code segment of the patch file according to the element segment size of the original file and the element index of the called function, wherein, The code segment of the patch file includes an indirect call instruction, and the indirect call instruction includes a function signature index of the called function. In the embodiment of the present application, if the called function is a function indirectly called by the original function, then after the original function is replaced by the patch function, the called function is also the function indirectly called by the patch function; in this case, the compilation information table It also records the function index of the called function, the function signature index of the called function, and the element segment size of the original file; obtains the function index of the called function from the compilation information table, and writes the function index of the called function into the patch file. Element segment, the element index of the called function can be obtained; obtain the element segment size of the original file from the compilation information table, and write the element segment size of the original file and the element index of the called function into the code segment of the patch file; from the compilation information The function signature index of the called function is obtained from the table, and after the function signature index of the called function is written into the indirect call instruction in the code segment of the patch file, the indirect call of the called function by the patch function can be realized. After replacing the original function with the patch function, the patch function can also indirectly call the function originally called indirectly by the original function.

In a possible implementation manner, the method further includes: during the loading process of the original file, acquiring the element index of the called function from the patch file; storing the element index of the called function It is added to the table index space, wherein the table index space is generated during the loading process of the original file. In the embodiment of the present application, for indirect calls, since the specific function to be called is not known at compile time, it can only be known at runtime, and the called function is not a function of the called function in the function index space. The index is located directly, but indirectly through the table index space, which is generated by loading the original file; therefore, during the loading process of the original file, the element index of the called function needs to be obtained from the patch file, and will be The element index of the calling function is added to the table index space; in this way, at runtime, the patch function can obtain the element index of the called function from the table index space, and then locate the called function and indirectly call the called function .

In a possible implementation manner, the called function is a virtual machine import function; before acquiring the function index of the called function from the compilation information table, the method further includes: generating the The function index of the called function; the function index of the called function is added to the compilation information table. In the embodiment of the present application, the called function is a virtual machine import function, and the compilation information table generated during the process of compiling the original file does not record the function index of the called function, so it is necessary to generate the function index of the called function, and The function index of the called function is added to the compilation information table, so as to facilitate the implementation of the patch function to call the called function.

In a possible implementation manner, the method further includes: during the loading process of the original file, adding the called function to the function index space through an import section of the original file. In the embodiment of the present application, the called function is a virtual machine import function, so the function index space generated during the loading process of the original file does not have the called function. Therefore, the called function needs to be added to the import section of the original file. in the function index space, so that the called function exists in the function index space; thus, it is beneficial to realize that the patch function calls the called function.

In the second aspect, an embodiment of the present application provides a patch device, and the beneficial effects can be found in the description of the first aspect, which will not be repeated here. The apparatus includes a processing unit, and the processing unit is configured to: in the process of compiling the original file, generate a compilation information table, wherein the original file is a file in the WebAssembly binary format, and the compilation information table records the function of the original function index, the original function is the function in the original file; in the process of compiling the patch file, a function correspondence table is generated according to the compilation information table, wherein the patch file is a file in the WebAssembly binary format, and the function The correspondence table records the correspondence between the original function and the patch function, and the patch function is a function in the patch file; during the loading process of the original file, the function index space is stored according to the function correspondence table. The function address of the original function is replaced with the function address of the patch function, wherein the function index space is generated during the loading process of the original file.

In a possible implementation manner, the functions in the patch file have one and only patch functions.

In a possible implementation manner, the processing unit is specifically configured to: determine whether the patch function exists according to the function correspondence table; if the patch function exists, obtain the patch function from the code segment of the patch file the function address of the patch function; replace the function address of the original function in the function index space with the function address of the patch function.

In a possible implementation manner, the compilation information table further records the size of the memory segment of the original file; the processing unit is further configured to: in the process of compiling the patch file, from the compilation information table to obtain the memory segment size of the original file; compile the code segment of the patch file according to the memory segment size of the original file and the data offset of the patch function.

In a possible implementation manner, the compilation information table further records a function index of a called function, where the called function is a function called by the original function; the processing unit is further configured to: in the During the compilation process of the patch file, the function index of the called function is obtained from the compilation information table; the code segment of the patch file is compiled according to the function index of the called function.

In a possible implementation manner, the called function is a function directly called by the original function, the code segment of the patch file includes a direct calling instruction, and the direct calling instruction includes a function of the called function index.

In a possible implementation manner, the compilation information table further records the function signature index of the called function and the element segment size of the original file; the called function is indirectly called by the original function The processing unit is specifically configured to: obtain the function signature index of the called function from the compilation information table; compile the element segment of the patch file according to the function index of the called function to obtain the The element index of the called function; compile the code segment of the patch file according to the element segment size of the original file and the element index of the called function, wherein the code segment of the patch file includes an indirect call instruction, the The indirect call instruction includes the function signature index of the called function.

In a possible implementation manner, the processing unit is further configured to: during the loading process of the original file, obtain the element index of the called function from the patch file; The element index is added to the table index space, wherein the table index space is generated during the loading process of the original file.

In a possible implementation manner, the called function is a virtual machine import function; the processing unit is further configured to: before acquiring the function index of the called function from the compilation information table; generate The function index of the called function; adding the function index of the called function to the compilation information table.

In a possible implementation manner, the processing unit is further configured to: during the loading process of the original file, add the called function to the function index space through an import segment of the original file.

In a third aspect, an embodiment of the present application provides a patch device, including a processor, a memory, a communication interface, and one or more programs, where the one or more programs are stored in the memory and configured to be processed by the above-mentioned process The above program includes instructions for performing the steps in the method according to any one of the above first aspects.

In a fourth aspect, an embodiment of the present application provides a chip, including: a processor, configured to call and run a computer program from a memory, so that a device installed with the chip executes any one of the above-mentioned first aspects. Methods.

In a fifth aspect, an embodiment of the present application provides a computer-readable storage medium, which stores a computer program for electronic data exchange, wherein the computer program causes a computer to execute the method described in any one of the foregoing first aspects. method.

In a sixth aspect, an embodiment of the present application provides a computer program, where the computer program causes a computer to execute the method according to any one of the foregoing first aspects.

Description of drawings

FIG. 1 is a schematic diagram of a main segment structure and a loaded and parsed structure of a WebAssembly file provided by an embodiment of the present application.

FIG. 2 is a schematic diagram of a WebAssembly function calling manner provided by an embodiment of the present application.

FIG. 3 is a schematic flowchart of a patching method provided by an embodiment of the present application.

FIG. 4 is a schematic diagram of a loading process of each segment of WebAssembly provided by an embodiment of the present application.

FIG. 5 is a schematic diagram of an original loading process of a WebAssembly function segment provided by an embodiment of the present application.

FIG. 6 is a schematic diagram of a loading process after modification of a WebAssembly function segment provided by an embodiment of the present application.

FIG. 7 is a schematic diagram of an original compilation flow of a code segment of WebAssembly when a function is directly called according to an embodiment of the present application.

FIG. 8 is a schematic diagram of a modified compilation flow of a WebAssembly code segment when a function is directly called according to an embodiment of the present application.

FIG. 9 is a schematic diagram of an original compilation flow of a code segment of WebAssembly when there is an indirect function call provided by an embodiment of the present application.

FIG. 10 is a schematic diagram of a modified compilation flow of a WebAssembly code segment when there is an indirect function call provided by an embodiment of the present application.

FIG. 11 is a schematic diagram of a WebAssembly compilation process provided by an embodiment of the present application.

FIG. 12 is a schematic diagram of a WebAssembly patch creation process provided by an embodiment of the present application.

FIG. 13 is a schematic diagram of a function index space correction process provided by an embodiment of the present application.

FIG. 14 is a schematic diagram of another WebAssembly patch creation process provided by an embodiment of the present application.

FIG. 15 is a schematic diagram of another WebAssembly compilation process provided by an embodiment of the present application.

FIG. 16 is a schematic diagram of another WebAssembly patch creation process provided by an embodiment of the present application.

FIG. 17 is a schematic diagram of a table index space correction process provided by an embodiment of the present application.

FIG. 18 is a schematic structural diagram of a patch device provided by an embodiment of the present application.

FIG. 19 is a schematic structural diagram of a patch device provided by an embodiment of the present application.

Detailed ways

In order to make those skilled in the art better understand the solutions of the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present application. Obviously, the described embodiments are only It is a part of the embodiments of the present application, but not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative work fall within the protection scope of the present application.

The terms "comprising" and "having", and any variations thereof, in the description and claims of this application and the above figures are intended to cover non-exclusive inclusions. For example, a process, method, system, product or device comprising a series of steps or units is not limited to the listed steps or units, but optionally also includes unlisted steps or units, or optionally also includes For other steps or units inherent to these processes, methods, products or devices.

Reference in this specification to an "embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment can be included in at least one embodiment of the present application. The appearances of the phrase in various places in the specification are not necessarily all referring to the same embodiment, nor a separate or alternative embodiment that is mutually exclusive of other embodiments. It is explicitly and implicitly understood by those skilled in the art that the embodiments described in this specification may be combined with other embodiments.

First, definitions of abbreviations and terms that may be involved in this application are provided so as to be easily understood by those skilled in the art, as shown in Table 1.

Table 1 Abbreviations and Definitions of Terms

English abbreviation Complete English expression/English standard language Chinese expressions/Chinese terms wasm WebAssembly a new binary format i32 i32 WebAssembly data type: 32-bit integer call call WebAssembly instructions: direct calls call_indirect call_indirect WebAssembly Instructions: Indirect Calls i32.store i32.store WebAssembly Instructions: Store in Linear Memory

Next, the relevant technical knowledge involved in the embodiments of the present application is introduced here. Described as follows:

WebAssembly is a low-level code execution specification designed and promoted by several major browser manufacturers such as Google, Apple, and Microsoft in recent years. It is designed as a portable, safe, low-size, and efficient binary format. WebAssembly can generate .wasm files in binary format by writing C/C++ code, and can run in a virtual machine that follows the WebAssembly specification. The sandbox function of WebAssembly makes the .wasm file actually run in its private sandbox when it is loaded into the runtime engine, and the programs in the sandbox cannot access the address space outside the sandbox. The WebAssembly opcode design is streamlined, which not only achieves fast compilation speed, but also high running speed. The features of WebAssembly, which can safely run third-party code, ultra-lightweight, and high-performance, are of great value in mobile devices, IoT devices, smart small appliances, and trusted operating environments.

When embedded device products need to provide a browser-like way to load third-party modules, using WebAssembly as a media format is a very attractive solution. Developers can publish their own algorithms as WebAssembly applications. Embedded devices can load and use the application in different architectures, platforms, and environments by integrating the WebAssembly virtual machine.

1) WebAssembly binary format

The top-level structure of WebAssembly is a module. Each WebAssembly binary file corresponds to a module. The main body of the module consists of multiple segments, and each segment is identified by a unique segment number. The specific structure is shown in Figure 1.

Among them, because the function involves information such as the index of the function, the type of the function, and the function code, the function is jointly represented by the function segment, the type segment, and the code segment.

Type segment: used to store the function signature type, including function parameters and return values.

Code segment: Stores the local variable information and execution code information of the function.

Function section: Stores the index of the function signature of each function in the type section in order.

Import section: Supports importing external functions for the module to call. The imported functions are composed of function names and function signatures.

Table segment and element segment: Function references can be saved, and the function pointer function can be realized through the table segment and element segment.

Memory segment: used to define linear memory, which is used to store dynamic data for program operation.

Data segment: Stores static data that initializes memory.

2) WebAssembly virtual machine

The WebAssembly code (that is, the WebAssembly file) runs on a virtual machine that supports the WebAssembly specification, and the WebAssembly virtual machine executes the WebAssembly file by parsing and loading the WebAssembly binary format.

The function-related structure generated by the WebAssembly virtual machine in the process of parsing and loading WebAssembly files is shown in Figure 1, including:

Function index space: function index, including all function information, including function signature and function address; parsed by function segment and code segment, the first address of the function identifies the function, the function signature identifies the function type, the compiler records the wasm compilation information, and records in the .wasm file. Among them, the function address here is a Webassembly virtual address, which is specified by the compiler for the function when the function is compiled.

Table index space: holds function references, used for indirect calls of functions, resolved by table and element segments.

Linear memory index space: A memory structure with contiguous addresses that can be byte-addressable, used to store dynamic data for program operation, and parsed by memory segments and data segments.

3) WebAssembly function call

There are two ways to call functions in WebAssembly, as shown in Figure 2, including:

Direct call: Using the call instruction, the call instruction first obtains the function index (func_idx), and then obtains the function address through the function index to call the function; the function index is specified by the immediate parameter of the instruction.

Indirect call: use the call_indirect instruction and the table index space to complete, the call_indirect instruction first obtains the function signature index (type-idx), the function signature index is placed in the immediate value, and then the (table) element index is obtained in the stack, and then the element index is passed. The function index is obtained, and the function signature is dynamically checked. If the function signature matches, the function address is obtained through the function index and the function is called. Among them, the wasm specification defines that the module can only define at most one table, and the element type must be a function reference (encoded as 0x70). In addition to the element type, the table type also needs to specify a limit on the number of elements, where a lower limit must be specified, and an upper limit is optional. Among them, the table index refers to the function reference (the first address of the function) that is indirectly called in the table segment through the index value. Among them, the immediate value is the index, and the index obtained at the table segment index is the function reference (function first address) of the indirect call.

Thirdly, in order to facilitate the understanding of the embodiments of the present application, the technical problems to be solved by the present application are further analyzed and proposed. Described as follows:

There is no patch solution implemented for WebAssembly applications yet. If you want to replace a specific function in the WebAssembly file, you need to recompile the entire source file to get the .wasm file in the new binary format after the function is replaced, which is in the form of a new version of the application. Load and run in the WebAssembly virtual machine. However, the way to regenerate WebAssembly binaries has the following disadvantages:

1) The entire application file has a lot of data and a large volume, and it takes a long time to download, replace, and load, and it cannot be lightweight and quickly updated.

2) In the case that the WebAssembly application needs to update the local code frequently without affecting the application version, if a new version of the .wasm file is regenerated every time, the application version number is also constantly increasing, resulting in version redundancy.

In view of the problems existing in the above analysis, this application proposes a method for compiling and loading patches for WebAssembly, making patch files for the WebAssembly binary format, and realizing the function-level replacement and update of WebAssembly applications using patches. The innovations of this application include: making and loading patches for the WebAssembly format, mainly in the following two aspects:

1) Patch making

Compilation stage: The application developed in C/C++ is compiled into a .wasm file in WebAssembly binary format, the compilation information is recorded during the compilation process, including the correspondence between function names and function indexes, etc., and the compilation information table is generated and exported. The compilation information table Including function index table and so on.

Patch making phase: Compile the WebAssembly patch file according to the compilation information table exported by the WebAssembly application, and at the same time correct the code segment during the compilation of the patch file. Wherein, the period of compiling the patch file refers to the production of the compiling patch file, and revising the code segment refers to replacing the reference of the original function with the reference of the patch function in the patch file.

2) Patch loading

Loading stage: Replace the function address in the function index space during loading, and replace the original function address with the patch function address. The function address refers to the first address of the function code block, which is also called the function code address, the function code address, and the first address of the function code block. If the patch function involves other function calls, the table index space needs to be corrected.

This application is applied in scenarios such as WebAssembly application upgrade and update or application defect repair. Due to the small size of the patch file, the time required for downloading and loading is short, which shortens the time for updating WebAssembly applications or repairing application defects.

Please refer to FIG. 3. FIG. 3 is a schematic flowchart of a patching method provided by an embodiment of the present application. The method includes but is not limited to the following steps:

301. In the compilation process of the original file, a compilation information table is generated, wherein the original file is a file in the WebAssembly binary format, and the compilation information table records the function index of the original function, and the original function is in the original file. The function.

302. During the compilation process of the patch file, generate a function correspondence table according to the compilation information table, wherein the patch file is a file in the WebAssembly binary format, and the function correspondence table records the correspondence between the original function and the patch function. relationship, the patch function is a function in the patch file.

303. During the loading process of the original file, replace the function address of the original function in the function index space with the function address of the patch function according to the function correspondence table, wherein the function index space is in the generated during the loading process of the original file described above.

The compilation information table includes a function index table, which records the function indexes of all functions in the original file; the function correspondence table records the correspondence between all original functions that need to be replaced and their corresponding patch functions.

It should be understood that the original files and patch files in the WebAssembly binary format can be obtained by first writing C/C++ source codes and then compiling them into .wasm files. In the process of compiling the original file, it refers to the process of compiling from other formats to the original file in WebAssembly binary format; in the process of compiling the patch file, it refers to the process of compiling from other formats into the patch file in WebAssembly binary format. .

Exemplarily, the generating a function correspondence table according to the compilation information table includes: acquiring a function index of the original function from the compilation information table; according to the function index of the original function and the function of the patch function The index generates the function correspondence table. The function correspondence table can record the index of the original function and the function index of the patch function, and the two are associated and recorded in the function correspondence table. For example, in the process of compiling the patch file, the function index of the original function is obtained from the compilation information table, the function index of the patch function is obtained from the patch file, and the function index of the original function and the function index of the patch function are associated and recorded in the corresponding function of the function. table, so as to generate a function corresponding table.

It should be noted that the original function or patch function described in the embodiments of this application does not refer to one function, but refers to a type of function, which may have multiple; There may be multiple functions that need to be replaced in the patch file, and these multiple functions that need to be replaced are collectively referred to as the original function; the patch function refers to the general name of the functions used for patching, and there may be multiple functions in the patch file that are used to replace the original file. The functions of the original function, these multiple functions used to replace the original function in the original file are collectively referred to as patch functions.

In the embodiment of the present application, in the process of compiling to obtain the original file in the WebAssembly binary format, a compilation information table is generated, and the compilation information table records the function index of the original function in the original file; after compiling to obtain the patch file in the WebAssembly binary format In the process of compiling, a function correspondence table is generated according to the function index of the original function in the compilation information table and the function index of the patch function in the patch file, and the function correspondence table records the correspondence between the original function and the patch function; that is, from the compilation information table Obtain the function index of the original function from , obtain the function index of the patch function from the patch file, record the function index of the original function and the function index of the patch function in the function correspondence table, thereby generating the function correspondence table; During the process, a function index space will be generated. The function index space records the function address of the original function, and the function correspondence table records the corresponding relationship between the original function and the patch function. Therefore, the function address of the patch function can be obtained from the patch file, and then According to the correspondence between the original function and the patch function recorded in the function correspondence table, replace the function address of the original function in the function index space with the function address of the patch function; because in the function index space, the function address of the original function is replaced by the patch function The function address of the later function application is the patch function, so as to realize the function-level replacement and update of the WebAssembly application using the patch.

In a possible implementation manner, the functions in the patch file have one and only patch functions.

Specifically, the source code of the patch file contains only functions and modules that need to be patched in the original file, which means that any function in the patch file is a useful patch function, that is, the functions in the patch file are all patch functions.

In the embodiment of the present application, the functions in the patch file include and only the patch function, that is, any function in the patch file is a function that is beneficial to the patch, which is conducive to making the patch file smaller in size and required for downloading and loading. short time.

In a possible implementation manner, the replacing the function address of the original function in the function index space with the function address of the patch function according to the function correspondence table includes: judging whether or not according to the function correspondence table The patch function exists; if the patch function exists, obtain the function address of the patch function from the code segment of the patch file; replace the function address of the original function in the function index space with the The function address of the patch function described above.

Specifically, in the process of loading the function segment of the original file, it is judged whether there is a patch function according to the function correspondence table. When there is a patch function, the function address of the patch function is obtained from the code segment of the patch file, and the function address in the function index space is The function address of the original function is replaced with the function address of the patch function.

The loading process of each segment of WebAssembly is shown in Figure 4. The loading sequence of each segment is: type segment, import segment, function segment, table segment, memory segment, global segment, export segment, start segment, element segment, and code segment. , data segment.

Among them, the original loading process of the function segment of WebAssembly is shown in Figure 5, including the following steps:

501. Determine whether the number of loaded functions is less than the total number of functions. Among them, if the number of loaded functions is not less than the total number of functions, it means that all functions have been loaded, and the process of loading the function segment ends.

502. If the number of loaded functions is less than the total number of functions, obtain the function signature index from the function segment. That is, get the function signature index of a function that has not yet been loaded.

503. Obtain the function address of the function from the code segment. Among them, the function address of the function is obtained from the code segment through the function signature index.

504. Add the function to the function index space. That is, add the function signature, function address, etc. of the function to the function index space.

It should be understood that in the original loading process of the function segment of WebAssembly, for each function, information such as the function signature index is obtained from the function segment, and the first address (that is, the function address) of the corresponding function code block is obtained in the code segment, and the After all the data for the function is available, the function is added to the function index space.

The original loading process of the WebAssembly function segment is described above. In the scenario where the patch needs to be loaded, since the function interface needs to be kept consistent, the function name and function signature of the original function and the patch function are consistent, so only need to be corrected in the loading stage. The function address of the patch function in the function index space. The present application modifies the original loading process of the WebAssembly function segment, and corrects the function address of the patch function during the loading process of the function segment, thereby realizing the replacement of the original function by the patch function. The modified loading process of the WebAssembly function segment provided by the embodiment of the present application is shown in FIG. 6 , and includes the following steps:

601. Determine whether the number of loaded functions is less than the total number of functions. Among them, if the number of loaded functions is not less than the total number of functions, it means that all functions have been loaded, and the process of loading the function segment ends.

602. If the number of loaded functions is less than the total number of functions, obtain the function signature index from the function segment; that is, obtain the function signature index of the function that has not been loaded yet. It should be understood that a function signature is a general name of a function's function name, parameter list, and return type, and the function signature index includes a function index and the like.

603. Find a function corresponding table. The function correspondence table records the original function index and the function index of the patch function.

604. Determine whether a patch function exists. That is, according to the correspondence between the original function and the patch function recorded in the function correspondence table, it is judged whether there is a patch function; when the correspondence between the original function and the patch function is recorded in the function correspondence table, it means that there is a patch function; when the function corresponds to If the corresponding relationship between the original function and the patch function is not recorded in the table, it means that there is no patch function.

605. If the patch function does not exist, obtain the function address of the function from the code segment of the original file.

606. If the patch function exists, obtain the function address of the function from the code segment of the patch file.

607. Add the function to the function index space.

It should be noted that, in the loading process of the WebAssembly function segment provided by the embodiment of the present application, for each function, information such as the function signature index is obtained from the function segment of the original function (original file), which is consistent with the original loading of the WebAssembly function segment. The difference in the process is that this application adds the steps of identifying the patch function and correcting the address of the patch function. If the function needs to be replaced with a patch function, the first address of the corresponding function code block is obtained from the patch file code segment, otherwise, the original file code is still used. The first address of the corresponding function code block is obtained in the segment. Finally, after all the data of the function is obtained, the function address replacement has been completed, and the function is added to the function index space.

In the embodiment of the present application, during the loading process of the original file, the function address of the original function is obtained from the original file and added to the function index space; when patching is required, the function correspondence table can be used to determine whether the original function needs to be updated. Replace, when the corresponding relationship between the original function and the patch function is recorded in the function correspondence table, it indicates that the original function needs to be replaced with a patch function. In this way, it can be judged whether there is a patch function according to the function correspondence table. Obtain the function address of the patch function from the code segment of the file, and then replace the function address of the original function in the function index space with the function address of the patch function; in other words, instead of adding the function address of the original function to the function index space, The function address of the patch function is added to the function index space, thereby realizing the replacement of the original function by the patch function.

In a possible implementation manner, the compilation information table further records the size of the memory segment of the original file; the method further includes: during the compilation process of the patch file, obtaining from the compilation information table The size of the memory segment of the original file; the code segment of the patch file is compiled according to the size of the memory segment of the original file and the data offset of the patch function.

Wherein, when the patch function involves memory operation, the memory operation of the code segment of the patch file should be corrected; in this case, the size of the memory segment of the original file is also recorded in the compilation information table generated during the process of compiling the original file.

For example, suppose there are 6 functions in the original file, namely function A (the memory occupied in the memory segment is 0-100), function B (the memory occupied in the memory segment is 100-300), function C ( The memory occupied in the memory segment is 300-400), the function D (the memory occupied in the memory segment is 400-600), the function E (the memory occupied in the memory segment is 600-800), the function F (the memory occupied in the memory segment is 600-800) The memory occupied in the segment is 800-1200), so the memory segment size of the original file is 0-1200; assuming that function D needs to be replaced with function D', the data offset of function D' is 300, and function D' is occupied by The memory is arranged at 1200-1500, so the new data offset is 1200+300=1500, and the data offset 1500 is written to the code segment of the patch file.

In the embodiment of the present application, if the patch function involves a memory operation, the memory operation of the code segment of the patch file needs to be corrected; in this case, the compilation information table generated in the process of compiling the original file also records the original file In the process of compiling and obtaining the patch file, the memory segment size of the original file is obtained from the compilation information table, and the memory segment size of the original file and the data offset of the patch function are used as the new offset, and write Enter the code segment of the patch file, so that the patch function can perform memory operations normally.

In a possible implementation manner, the compilation information table further records a function index of a called function, and the called function is a function called by the original function; the method further includes: in the patch file During the compiling process, the function index of the called function is obtained from the compilation information table; the code segment of the patch file is compiled according to the function index of the called function.

It should be noted that when there is a function call in the original function, in the process of compiling the patch file, the relevant instruction code segment of the function call in the patch function needs to be corrected to ensure the correctness of the calling relationship between the functions. The function index of the called function of the original function to compile the code segment of the patch file.

In the embodiment of the present application, if the original function involves calling other functions, after the original function is replaced by the patch function, the patch function also involves calling the function originally called by the original function, and the code segment of the patch file needs to be corrected; this kind of In this case, the compilation information table also records the function index of the called function, and the called function is the function called by the original function; in the process of compiling to obtain the patch file, the function index of the called function is obtained from the compilation information table, and the The function index of the called function compiles the code segment written into the patch file, so that after replacing the original function with the patch function by means of a patch, the patch function can also call the function originally called by the original function.

In a possible implementation manner, the called function is a function directly called by the original function, the code segment of the patch file includes a direct calling instruction, and the direct calling instruction includes a function of the called function index.

When a function is called directly, the called function is located directly by the function index in the function index space, so the function index after the direct call instruction of the code segment needs to be updated.

Among them, the original compilation process of the WebAssembly code segment when the function is directly called is shown in Figure 7, including the following steps:

701. Obtain the function index (fun_id) of the called function during compilation.

702. Write the direct call instruction (call fun_id) into the code segment.

For example, when compiling the code segment of the original file, the flow shown in FIG. 7 can be executed.

It should be noted that the embodiment of the present application introduces a patch, so the compilation process of the code segment needs to be corrected. For the compilation of the patch file, the function index to be called is obtained from the compilation information table, and the code segment of the patch file is corrected. 8 is a schematic diagram of a post-correction compilation flow diagram of a code segment of WebAssembly when there is a direct invocation of a function provided by an embodiment of the present application, including the following steps:

801. Determine whether the file is a patch file. That is, it is determined whether the currently compiled file is a patch file.

802. If the file is not a patch file, obtain the function index (fun_id) of the called function during compilation. If the currently compiled file is not a patch file, that is, when the currently compiled file is the original file, the compilation process is the same as the original compilation process of the code segment.

803. If the file is a patch file, obtain the function index (fun_id) of the called function from the compilation information table.

804. Write the direct call instruction (call fun_id) into the code segment.

In the embodiment of the present application, if the called function is a function directly called by the original function, then after the original function is replaced by the patch function, the called function is also the function directly called by the patch function; in this case, the compilation information table The function index of the called function is also recorded; therefore, after obtaining the function index of the called function from the compilation information table, and writing the function index of the called function into the direct calling instruction of the code segment of the patch file, the patch function can be implemented. After directly calling the called function, after replacing the original function with the patch function by means of a patch, the patch function can also directly call the function originally called directly by the original function.

In a possible implementation manner, the compilation information table further records the function signature index of the called function and the element segment size of the original file; the called function is indirectly called by the original function function; the compiling the code segment of the patch file according to the function index of the called function includes: acquiring the function signature index of the called function from the compilation information table; according to the function index of the called function Index compiling the element segment of the patch file to obtain the element index of the called function; compiling the code segment of the patch file according to the element segment size of the original file and the element index of the called function, wherein, The code segment of the patch file includes an indirect call instruction, and the indirect call instruction includes a function signature index of the called function.

The compilation information table further includes a function signature index table, in which the function signature index of the called function is recorded; the compilation information table also includes the size of the element segment of the original file.

For the indirect call of a function, since the specific function to be called is not known at compile time, it can only be known at runtime. The called function is not located directly through the function index of the function index space, but is located from the table index space. Indirect positioning, so the element items in the element section need to be updated at compile time.

Among them, the original compilation process of the WebAssembly code segment when there is an indirect function call is shown in Figure 9, including the following steps:

901. Obtain the function index (fun_id) of the called function during compilation.

902. Obtain the function signature index (type_id) of the called function during compilation.

903. Write the function index (fun_id) of the called function into the element segment, and obtain the element index (elem_id) of the called function.

904. Write the element index (elem_id) of the called function into the code segment.

905. Write the indirect call instruction (call_indirent type_id) into the code segment.

It should be noted that the embodiment of the present application introduces a patch, so the compilation process of the code segment needs to be corrected. If the patch file is compiled, the function index of the called function is obtained from the function index table, the function signature index of the called function is obtained from the function signature index table, the size of the element segment is obtained, and the element segment and the code segment are modified at the same time. 10 is a schematic diagram of a post-correction compilation flow diagram of a code segment of WebAssembly when there is an indirect function call provided by an embodiment of the present application, including the following steps:

1001. Whether the file is a patch file. That is, it is determined whether the currently compiled file is a patch file.

1002. If the file is not a patch file, obtain the function index (fun_id) of the called function during compilation. If the currently compiled file is not a patch file, that is, when the currently compiled file is the original file, the compilation process is the same as the original compilation process of the code segment.

1003. If the file is not a patch file, obtain the function signature index (type_id) of the called function during compilation.

1004. If the file is a patch file, obtain the function index (fun_id) of the called function from the compilation information table.

1005. If the file is a patch file, obtain the function signature index (type_id) of the called function from the compilation information table.

1006. Write the function index (fun_id) of the called function into the element segment to obtain the element index (elem_id) of the called function.

1007. If the file is not a patch file, write the element index (elem_id) of the called function into the code segment.

1008. If the file is a patch file, write the element index (elem_id) and element segment size (table_size) of the called function into the code segment.

1009. Write the indirect call instruction (call_indirent type_id) into the code segment.

In the embodiment of the present application, if the called function is a function indirectly called by the original function, then after the original function is replaced by the patch function, the called function is also the function indirectly called by the patch function; in this case, the compilation information table It also records the function index of the called function, the function signature index of the called function, and the element segment size of the original file; obtains the function index of the called function from the compilation information table, and writes the function index of the called function into the patch file. Element segment, the element index of the called function can be obtained; obtain the element segment size of the original file from the compilation information table, and write the element segment size of the original file and the element index of the called function into the code segment of the patch file; from the compilation information The function signature index of the called function is obtained from the table, and after the function signature index of the called function is written into the indirect call instruction in the code segment of the patch file, the indirect call of the called function by the patch function can be realized. After replacing the original function with the patch function, the patch function can also indirectly call the function originally called indirectly by the original function.

In a possible implementation manner, the method further includes: during the loading process of the original file, acquiring the element index of the called function from the patch file; storing the element index of the called function It is added to the table index space, wherein the table index space is generated during the loading process of the original file.

In the embodiment of the present application, for indirect calls, since the specific function to be called is not known at compile time, it can only be known at runtime, and the called function is not a function of the called function in the function index space. The index is located directly, but indirectly through the table index space, which is generated by loading the original file; therefore, during the loading process of the original file, the element index of the called function needs to be obtained from the patch file, and will be The element index of the calling function is added to the table index space; in this way, at runtime, the patch function can obtain the element index of the called function from the table index space, and then locate the called function and indirectly call the called function .

In a possible implementation manner, the called function is a virtual machine import function; before acquiring the function index of the called function from the compilation information table, the method further includes: generating the The function index of the called function; the function index of the called function is added to the compilation information table.

Wherein, if the called function is a virtual machine import function, a new function index needs to be generated and added to the function index table in the compilation information table. If the called function is not a virtual machine imported function, the function index of the called function is already in the function index table.

In the embodiment of the present application, the called function is a virtual machine import function, and the compilation information table generated during the process of compiling the original file does not record the function index of the called function, so it is necessary to generate the function index of the called function, and The function index of the called function is added to the compilation information table, so as to facilitate the implementation of the patch function to call the called function.

In a possible implementation manner, the method further includes: during the loading process of the original file, adding the called function to the function index space through an import section of the original file.

In the embodiment of the present application, the called function is a virtual machine import function, so the function index space generated during the loading process of the original file does not have the called function. Therefore, the called function needs to be added to the import section of the original file. in the function index space, so that the called function exists in the function index space; thus, it is beneficial to realize that the patch function calls the called function.

The technical solutions provided by the present application are described below through specific examples.

Example 1

Example 1 is an application scenario of this application. In order to upgrade or repair the WebAssembly application, the function in the existing WebAssembly application file compute.wasm needs to be replaced. Taking the calculation function compute as an example, the function implementation is replaced by a-b with a+b. The specific technical solution of Example 1 is as follows:

Step 1. Compile

The compilation process is shown in Figure 11.

1. Use the application source file main.c and compile it into the WebAssembly binary format file main.wasm through the compiler tool chain; among them, main.wasm is the original file. Optionally, translate the wasm binary format into wat text format, so that the WebAssembly binary format file main.wasm is readable, as shown in Figure 11.

1) The type segment contains two types of function signatures. In FIG. 11, they correspond to (type(;0;)(func(param i32i32)(result i32))) and (type(;1;)(func(result i32))), respectively.

2) The function section contains two functions, the function indexes are 0 and 1 respectively, and the function name has been discarded in the compilation stage. That is, func(;0;) and func(;1;) in FIG. 11 .

2. Generate and export the compilation information table during the compilation process; in example 1, record the correspondence between each function and function index in the source code, generate and export the function index table, and other structures of the compilation information table are introduced in subsequent examples . The function index table is shown in Figure 11, and the structure is explained as follows:

1) Function index: The index assigned by the compiler to each function during the compilation process is related to the compilation order.

2) Function name: The actual function name corresponding to the function index in the WebAssembly file.

It can be seen that the function index table corresponding to main.wasm contains two items, which are the No. 0 function compute and No. 1 function main. Among them, according to the compilation order, index 0 corresponds to func(;0;), compute in example 1; index 1 corresponds to func(;1;), main in example 1.

Step 2: Make a patch

The process of making a patch is shown in Figure 12.

1. According to the function index table exported in step 1, query the function index corresponding to the original function in the function index table. For example, in this example, the function compute needs to be replaced. By querying the function index table, we can see that the function index corresponding to the compute function is 0.

2. In the process of compiling the patch function file (patch.c) into the WebAssembly binary format file patch.wasm, there are two ways to record the correspondence between the function in the original file and the function in the patch file; among them, patch.wasm is the patch document.

1) Keep the content of the function section of the original file and the function section of the patch file consistent, as this method will increase the size of the patch file. That is, the functions in the original file refer to compute and main, and the functions in the patch file are still compute and main. Compute is to be patched and changed, and main remains unchanged. This refers to the fact that compute and main are maintained in the patch file, and both are regenerated. In fact, main is redundant.

2) A function correspondence table is generated using the function index of the original function in the function index table and the function index of the patch function in the patch file, so as to obtain the correspondence between the old and new functions. In this application, an index is added to the changed part in WebAssembly, and the original reference to the old function is modified and replaced with the updated part in the patch, so there is a changed function correspondence table, and the transformed function correspondence table contains the function index of the original function and Correspondence of the function index of the patch function. This implementation is adopted below.

Step 3. Load

Taking the compute function as an example, as shown in Figure 13, when the original file main.wasm is parsed and loaded, the compute function needs to be replaced with the compute function in the patch file. If the function address of the compute function is obtained from the code segment of the original file, the address is 0x08020000 ;If the patch file is loaded and the function address of the compute function is obtained from the code block of the patch file, the address 0x08020200 is obtained, and the address 0x08020000 of the original function compute{a-b} is replaced with the address 0x08020200 of the patch function compute{a+b}, and the function address is replaced Finish. It should be understood that the first address of the compute() function can be obtained from either main.wasm or patch.wasm. The reference to the compute function is replaced here, the new compute function and the original main in the patch file patch.wasm The compute functions of .wasm are all there, but the call point is changed to achieve the effect of replacement.

Using this example, the WebAssembly application can be updated with a small patch file without affecting the officially released application version, so that lightweight and fast WebAssembly application upgrades and application bug fixes can be achieved. Realize the upgrade and update of WebAssembly applications or repair application defects, create and load patches for the WebAssembly format, record and export the function index table in the compilation stage, obtain the function index of the original function, and compile the patch file with the patch function, when loading the application. , replace the function address of the original function with the function address of the patch function, thus realizing the replacement and update of the patch function level.

Example 2

Example 2 is another application scenario of this application. The difference between Example 2 and Example 1 is that there is a case of operating memory in the patch function. Taking the function compute as an example, a new array needs to be declared and assigned a value in the function implementation. The specific technical solution of Example 2 is as follows:

Step 1. Compile

The compilation process adds steps to the compilation process of Example 1.

1. Use the application source file main.c and compile it into the WebAssembly binary format file main.wasm through the compiler tool chain.

2. Generate and export the compilation information table during the compilation process. The compilation information table includes the following structure:

1) Function index table: Record the correspondence between each function and function index in the application code during the compilation process, and generate and export the function index table.

2) Memory segment size: Record the size of the memory segment during the compilation process, and export the memory segment size.

Step 2: Make a patch

The process of making a patch adds steps to the process of making a patch in Example 1, as shown in Figure 14.

1. According to the function index table exported in step 1, query the function index corresponding to the original function in the function index table.

2. In the process of compiling the patch function file (patch.c) into the WebAssembly binary format file patch.wasm, it is necessary to correct the relevant instruction code segment for operating the memory in the patch function to ensure the correctness of the operating memory.

The specific process is as follows: The used memory segment size can be known from the compilation information table. When compiling the patch file, the offset of the patch file (or patch function) plus the used memory segment size is used as the new offset to correct the operation. Memory-related instructions, the code segment that writes the patch file. It should be understood that because the size of the data memory is modified in the patch, the size of the data segment needs to be expanded so that the new patch function can operate on new data, while the old version can still operate its own data. Here the new data offset is no longer indexed from 0, but starts from the end of the old data segment (used memory data segment), so "new offset = offset + used memory segment size".

3. In the process of compiling the patch function file into the WebAssembly binary format file patch.wasm, use the function index of the original function in the function index table and the function index of the patch function in the patch file to generate a function correspondence table, so as to obtain the correspondence between the old and new functions. .

Step 3. Load

The loading process adds steps to the loading process of Example 1. The data segment in the patch file is additionally loaded into the linear memory space, and the offset is the size of the used memory segment.

Using this example, the WebAssembly application can be updated with a small patch file without affecting the officially released application version, so that lightweight and fast WebAssembly application upgrades and application bug fixes can be achieved. For the scenario of linear memory operation in the patch function, the correct replacement of the patch function is realized through the processing in the compilation and loading stages. Realize the upgrade and update of WebAssembly applications or repair application bugs, create and load patches for the WebAssembly format, and obtain the function index and memory segment size of the original function by recording and exporting compilation information during the compilation phase, including the function index table and memory segment size. , because the patch function involves memory operations, the memory operation of the code segment is corrected, and the patch function is compiled into a WebAssembly patch file. When loading the application, replace the function address of the original function with the function address of the patch function to load.

Example 3

Example 3 is a more complex application scenario of the application. The difference between Example 3 and Example 1 is that other functions are called in the patch function. Taking the function compute as an example, the directly calling function add needs to be replaced in the function implementation. To directly call the function sub, replace the indirect call function sub with the indirect call function add. Example 3 The specific technical solutions are as follows:

Step 1. Compile

The compilation process adds steps to the compilation process of Example 1, as shown in FIG. 15 .

1. Use the application source file main.c and compile it into the WebAssembly binary format file main.wasm through the compiler tool chain. Optionally, translate the wasm binary format to wat text format to make the WebAssembly binary format file main.wasm readable, as shown in Figure 15:

The table segment contains one element, which is a function reference, which is the function reference corresponding to function index 1, which is used for function indirect call. Here, an address reference space is actually reserved in the table segment, which dynamically saves the value of p, but the default is sub; when the statement "p=sub" is executed {local.get 0; call_indirect(type0)}, wasm puts The address of sub is written into table segment reference index 1, and then, "int ret=(*p)(a,b)" reads the address of the indirect call to be executed from reference index 1, that is, sub, and the function calls the sub function.

2. Generate and export the compilation information table during the compilation process. The compilation information table includes the following structure:

1) Function index table: Record the correspondence between each function and function index during the compilation process, and generate and export the function index table.

2) Function signature index table: record the correspondence between each function signature and function signature index during the compilation process, and generate and export the function signature index table. The function signature index table structure includes:

Function Signature Index: The index assigned by the compiler to each function signature during compilation.

Function signature: The function signature type corresponding to the function signature index in the type section of the WebAssembly file.

3) Element segment size: The element segment size is recorded during the compilation process, and the element segment size is derived.

4) Memory segment size: Record the size of the memory segment during the compilation process, and export the memory segment size.

Step 2: Make a patch

The process of making a patch adds steps to the process of making a patch in Example 1, as shown in Figure 16.

1. If the called function is a virtual machine import function, a new function index is generated and added to the function index table.

2. According to the function index table exported in step 1, query the function index corresponding to the original function in the function index table. For example, in this example, the function compute needs to be replaced. By querying the function index table, we can see that the function index corresponding to the compute function is 2.

3. In the process of compiling the patch function file (patch.c) into the WebAssembly binary format file patch.wasm, it is necessary to correct the relevant instruction code segment of the function call in the patch function to ensure the correctness of the calling relationship between functions. For different function calling methods, the specific process is as follows:

Direct call: The called function is located directly by the function index in the function index space, so the function index after the code segment call instruction needs to be updated, as shown in Figure 7 and Figure 8. If the patch file is compiled, the function index of the called function is obtained from the function index table, and the code segment is corrected.

Indirect call: Since the specific function to be called is not known at compile time and can only be known at runtime, the called function is not directly located through the function index of the function index space, but indirectly located from the table index space. Therefore, the element items in the element segment need to be updated, as shown in Figure 9 and Figure 10. If the patch file is compiled, the called function index is obtained from the function index table, the function signature index of the called function is obtained from the function signature index table, the size of the element segment is obtained, and the element segment and the code segment are modified at the same time.

4. In the process of compiling the patch function file (patch.c) into the WebAssembly binary format file patch.wasm, use the function index of the original function in the function index table and the function index of the patch function in the patch file to generate the function correspondence table, so as to obtain Correspondence between old and new functions.

Step 3. Load

The loading process adds steps to the loading process of Example 1.

1. For the patch function:

Correct the patch function code address in the function index space according to the loading steps of Example 1, that is, replace the function address of the original function with the function address of the patch function.

2. For other functions called in the patch function:

If the called function is a virtual machine import function, first add the called function from the import segment of the patch function to the function index space, and then perform different steps for different function calling methods. The specific process is as follows:

Direct call: The called function is located directly through the function index in the function index space. The function index after the call instruction in the code segment has been corrected in the pre-compilation stage, and the function address of the called function has not changed, so it can be guaranteed that the function Correctness of direct calls.

Indirect call: Since the specific function to be called is not known at compile time and only known at runtime, the called function is not directly located by the function index in the function index space, but indirectly located from the table index space . Therefore, in the process of obtaining the table index space from the original file, it is necessary to modify the function reference and add the corresponding element item in the table index space. As shown in Figure 17, the index of the newly added item in the table index space is the element segment size of the original file. and the sum of the element indices of the patch file.

Using this example, the WebAssembly application can be updated with a small patch file without affecting the officially released application version, so that lightweight and fast WebAssembly application upgrades and application bug fixes can be achieved. For the scenario of calling other functions in the patch function, the correct replacement of the patch function is realized through the processing in the compilation and loading stages. Realize the upgrade and update of WebAssembly applications or repair application defects, create and load patches for the WebAssembly format, record and export the compilation information table in the compilation stage, including the function index table, function signature index table and element segment size, obtain the original function's size. Function index, function signature index, and element segment size. Because the patch function involves other function calls, the code segment is revised based on the exported compilation information table, and the patch function is compiled into a WebAssembly patch file. When loading the application, for the patch function, replace the original function address with the patch function address. For other functions called in the patch function, different calling methods of the functions are processed, thereby realizing the replacement and update of the patch function level.

Please refer to FIG. 18. FIG. 18 is a schematic structural diagram of a patch device provided by an embodiment of the present application. The patch device 1800 may include a processing unit 1801 and a communication unit 1802, wherein the processing unit 1801 is used to execute the steps shown in FIGS. In any step in the method embodiment shown in FIG. 12, and when performing data transmission such as acquisition, the communication unit 1802 can be selectively invoked to complete the corresponding operation. A detailed description will be given below.

The processing unit 1801 is configured to: in the process of compiling the original file, generate a compilation information table, wherein the original file is a file in the WebAssembly binary format, and the compilation information table records the function index of the original function, and the original function is the function in the original file; during the compilation process of the patch file, a function correspondence table is generated according to the compilation information table, wherein the patch file is a file in the WebAssembly binary format, and the function correspondence table records the The corresponding relationship between the original function and the patch function, the patch function is a function in the patch file; during the loading process of the original file, the function of the original function in the function index space is converted according to the function corresponding table. The address is replaced with the function address of the patch function, wherein the function index space is generated during the loading process of the original file.

In a possible implementation manner, the functions in the patch file have one and only patch functions.

In a possible implementation manner, the processing unit 1801 is specifically configured to: determine whether the patch function exists according to the function correspondence table; if the patch function exists, obtain from the code segment of the patch file The function address of the patch function; replace the function address of the original function in the function index space with the function address of the patch function.

In a possible implementation manner, the compilation information table further records the size of the memory segment of the original file; the processing unit 1801 is further configured to: in the process of compiling the patch file, from the compilation information The size of the memory segment of the original file is obtained from the table; the code segment of the patch file is compiled according to the size of the memory segment of the original file and the data offset of the patch function.

In a possible implementation manner, the compilation information table further records the function index of the called function, and the called function is the function called by the original function; the processing unit 1801 is further configured to: During the compilation process of the patch file, the function index of the called function is obtained from the compilation information table; the code segment of the patch file is compiled according to the function index of the called function.

In a possible implementation manner, the called function is a function directly called by the original function, the code segment of the patch file includes a direct calling instruction, and the direct calling instruction includes a function of the called function index.

In a possible implementation manner, the compilation information table further records the function signature index of the called function and the element segment size of the original file; the called function is indirectly called by the original function The processing unit 1801 is specifically configured to: obtain the function signature index of the called function from the compilation information table; compile the element segment of the patch file according to the function index of the called function to obtain the the element index of the called function; compile the code segment of the patch file according to the element segment size of the original file and the element index of the called function, wherein the code segment of the patch file includes an indirect call instruction, so The indirect call instruction includes a function signature index of the called function.

In a possible implementation manner, the processing unit 1801 is further configured to: during the loading process of the original file, obtain the element index of the called function from the patch file; The element index of is added to the table index space, wherein the table index space is generated during the loading process of the original file.

In a possible implementation manner, the called function is a virtual machine import function; the processing unit 1801 is further configured to: before obtaining the function index of the called function from the compilation information table; generating a function index of the called function; adding the function index of the called function to the compilation information table.

In a possible implementation manner, the processing unit 1801 is further configured to: during the loading process of the original file, add the called function to the function index space through the import segment of the original file .

Wherein, the patch device 1800 may further include a storage unit 1803 for storing program codes and data of the terminal. The processing unit 1801 may be a processor, the communication unit 1802 may be a transceiver, and the storage unit 1803 may be a memory.

It should be noted that, the implementation of each unit may also correspond to the corresponding description with reference to the method embodiments shown in FIG. 3 to FIG. 17 .

The patch device 1800 described in FIG. 18 generates a compilation information table in the process of compiling to obtain the original file in the WebAssembly binary format, and the compilation information table records the function index of the original function in the original file; In the process of patching the file, a function correspondence table is generated according to the function index of the original function in the compilation information table and the function index of the patch function in the patch file, and the function correspondence table records the correspondence between the original function and the patch function; The function index of the original function is obtained from the information table, the function index of the patch function is obtained from the patch file, and the function index of the original function and the function index of the patch function are associated and recorded in the function correspondence table, thereby generating the function correspondence table; During the file process, a function index space will be generated. The function index space records the function address of the original function, and the function correspondence table records the corresponding relationship between the original function and the patch function. Therefore, the function address of the patch function can be obtained from the patch file. , and then replace the function address of the original function in the function index space with the function address of the patch function according to the correspondence between the original function and the patch function recorded in the function correspondence table; because in the function index space, the function address of the original function is replaced by The function address of the patch function. The function executed when the function is applied later is the patch function, so that the WebAssembly application can be replaced and updated at the function level using the patch.

Please refer to FIG. 19. FIG. 19 is a schematic structural diagram of a patch device provided by an embodiment of the present application. The patch device 1910 includes a transceiver 1911, a processor 1912, and a memory 1913. The transceiver 1911, the processor 1912 and the The memories 1913 are connected to each other through a bus 1914 .

The memory 1913 includes, but is not limited to, random access memory (RAM), read-only memory (ROM), erasable programmable read only memory (EPROM), or portable Read-only memory (compact disc read-only memory, CD-ROM), the memory 1913 is used for related instructions and data.

The transceiver 1911 is used to receive and transmit data.

The processor 1912 may be one or more central processing units (central processing units, CPUs). In the case where the processor 1912 is a CPU, the CPU may be a single-core CPU or a multi-core CPU.

The processor 1912 in the patch device 1910 is configured to read the program code stored in the memory 1913, and perform the following operations: in the process of compiling the original file, generate a compilation information table, wherein the original file is a WebAssembly binary Format file, the compilation information table records the function index of the original function, and the original function is the function in the original file; during the compilation process of the patch file, a function correspondence table is generated according to the compilation information table, wherein , the patch file is a file in the WebAssembly binary format, the function correspondence table records the correspondence between the original function and the patch function, and the patch function is the function in the patch file; in the loading of the original file In the process, the function address of the original function in the function index space is replaced with the function address of the patch function according to the function correspondence table, wherein the function index space is generated during the loading process of the original file.

It should be noted that the implementation of each operation may also correspond to the corresponding description of the method embodiments described with reference to FIG. 3 to FIG. 17 .

The patch device 1910 described in FIG. 19 generates a compilation information table in the process of compiling to obtain the original file in the WebAssembly binary format, and the compilation information table records the function index of the original function in the original file; In the process of patching the file, a function correspondence table is generated according to the function index of the original function in the compilation information table and the function index of the patch function in the patch file, and the function correspondence table records the correspondence between the original function and the patch function; The function index of the original function is obtained from the information table, the function index of the patch function is obtained from the patch file, and the function index of the original function and the function index of the patch function are associated and recorded in the function correspondence table, thereby generating the function correspondence table; During the file process, a function index space will be generated. The function index space records the function address of the original function, and the function correspondence table records the corresponding relationship between the original function and the patch function. Therefore, the function address of the patch function can be obtained from the patch file. , and then replace the function address of the original function in the function index space with the function address of the patch function according to the correspondence between the original function and the patch function recorded in the function correspondence table; because in the function index space, the function address of the original function is replaced by The function address of the patch function. The function executed when the function is applied later is the patch function, so that the WebAssembly application can be replaced and updated at the function level using the patch.

The embodiment of the present application further provides a chip, the chip includes at least one processor, a memory and an interface circuit, the above-mentioned memory, the above-mentioned transceiver and the above-mentioned at least one processor are interconnected through a line, and the above-mentioned at least one memory stores a computer program; the above-mentioned When the computer program is executed by the above-mentioned processor, the method flow shown in the above-mentioned method embodiment is realized.

Embodiments of the present application further provide a computer-readable storage medium, where a computer program is stored in the computer-readable storage medium, and when the computer program is executed on an electronic device, the method flow shown in the foregoing method embodiments is realized.

The embodiments of the present application further provide a computer program, when the computer program is executed on an electronic device, the method flow shown in the above method embodiments can be realized.

It should be understood that the processor mentioned in the embodiments of the present application may be a central processing unit (Central Processing Unit, CPU), and may also be other general-purpose processors, digital signal processors (Digital Signal Processors, DSP), application specific integrated circuits (Application Specific Integrated Circuits) Integrated Circuit, ASIC), off-the-shelf Programmable Gate Array (Field Programmable Gate Array, FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like.

It should also be understood that the memory mentioned in the embodiments of the present application may be volatile memory or non-volatile memory, or may include both volatile and non-volatile memory. Wherein, the non-volatile memory may be Read-Only Memory (ROM), Programmable Read-Only Memory (PROM), Erasable Programmable Read-Only Memory (Erasable PROM, EPROM), Erase programmable read-only memory (Electrically EPROM, EEPROM) or flash memory. The volatile memory may be random access memory (RAM), which is used as an external cache. By way of example and not limitation, many forms of RAM are available, such as Static RAM (SRAM), Dynamic RAM (DRAM), Synchronous DRAM, SDRAM), double data rate synchronous dynamic random access memory (Double DataRate SDRAM, DDR SDRAM), enhanced synchronous dynamic random access memory (Enhanced SDRAM, ESDRAM), synchronous link dynamic random access memory (Synchlink DRAM, SLDRAM) And direct memory bus random access memory (Direct Rambus RAM, DR RAM).

It should be noted that when the processor is a general-purpose processor, DSP, ASIC, FPGA or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components, the memory (storage module) is integrated in the processor.

It should be noted that the memory described in this specification is intended to include, but not be limited to, these and any other suitable types of memory.

It should be understood that, in various embodiments of the present application, the size of the sequence numbers of the above-mentioned processes does not mean the sequence of execution, and the execution sequence of each process should be determined by its functions and internal logic, and should not be dealt with in the embodiments of the present application. implementation constitutes any limitation.

Those of ordinary skill in the art can realize that the units and algorithm steps of each example described in conjunction with the embodiments disclosed in this specification can be implemented by electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Skilled artisans may implement the described functionality using different methods for each particular application, but such implementations should not be considered beyond the scope of this application.

Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working process of the above-described systems, devices and units may refer to the corresponding processes in the foregoing method embodiments, which will not be repeated here.

In the several embodiments provided in this application, it should be understood that the disclosed system, apparatus and method may be implemented in other manners. For example, the apparatus embodiments described above are only illustrative. For example, the division of the above units is only a logical function division. In actual implementation, there may be other division methods. For example, multiple units or components may be combined or may be Integration into another system, or some features can be ignored, or not implemented. On the other hand, the shown or discussed mutual coupling or direct coupling or communication connection may be through some interfaces, indirect coupling or communication connection of devices or units, and may be in electrical, mechanical or other forms.

The units described above as separate components may or may not be physically separated, and components shown as units may or may not be physical units, that is, may be located in one place, or may be distributed to multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution in this embodiment.

In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically alone, or two or more units may be integrated into one unit.

If the above functions are implemented in the form of software functional units and sold or used as independent products, they may be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application can be embodied in the form of a software product in essence, or the part that contributes to the prior art or the part of the technical solution. The computer software product is stored in a storage medium, including Several instructions are used to cause a computer device (which may be a personal computer, a server, or a patch device, etc.) to execute all or part of the steps of the above-mentioned methods in various embodiments of the present application. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (Read-Only Memory, ROM), random access memory (Random Access Memory, RAM), magnetic disk or optical disk and other media that can store program codes .

The steps in the method of the embodiment of the present application may be adjusted, combined and deleted in sequence according to actual needs. In addition, for terms and explanations in each embodiment of the present application, reference may be made to corresponding descriptions in other embodiments.

The modules in the apparatus of the embodiment of the present application may be combined, divided and deleted according to actual needs.

As described above, the above embodiments are only used to illustrate the technical solutions of the present application, but not to limit them; although the present application has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand: The technical solutions described in the embodiments are modified, or some technical features thereof are equivalently replaced; and these modifications or replacements do not make the essence of the corresponding technical solutions depart from the scope of the technical solutions of the embodiments of the present application.

Claims (23)

1. A patching method, comprising:

generating a compiling information table in the compiling process of an original file, wherein the original file is a file in a WebAssembly binary format, the compiling information table records a function index of an original function, and the original function is a function in the original file;

generating a function corresponding table according to the compiling information table in the compiling process of the patch file, wherein the patch file is a file in a WebAssembly binary format, the function corresponding table records the corresponding relation between the original function and the patch function, and the patch function is a function in the patch file;

and in the loading process of the original file, replacing the function address of the original function in a function index space with the function address of the patch function according to the function corresponding table, wherein the function index space is generated in the loading process of the original file.

2. The method of claim 1, wherein the functions in the patch file are patch functions and only patch functions.

3. The method according to claim 1 or 2, wherein the replacing the function address of the primitive function in the function index space with the function address of the patch function according to the function correspondence table comprises:

judging whether the patch function exists according to the function corresponding table;

if the patch function exists, acquiring a function address of the patch function from the code segment of the patch file;

and replacing the function address of the original function in the function index space with the function address of the patch function.

4. The method according to any one of claims 1 to 3, wherein the compiling information table further records a memory segment size of the original file; the method further comprises the following steps:

in the compiling process of the patch file, acquiring the memory segment size of the original file from the compiling information table;

and compiling the code segment of the patch file according to the size of the memory segment of the original file and the data offset of the patch function.

5. The method according to any one of claims 1 to 4, wherein the compilation information table further records a function index of a called function, the called function being a function called by the primitive function; the method further comprises the following steps:

in the compiling process of the patch file, acquiring a function index of the called function from the compiling information table;

and compiling the code segment of the patch file according to the function index of the called function.

6. The method as recited in claim 5, wherein the called function is a function directly called by the primitive function, and wherein the code segment of the patch file includes a direct call instruction including a function index of the called function.

7. The method according to claim 5, wherein the compilation information table further records a function signature index of the called function, and an element segment size of the original file; the called function is a function indirectly called by the original function; the code segment for compiling the patch file according to the function index of the called function comprises:

acquiring a function signature index of the called function from the compiling information table;

compiling the element segment of the patch file according to the function index of the called function to obtain the element index of the called function;

compiling the code segment of the patch file according to the element segment size of the original file and the element index of the called function, wherein the code segment of the patch file comprises an indirect call instruction, and the indirect call instruction comprises a function signature index of the called function.

8. The method of claim 7, further comprising:

in the loading process of the original file, acquiring an element index of the called function from the patch file;

and adding the element index of the called function into a table index space, wherein the table index space is generated in the loading process of the original file.

9. The method of any of claims 5-8, wherein the called function is a virtual machine import function; before the obtaining the function index of the called function from the compiling information table, the method further comprises:

generating a function index of the called function;

adding a function index of the called function to the compilation information table.

10. The method of claim 9, further comprising:

and in the loading process of the original file, adding the called function to the function index space through the import section of the original file.

11. A patch device, the device comprising a processing unit configured to:

generating a compiling information table in the compiling process of an original file, wherein the original file is a file in a WebAssembly binary format, the compiling information table records a function index of an original function, and the original function is a function in the original file;

generating a function corresponding table according to the compiling information table in the compiling process of the patch file, wherein the patch file is a file in a WebAssembly binary format, the function corresponding table records the corresponding relation between the original function and the patch function, and the patch function is a function in the patch file;

and in the loading process of the original file, replacing the function address of the original function in a function index space with the function address of the patch function according to the function corresponding table, wherein the function index space is generated in the loading process of the original file.

12. The apparatus of claim 11, wherein the function in the patch file is and only has a patch function.

13. The apparatus according to claim 11 or 12, wherein the processing unit is specifically configured to:

judging whether the patch function exists according to the function corresponding table;

if the patch function exists, acquiring a function address of the patch function from the code segment of the patch file;

and replacing the function address of the original function in the function index space with the function address of the patch function.

14. The apparatus according to any of claims 11-13, wherein the compiling information table further records a memory segment size of the original file; the processing unit is further to:

in the compiling process of the patch file, acquiring the memory segment size of the original file from the compiling information table;

and compiling the code segment of the patch file according to the size of the memory segment of the original file and the data offset of the patch function.

15. The apparatus according to any one of claims 11-14, wherein the compilation information table further records a function index of a called function, the called function being a function called by the primitive function; the processing unit is further to:

acquiring a function index of the called function from the compiling information table in the compiling process of the patch file;

and compiling the code segment of the patch file according to the function index of the called function.

16. The apparatus of claim 15, wherein the called function is a function directly called by the primitive function, and wherein the code segment of the patch file comprises a direct call instruction, and wherein the direct call instruction comprises a function index of the called function.

17. The apparatus according to claim 15, wherein the compilation information table further records a function signature index of the called function, and an element segment size of the original file; the called function is a function indirectly called by the original function; the processing unit is specifically configured to:

acquiring a function signature index of the called function from the compiling information table;

compiling the element segment of the patch file according to the function index of the called function to obtain the element index of the called function;

compiling the code segment of the patch file according to the element segment size of the original file and the element index of the called function, wherein the code segment of the patch file comprises an indirect call instruction, and the indirect call instruction comprises a function signature index of the called function.

18. The apparatus of claim 17, wherein the processing unit is further configured to:

in the loading process of the original file, acquiring an element index of the called function from the patch file;

and adding the element index of the called function into a table index space, wherein the table index space is generated in the loading process of the original file.

19. The apparatus according to any of claims 15-18, wherein the called function is a virtual machine import function; the processing unit is further to:

before the obtaining of the function index of the called function from the compiling information table;

generating a function index of the called function;

adding a function index of the called function to the compilation information table.

20. The apparatus of claim 19, wherein the processing unit is further configured to:

and in the loading process of the original file, adding the called function to the function index space through the import section of the original file.

21. A patch device comprising a processor, a memory, a communication interface, and one or more programs stored in the memory and configured for execution by the processor, the programs including instructions for performing the steps of the method of any of claims 1-10.

22. A chip, comprising: a processor for calling and running a computer program from a memory so that a device on which the chip is installed performs the method of any one of claims 1-10.

23. A computer-readable storage medium, characterized in that it stores a computer program for electronic data exchange, wherein the computer program causes a computer to perform the method according to any one of claims 1-10.

Images