WO2016000550A1

WO2016000550A1 - Binary translation execution method and apparatus for shared libraries

Info

Publication number: WO2016000550A1
Application number: PCT/CN2015/082127
Authority: WO
Inventors: 王振江; 武成岗; 张洪娟
Original assignee: 华为技术有限公司
Priority date: 2014-06-30
Filing date: 2015-06-23
Publication date: 2016-01-07
Also published as: CN105335203B; CN105335203A

Abstract

Disclosed are a binary translation execution method and apparatus for shared libraries. The binary translation execution method for shared libraries may comprise: when a first function in a second shared library is called, a host executes the first function to call a translation function in a first shared library; the host translates a second function, having the same function interface as that of the first function, in a third shared library by using the called translation function in the first shared library, so as to obtain a third function supported by the host, a function interface of the third function being the same as the function interface of the second function; and the host executes the third function. The solution provided in embodiments of the present invention helps to reduce the amount of relevant code translation in shared library translation, and thus increases execution efficiency of binary translation and improves user experience.

Description

Binary translation execution method and device of shared library

Technical field

The present invention relates to the field of computer technologies, and in particular, to a binary translation execution method and apparatus for a shared library.

Background technique

The computer architecture is constantly evolving, and new processors that adapt to different needs are constantly emerging. When a new processor is produced, the lack of software resources is an important factor hindering its forward development. Older general-purpose processors have a wealth of software resources, but their binary programs can only run on this instruction set architecture platform. In this context, it is increasingly important to port the executable code to the new processor in the original architecture, and binary translation technology has emerged in this situation.

Among them, Binary Translation (BT) technology is an important technology for code migration across ISA Instruction Set Architecture. Usually BT technology is used in translation source platform (also called guest). a shared library, usually in the binary form supported by the source platform, the shared library and the main program dependent on the shared library and all other shared libraries that the main program depends on as input (even if the target platform already has a corresponding main program) By translating the input information, a corresponding shared library that can be run on the target platform (also called a host) and a main program that depends on the shared library and all other shared libraries that the main program depends on are obtained. Due to the wide application of binary translation technology, the industry has begun to conduct in-depth research.

The prior art binary translation system usually performs binary translation of the shared library supported by the client and the main program that depends on the shared library and all other shared libraries that the main program depends on to obtain a corresponding share that can be run on the host. The library and the main program that depends on the shared library and all other shared libraries that the main program depends on. However, the amount of code that the existing binary translation system needs to translate may sometimes be large, which may bring a large amount to the binary translation system. Work load, which in turn may affect the user experience.

Summary of the invention

Embodiments of the present invention provide a binary translation execution method and apparatus for a shared library, in anticipation of reducing The amount of relevant code translation when translating the library, thereby improving the efficiency of binary translation execution, thereby improving the user experience.

A first aspect of the present invention provides a binary translation execution method of a shared library, where the method is applied to a host, where the host includes a first shared library supported by the host, and a second share supported by the host. a third shared library supported by the library and the client, the first shared library including a translation function, the host and the client supporting different instruction set architectures,

The method includes:

When the first function in the second shared library is called, the host executes the first function to invoke a translation function in the first shared library;

The host machine translates a function function in the third shared library with a second function function of the first function by using a translation function in the first shared library of the call to obtain a second function a third function supported by the host; wherein a function interface of the third function and a function interface of the second function are the same;

The host executes the third function.

With reference to the first aspect, in a first possible implementation manner of the first aspect, the host machine further includes a fifth shared library supported by the host; if the second function includes calling the client support The instruction of the fourth function in the fourth shared library, the step of translating the second function, further includes:

The host translates, by the second function, an instruction that calls a fourth function in the fourth shared library into an instruction that invokes a fifth function in the fifth shared library, wherein the fourth The function has the same function as the function of the fifth function, or the function functions and function interfaces of the fourth function and the fifth function are the same.

With reference to the first aspect, in a second possible implementation manner of the first aspect, the host machine further includes a fifth shared library supported by the host, when the third function invokes the client support When the fourth function in the fourth shared library, the method further includes:

Transmitting, by the host machine, an instruction of the third function included in the third function that is called by the third function to the third function in the fifth shared library An instruction; wherein the functions of the fourth function and the fifth function are the same, or the function functions and function interfaces of the fourth function and the fifth function are the same.

In conjunction with the first aspect or the first possible implementation of the first aspect or the second possible implementation of the first aspect, in a third possible implementation of the first aspect,

The host machine further includes a second main program supported by the host, if the second function includes an instruction to invoke a sixth function in the first main program supported by the client, to the second function The steps to translate include:

The host translating, by the second function, the instruction that invokes the sixth function in the first main program supported by the client into an instruction that invokes the seventh function in the second main program, The functions of the sixth function and the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same.

With reference to the first aspect, or the first possible implementation manner of the first aspect, or the second possible implementation manner of the first aspect, in a fourth possible implementation manner of the first aspect, The second main program supported by the host, when the third function calls the sixth function in the first main program supported by the client, the method further includes:

The host translates, by the third function, an instruction that calls a sixth function in the first main program supported by the client into a third function, and invokes a seventh function in the second main program. And the functions of the sixth function and the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same.

Combining the first aspect or the first possible implementation of the first aspect or the second possible implementation of the first aspect or the third possible implementation of the first aspect or the fourth possible implementation of the first aspect Embodiment, in a fifth possible implementation manner of the first aspect, when the second function includes a function pointer of a tenth function supported by the client as an incoming parameter, to invoke the host support The invoking instruction of the eighth function, the step of translating the second function, further comprising: the host machine, using the function pointer of the tenth function supported by the client as an incoming parameter, to invoke the The calling instruction of the eighth function supported by the host is replaced by a function pointer of the ninth function supported by the host as an incoming parameter to invoke a calling instruction of the eighth function supported by the host;

Wherein, when the ninth function is called, the host executes the ninth function to invoke a translation function in the first shared library to translate the tenth function, to obtain the host support In an eleventh function, the host executes the eleventh function.

Combining the first aspect or the first possible implementation of the first aspect or the second possible implementation of the first aspect or the third possible implementation of the first aspect or the fourth possible implementation of the first aspect The fifth possible implementation manner of the first aspect, in the sixth possible implementation manner of the first aspect, when the second function includes calling the twelfth function with the first structure as an incoming parameter The calling instruction, the step of translating the second function, further includes:

Transmitting, by the host machine, the calling instruction that invokes the twelfth function with the first structure as an incoming parameter, and calling the calling instruction of the twelfth function with the second structural body as an incoming parameter, the first structure The domain included in the volume is a subset of the domains included in the second structure;

The first structure is a structure supported by the client, and the second structure is a structure supported by the host, and the twelfth function is a function supported by the host. ;

Or the first structure is a structure supported by the host, and the second structure is a structure supported by the client, and the twelfth function is supported by the client The function.

Combining the first aspect or the first possible implementation of the first aspect or the second possible implementation of the first aspect or the third possible implementation of the first aspect or the fourth possible implementation of the first aspect The fifth possible implementation manner of the first aspect or the sixth possible implementation manner of the first aspect, in the seventh possible implementation manner of the first aspect,

When the second function includes a call instruction that invokes the thirteenth function with the first structure body pointer as an incoming parameter, the step of translating the second function further includes: the host machine The structure pointer calls the call instruction of the thirteenth function as an incoming parameter, and translates to a call instruction that calls the thirteenth function with the second structure body pointer as an incoming parameter;

Wherein the first structure body pointer points to the first structure body, the second structure body pointer points to the second structure body, and the first structure body includes a domain that is a subset of the domain included in the second structure body ;

Wherein the first structure is a structure supported by a client, and the second structure is a structure supported by a host, and the thirteenth function is a function supported by the host; or The first structure is a structure supported by the host, and the second structure is a structure supported by the client, and the thirteenth function is a function supported by the client.

Combining the first aspect or the first possible implementation of the first aspect or the second aspect of the first aspect A possible implementation or a third possible implementation of the first aspect or a fourth possible implementation of the first aspect or a fifth possible implementation of the first aspect or a sixth possible implementation of the first aspect Embodiments or a seventh possible implementation of the first aspect, in an eighth possible implementation of the first aspect,

When the incoming parameter of the second function includes the third structure, the method further includes: the host replacing the third structure as the incoming parameter of the second function with the fourth structure, The domain included in the third structure is a subset of the domains included in the fourth structure;

The fourth structure is a structure supported by a client, and the third structure is a structure supported by a host.

Combining the first aspect or the first possible implementation of the first aspect or the second possible implementation of the first aspect or the third possible implementation of the first aspect or the fourth possible implementation of the first aspect A fifth possible implementation of the first aspect or a sixth possible implementation of the first aspect or a seventh possible implementation of the first aspect, the ninth possible implementation of the first aspect In the way,

When the incoming parameter of the second function includes a third structure pointer, the method further includes: the host replacing the third structure pointer as an incoming parameter of the second function with a fourth a structure pointer, the fourth structure pointer points to a fourth structure body, the third structure body pointer points to a third structure body, and the third structure body includes a domain that is a domain of the fourth structure body Subset;

Combining the first aspect or the first possible implementation of the first aspect or the second possible implementation of the first aspect or the third possible implementation of the first aspect or the fourth possible implementation of the first aspect Embodiment or a fifth possible implementation of the first aspect or a sixth possible implementation of the first aspect or a seventh possible implementation of the first aspect or an eighth possible implementation of the first aspect Or a ninth possible implementation manner of the first aspect, in the tenth possible implementation manner of the first aspect,

Before the first function in the third shared library is translated to obtain the second function, the method further includes: the host performing symbol on the third shared library and the host with the same name global variable reset.

In conjunction with the tenth possible implementation of the first aspect, in an eleventh possible implementation manner of the first aspect, the host performs a symbol on the third shared library and the host with the same name global variable Relocating includes: if the first global variable included in the third shared library and the N global variable of the host have the same name, the host will be the most among the first global variable and the N global variables The address of the first loaded global variable is set to the public address of the N global variables and the first global variable.

With reference to the tenth possible implementation manner of the first aspect, in a twelfth possible implementation manner of the first aspect, the host performs a symbol on a global variable of the same name of the third shared library and the host Relocating includes: after being loaded in the second shared library, the host relocates an address of a first global variable in the third shared library to a second global in the second shared library The address of the variable, wherein the declaration of the first global variable and the second global variable are the same.

A second aspect of the present invention provides a host machine, the host machine comprising:

a storage unit, configured to store a first shared library supported by the host, a second shared library supported by the host, and a third shared library supported by the client, where the first shared library includes a translation function, the sink The host and the client support different instruction set architectures;

a calling unit, configured to: when the first function in the second shared library is called, execute the first function to invoke a translation function in the first shared library;

a translation unit, configured to translate, by using a translation function in the first shared library of the call, a function of the function interface of the third shared library and a second function of the first function to obtain a a third function supported by the host; wherein a function interface of the third function and a function interface of the second function are the same;

An execution unit, configured to execute the third function.

With reference to the second aspect, in a first possible implementation manner of the second aspect, the storage unit is further configured to store a fifth shared library supported by the host, where, if the second function includes calling the An instruction of a fourth function in a fourth shared library supported by the client;

The translation unit is also used to:

Translating, by the second function, an instruction to invoke a fourth function in the fourth shared library into An instruction to invoke a fifth function in the fifth shared library, wherein functions of the fourth function and the fifth function are the same, or function functions of the fourth function and the fifth function are The function interfaces are the same.

In conjunction with the second aspect, in a second possible implementation of the second aspect, the storage unit is further configured to store a fifth shared library supported by the host, when the third function invokes the client support The fourth function in the fourth shared library, the translation unit is also used to:

Translating, by the third function, an instruction that invokes a fourth function in a fourth shared library supported by the client into an instruction that the third function calls a fifth function in the fifth shared library; The functions of the fourth function and the function of the fifth function are the same, or the function functions and function interfaces of the fourth function and the fifth function are the same.

In conjunction with the second aspect or the first possible implementation of the second aspect or the second possible implementation of the second aspect, in a third possible implementation of the second aspect, the storage unit is further configured to: Storing a second main program supported by the host, if the second function includes an instruction to invoke a sixth function in the first main program supported by the client, the translation unit is further configured to:

Translating, by the second function, the instruction that invokes the sixth function in the first main program supported by the client into an instruction that invokes a seventh function in the second main program, wherein The functions of the sixth function and the function of the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same.

In conjunction with the second aspect or the first possible implementation of the second aspect or the second possible implementation of the second aspect, in a fourth possible implementation of the second aspect, the storage unit is further configured to: Storing a second main program supported by the host, when the third function calls a sixth function in the first main program supported by the client, the translation unit is further configured to:

Translating, by the third function, an instruction that invokes a sixth function in the first main program supported by the client into a call of the third function in the third main program The functions of the sixth function and the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same.

Optionally, when the second function includes a function pointer of the tenth function supported by the client as an incoming parameter, to invoke a call instruction of an eighth function supported by the host, the translation unit further Used for:

The function pointer of the tenth function supported by the client is used as an incoming parameter, and the calling instruction of the eighth function supported by the host is invoked, and the function of the ninth function supported by the host is replaced. a pointer as an incoming parameter to invoke a call instruction of an eighth function supported by the host; when the ninth function is called, executing the ninth function to invoke a translation function pair in the first shared library The tenth function is translated to obtain an eleventh function supported by the host.

Combining the second aspect or the first possible implementation of the second aspect or the second possible implementation of the second aspect or the third possible implementation of the second aspect or the fourth possible implementation of the second aspect Embodiment, in a fifth possible implementation manner of the second aspect, when the second function includes a calling instruction that invokes a twelfth function by using the first structure as an incoming parameter, the translation unit is further configured to: Calling the call instruction of the twelfth function with the first structure as the incoming parameter, and translating into the call instruction of the twelfth function with the second structure as the incoming parameter, wherein the first structure includes The domain is a subset of the domains contained by the second structure;

Combining the second aspect or the first possible implementation of the second aspect or the second possible implementation of the second aspect or the third possible implementation of the second aspect or the fourth possible implementation of the second aspect The fifth possible implementation manner of the second aspect, in the sixth possible implementation manner of the second aspect, when the second function includes calling the thirteenth with the first structure body pointer as an incoming parameter The call instruction of the function,

The translation unit is further configured to: the host machine invokes the calling instruction that invokes the thirteenth function by using the first structure body pointer as an incoming parameter, and translates to calling the tenth with the second structure body pointer as an incoming parameter a call instruction of a three function; wherein the first structure body pointer points to the first structure body, and the second structure body pointer points to the second structure body, wherein the first structure body includes a domain a subset of the fields contained in the structure;

The first structure is a structure supported by a client, and the second structure is a structure supported by a host, and the thirteenth function is a function supported by the host;

Or the first structure is a structure supported by the host, and the second structure is a structure supported by the client, and the thirteenth function is a function supported by the client.

Combining the second aspect or the first possible implementation of the second aspect or the second possible implementation of the second aspect or the third possible implementation of the second aspect or the fourth possible implementation of the second aspect The fifth possible implementation manner of the second aspect or the sixth possible implementation manner of the second aspect, in the seventh possible implementation manner of the second aspect,

The host machine further includes: a relocation unit, configured to perform the third-order shared library and the same-named global variable of the host machine before translating the first function in the third shared library to obtain the second function Symbol relocation.

With reference to the seventh possible implementation of the second aspect, in an eighth possible implementation manner of the second aspect, the relocation unit is specifically configured to: if the third shared library includes a first global variable and Setting N global variables of the host with the same name, setting an address of the first global variable and the first global variable loaded among the N global variables as the N global variables and the first The public address of the global variable;

or,

The relocation unit is specifically configured to relocate an address of the first global variable in the third shared library to a second in the second shared library after being loaded in the second shared library The address of the global variable, wherein the declaration of the first global variable and the second global variable are the same.

It can be seen that, in the solution of the embodiment of the present invention, the second shared library supported by the host can be regarded as a pseudo shared library of the third shared library supported by the client, because the second shared library The first function is the same as the function interface of the second function in the third shared library, and the first function in the second shared library is mainly used to trigger the calling of the first shared library to translate the third shared library. A function with the same function interface, and this can make the main program or other shared library on the host machine can be the second shared library as a bridge, indirectly calling the first share by calling a function in the second shared library. Another function in the third shared library translated by the translation function in the library has the same function interface. Since the second shared library is supported by the host, the main program or other shared library on the host can recognize and straighten. Calling the function in the second shared library, so that even if the main program or the other dependent shared library that depends on the third shared library on the client is not translated, the third shared library on the client can be indirectly called, so that Greatly reduce the strong dependency between the third shared library and the client's supporting main program (or other related shared libraries), which is beneficial to greatly reduce the amount of translation code, thereby improving the efficiency of binary translation execution, and thus Improve the user experience.

DRAWINGS

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the embodiments or the description of the prior art will be briefly described below. Obviously, the drawings in the following description are only It is a certain embodiment of the present invention, and other drawings can be obtained from those skilled in the art without any creative work.

1 is a schematic flowchart of a binary translation execution method of a shared library according to an embodiment of the present invention;

FIG. 2 is a schematic flowchart diagram of another binary translation execution method of a shared library according to another embodiment of the present invention; FIG.

FIG. 3 is a schematic structural diagram of an x86 client running browser according to an embodiment of the present invention; FIG.

FIG. 3 is a schematic structural diagram of a Loongson host running browser according to an embodiment of the present invention; FIG.

FIG. 3-c is a schematic diagram of a conventional architecture after the Loongson host is introduced into the binary translator according to the embodiment of the present invention;

FIG. 3-d is a schematic diagram of a new architecture after the introduction of the binary translator by the Loongson host according to the embodiment of the present invention; FIG.

FIG. 3-e is a schematic diagram of code translation according to an embodiment of the present invention;

FIG. 3-f is a schematic diagram of another code translation related to a function pointer according to an embodiment of the present invention;

4 is a schematic diagram of a host machine according to an embodiment of the present invention;

FIG. 5 is a schematic diagram of another host machine according to an embodiment of the present invention; FIG.

6 is a schematic diagram of another host machine according to an embodiment of the present invention;

FIG. 7 is a schematic diagram of a communication system according to an embodiment of the present invention.

detailed description

The embodiments of the present invention provide a binary translation execution method and apparatus for a shared library, so as to reduce the amount of related code translation when the shared library is translated, thereby improving the execution efficiency of the binary translation, thereby improving the user experience.

The technical solutions in the embodiments of the present invention will be clearly described in conjunction with the drawings in the embodiments of the present invention. Some embodiments of the invention, rather than all of the embodiments. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without creative efforts shall fall within the scope of the present invention.

The details are described below separately.

The terms "first", "second", "third" and "fourth" and the like in the specification and claims of the present invention and the above drawings are used to distinguish different objects, and are not intended to describe a specific order. . Furthermore, the terms "comprises" and "comprising" and "comprising" are intended to cover a non-exclusive inclusion. For example, a process, method, system, product, or device that comprises a series of steps or units is not limited to the listed steps or units, but optionally also includes steps or units not listed, or alternatively Other steps or units inherent to these processes, methods, products or equipment.

An embodiment of the binary translation execution method of the shared library of the present invention, a binary translation execution method of the shared library is applied to the host machine, and the host machine may include the first shared library supported by the host machine and supported by the host machine. a second shared library and a third shared library supported by the client, the first shared library includes a translation function, the host machine and the client support different instruction set architectures, and the method includes: when in the second shared library When the first function is called, the host machine executes the first function to invoke the translation function in the first shared library; the host machine uses the translation function in the first shared library that is invoked to invoke the third shared library. The second function of the function interface of the first function is translated to obtain the third function supported by the host machine; the function interface of the third function is the same as the function interface of the second function; The host executes the third function described above.

Referring to FIG. 1, FIG. 1 is a schematic flowchart of binary translation execution of a shared library according to an embodiment of the present invention. As shown in FIG. 1, a binary translation execution method of a shared library provided by an embodiment of the present invention may include the following contents:

101. When the first function in the second shared library is called, wherein the first function in the second shared library may be called by the main program, of course, the first function in the second shared library may also be the second shared library. Or the function call in the other shared library, the host machine executes the first function described above to invoke the translation function in the first shared library.

The host machine may include a first shared library supported by the host, a second shared library supported by the host, and a third shared library supported by the client, wherein the host and the client support different instruction sets. Architecture.

102. The host machine translates, by using the translation function in the first shared library that is invoked, the second function of the function interface and the function interface of the first function in the third shared library to obtain the foregoing function. The third function supported by the host. The function interface of the third function is the same as the function interface of the second function.

It is to be understood that the first function in the second shared library may be any one of the second shared libraries, or the first function in the second shared library may be any one of the second shared libraries. a specific function.

103. Perform the third function described above.

It can be understood that there is no necessary execution order between the step of translating the above second function and the step of executing the above third function. In some possible implementations, the step of translating the second function may be performed first, and then the step of executing the foregoing third function may be performed, and in other possible implementations, it may be performed on one side. The step of translating the second function described above performs the above-described step of executing the third function described above, that is, performing the third function and translating the second function may be interleaved.

It can be seen that, in the solution of the embodiment of the present invention, the second shared library supported by the host can be regarded as a pseudo shared library of the third shared library supported by the client, because the second shared library The first function is the same as the function interface of the second function in the third shared library, and the first function in the second shared library is mainly used to trigger the calling of the first shared library to translate the third shared library. A function with the same function interface, and this can make the main program or other shared library on the host machine can be the second shared library as a bridge, indirectly calling the first share by calling a function in the second shared library. Another function in the third shared library translated by the translation function in the library with the same function interface, due to the second The shared library is supported by the host, so the main program or other shared library on the host can recognize and directly call the function in the second shared library, which can realize the main program or other even if it is not dependent on the third shared library on the client. Dependent shared library for translation, or indirect call to the third shared library on the client, which greatly reduces the strong between the third shared library and the client's supporting main program (or other related shared libraries) Dependency, which helps to greatly reduce the amount of translation code, which can improve the efficiency of binary translation execution, thereby improving the user experience.

Further, since the first shared library includes a translation function, that is, the binary translator is compiled into the first shared library, when the function in the third shared library supported by the client needs to be called, the first shared library is related to the called The function is dynamically translated, which is beneficial to improve the pertinence and effectiveness of translation, and is beneficial to reduce the amount of invalid translation work, thereby further reducing the amount of translation code, thereby further improving the execution efficiency of binary translation, thereby further improving the user experience.

Among them, the translation of the above second function may involve various aspects, and the specific translation manner may also be various, as exemplified below.

In some possible implementation manners of the present invention, the host machine further includes a fifth shared library supported by the host machine; if the second function includes an instruction for calling a fourth function in the fourth shared library supported by the client. The step of translating the second function may further include: the host machine translating, by the host machine, the instruction for calling the fourth function in the fourth shared library included in the second function into calling the fifth shared library. The instruction of the fifth function, wherein the functions of the fourth function and the function of the fifth function are the same, or the function functions and function interfaces of the fourth function and the fifth function are the same. It can be understood that the above host translates the instruction of the second function included in the second shared library to the instruction of calling the fifth function in the fifth shared library, which can be regarded as one. The library function packaging technology replaces the call of a function in a shared library supported by the client with a function that has the same function or a function function and a function interface in a shared library supported by the host. This is beneficial to improve the utilization of the local shared library of the host machine, and further reduce the translation of the function code of the client-related shared library, thereby further reducing the amount of code translation.

In another possible implementation manner of the present invention, the host machine may further include a fifth shared library supported by the host machine, where the third function invokes the fourth shared library supported by the client. In the fourth function, the method may further include: the host machine translating, by the host function, the instruction of the fourth function included in the fourth shared library supported by the third function into the third function calling the foregoing The instruction of the fifth function in the shared library; wherein the function function and the function interface of the fourth function and the fifth function are the same, or the functions of the fourth function and the fifth function are the same. It can be understood that the host machine translates the instruction including the fourth function in the fourth shared library included in the third function into an instruction that invokes the fifth function in the fifth shared library, which can be regarded as an essential Is a library function wrapper technology, that is, the call to a function in a shared library supported by the client can be replaced by the same function or function function and function interface in a shared library supported by the host. The call of the function, which is beneficial to improve the utilization of the local shared library of the host, further reduce the translation of the function code of the client-related shared library, thereby further reducing the amount of code translation.

In some possible implementation manners of the present invention, the host machine further includes a second main program supported by the host machine, where the second function includes an instruction to invoke a sixth function in the first main program supported by the client. The step of translating the second function may further include: the host machine translating, by the host function, the instruction that invokes the sixth function in the first main program supported by the client by the second function to call the foregoing The instruction of the seventh function in the two main programs, wherein the functions of the sixth function and the function of the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same. It can be understood that the above-mentioned second function includes the instruction for calling the sixth function in the first main program supported by the client, and the instruction for calling the seventh function in the second main program is essentially regarded as Is a library function wrapper technology, that is, the call to a function in the main program supported by the client is replaced by a call to a function with the same function or the same function and function interface in the main program supported by the host. This is beneficial to improve the utilization of the local shared library of the host machine, and further reduce the translation of the function code of the client-related shared library, thereby further reducing the amount of code translation.

In another possible implementation manner of the present invention, the host machine further includes a second main program supported by the host machine, when the third function invokes a sixth function in the first main program supported by the client, The method further includes: the host machine translating, by the host function, an instruction of the third function included in the first main program supported by the third function to the third function to invoke the second main a call of a seventh function in the program, wherein the functions of the sixth function and the function of the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same. It can be understood that the above-mentioned third function includes the instruction for calling the sixth function in the first main program supported by the client, and the instruction for calling the seventh function in the second main program is substantially Seen as a library function wrapper technology, that is, you can replace the call to a function in the main program supported by the client with the same function or the function and function interface in the main program supported by the host. The call of the function, which is beneficial to improve the utilization of the host's local shared library, further reduce the translation of the function code of the client-related shared library, thereby further reducing the amount of code translation.

In some possible implementation manners of the present invention, when the second function includes a function pointer of the tenth function supported by the client as an incoming parameter, to invoke the calling instruction of the eighth function supported by the host, The step of translating the second function may further include: the host machine adopts the function pointer of the tenth function supported by the client as the incoming parameter, and invokes the calling instruction of the eighth function supported by the host, and replaces it with The function pointer of the ninth function supported by the host machine is used as an incoming parameter to invoke the calling instruction of the eighth function supported by the host. Wherein, when the ninth function is called, the host machine executes the ninth function to invoke the translation function in the first shared library to translate the tenth function, to obtain an eleventh function supported by the host machine, The host executes the eleventh function described above. It can be understood that, in the above scenario where the function pointer exists, the introduction of the ninth function as a bridge is beneficial to realizing the translation of the function pointed to by the function pointer at a suitable timing, which is beneficial to avoid errors as much as possible.

In some possible implementation manners of the present invention, when the third year function includes a function pointer of the function S01 supported by the host machine as an incoming parameter, to invoke a call instruction of the S02 function supported by the host, when the function is When S01 is called, the host machine executes the above function S01, and the host does not translate the above function S001.

In some possible implementations of the present invention, when the second function includes a call instruction that invokes the twelfth function with the first structure as an incoming parameter, the step of translating the second function may further include: The host invokes the above-mentioned call instruction of the twelfth function with the first structure as the incoming parameter, and translates the call instruction of the twelfth function with the second structure as the incoming parameter, The domain included in the first structure is a subset of the domains included in the second structure. The first structure is a structure supported by the client, and the second structure is a structure supported by the host, and the twelfth function is a function supported by the host; or the first structure The body is a structure supported by the host machine, and the second structure is a structure supported by the client, and the twelfth function is a function supported by the client. For example, the domain included in the first structure may be the same as the domain included in the second structure.

In some possible implementations of the present invention, when the second function includes a call instruction that invokes the thirteenth function with the first structure body pointer as an incoming parameter, the step of translating the second function may further include: The host machine invokes the above-mentioned call instruction that invokes the thirteenth function with the first structure body pointer as an incoming parameter, and translates the call instruction of the thirteenth function with the second structure body pointer as an incoming parameter. The first structure pointer points to the first structure, the second structure pointer points to the second structure, and the first structure includes a field that is a subset of the domains included in the second structure. The first structure is a structure supported by a client, and the second structure is a structure supported by a host, and the thirteenth function is a function supported by the host. Or the first structure is a structure supported by the host, and the second structure is a structure supported by the client, and the thirteenth function is a function supported by the client. For example, the domain included in the first structure may be the same as the domain included in the second structure.

In some possible implementation manners of the present invention, when the incoming parameter of the second function includes the third structure, the method may further include: the third structure that the host machine uses as the incoming parameter of the second function The body is replaced by a fourth structure, and the third structure includes a domain of a subset of domains included in the fourth structure; wherein the fourth structure is a client-supported structure, and the third structure A structure supported by the host. For example, the domain included in the third structure described above may be the same as the domain included in the fourth structure.

In some possible implementation manners of the present invention, when the incoming parameter of the second function includes the third structure pointer, the method may further include: the foregoing, by the host, as an incoming parameter of the second function The third structure pointer is replaced with a fourth structure body pointer, the fourth structure body pointer is directed to the fourth structure body, the third structure body pointer is directed to the third structure body, and the third structure body includes the fourth structure body A subset of the included domains. Wherein the fourth structure body is supported by the client The structure, and the third structure is a structure supported by a host. For example, the domain included in the third structure described above may be the same as the domain included in the fourth structure.

Wherein, the above exemplifies some possible implementations of the translation second function, and the translation translation second function may also involve some other operations related to translation, of course, in practical applications, other translation operations may also be involved, of course, the above translation operations They may also be nested with each other, and the specific methods are not described here.

In addition, in some possible implementation manners of the present invention, before the first function in the third shared library is translated to obtain the second function, the method may further include: the foregoing host machine, the third shared library, and the foregoing The host's global variable of the same name is symbol relocated.

For example, the symbol relocation of the global variable of the same name of the third shared library and the host machine by the host machine includes: if the first global variable included in the third shared library and the N global variable of the host have the same name, The host machine sets an address of the first global variable and the first global variable loaded among the N global variables to a common address of the N global variables and the first global variable.

For another example, the symbol relocation of the global variable of the same name of the third shared library and the host machine by the host machine includes: after the second shared library is loaded, the host machine is the first one of the third shared libraries. The address of the global variable is relocated to the address of the second global variable in the second shared library, wherein the declaration of the first global variable and the second global variable is the same.

It can be understood that the first global variable may be any global variable included in the third shared library. Alternatively, the first global variable may also be a specific global variable included in the third shared library.

The host and the client of the embodiments of the present invention support different instruction set architectures. For example, the host and the client can respectively support one of the following instruction set architectures: the POWER instruction set architecture and the x86 instruction set system. Architecture, Loongson instruction set architecture and MIPS instruction set architecture.

To facilitate a better understanding and implementation of the foregoing technical solutions of the embodiments of the present invention, the following is exemplified by some specific application scenarios.

In the following example, the client mainly supports the x86 instruction set architecture, and the host supports the Loongson command. Take the architecture of the system as an example. Among them, in the following example description, a client supporting the x86 instruction set architecture may be referred to as an x86 client, and a host supporting the Loongson instruction set architecture may be referred to as a Loongson host.

For example, suppose that the Loongson host machine can run the open source Firefox browser (the browser can be regarded as the main program), but the flash playback plugin (ie flashplayer.so shared library) in the browser is developed by Adobe. Assume that the flash player plugin is not open source and only provides the version under the x86 instruction set architecture, so it cannot be used in the Firefox browser of the Godson host.

In order to simplify the description, the browser supported by the Loongson host can be called the Loongson browser, and the shared library supported by the Loongson host is called the Loongson shared library. Similarly, a browser supported by an x86 client can be referred to as an x86 browser, and a shared library supported by an x86 client can be referred to as an x86 shared library.

See Figure 3-a, which shows a software architecture for an x86 client running an x86 browser. The x86 browser may call functions in various x86 shared libraries (including flash play plugins); the flash play plugin may also call functions from other x86 shared libraries; the flash play plugin may also call functions in the x86 browser.

Among them, on x86 clients, these programs are complete. On the Loongson host, the Loongson browser and other x86 shared libraries can be compiled and generated with open source code, but the Loongson host lacks the shared library of flash playback plugins, as shown in Figure 3-b.

In the existing binary translation scheme, the binary translator is the main program of the Loongson host, and its architecture can be specifically shown in Figure 3-c. The binary translator not only needs to translate the flash playback plug-in running the x86 client, but also needs to translate and run. X86 browsers and other x86 shared libraries, therefore, because of the need to translate x86 shared libraries and x86 browsers, which makes the translation code large, affecting the efficiency of translation operations.

In a technical solution of some embodiments of the present invention, the binary translator is compiled into a first shared library bt.so on the Loongson host (an example implementation of the first shared library in the above embodiment), the first shared library Bt.so can be called by the Loongson browser, and the x86 client's flash play plugin is translated by the first shared library bt.so, as shown in Figure 3-d. Because the x86 code that needs to be translated and run is greatly reduced, it is beneficial to greatly improve the efficiency of translation operation.

Referring to FIG. 2, FIG. 2 is a schematic flowchart of binary translation execution of another shared library according to another embodiment of the present invention. As shown in FIG. 2, another shared library provided by another embodiment of the present invention is provided. The binary translation execution method can include the following:

201. The Loongson host compiles the binary translator into the first shared library bt.so.

202. The Loongson host machine loads the pseudo flash play plugin flashplayer_ls.so (the pseudo flash play plugin flashplayer_ls.so can be regarded as an example implementation of the second shared library in the above embodiment) to be loaded into the Loongson browser.

The function interface provided by the pseudo flash playback plug-in flashplayer_ls.so and the x86flash playback plug-in flashplayer_x86.so (where the x86flash playback plug-in flashplayer_x86.so can be regarded as an example implementation of the third shared library in the above embodiment) provides a function. The interface is the same. Among them, you can find the global function symbols from the symbol table by parsing the binary files of the x86flash playback plug-in. These global function symbols are the function interfaces of the x86flash playback plug-in, and the function interface of the x86flash playback plug-in is provided as a function provided by the pseudo-flash playback plug-in. interface.

Of course, the Loongson host can also load the first shared library bt.so, and can also initialize the x86 runtime environment (such as simulated x86 registers, memory, etc.) and the translated Loongson code buffer through the first shared library bt.so. Wait.

203. When the first function of the pseudo flash playback plug-in flashplayer_ls.so is called by the Loongson browser, the Loongson host executes the first function in the pseudo flash playback plug-in flashplayer_ls.so to call the first shared library bt.so The translation function x86_exec translates the function function in the x86flash playback plug-in flashplayer_x86.so with the second function (such as the NPP_New function) of the function interface of the first function to obtain a third function, and executes the third function.

Referring to Figure 3-e, Figure 3-e shows the second function in the x86flash playback plug-in flashplayer_x86.so (the NPP_New function is shown in Figure 3-e), and the Loongson host machine is translated. The third function supported.

In some possible implementation manners of the present invention, the foregoing Loongson host further includes a fifth shared library supported by the Loongson host; if the second function includes a fourth shared library (such as libc.so) supported by the x86 client. The instruction of the fourth function (such as the malloc function), wherein the step of translating the second function may further include: the Loongson host invoking the second function included in the fourth shared library (such as libc. An instruction of a fourth function (such as a malloc function) in so) is translated into an instruction that invokes a fifth function in the fifth shared library, wherein the fourth function and the fifth function are The function and function interface are the same. It can be understood that the Loongson host machine translates the instruction of the second function included in the second shared library mentioned above into the instruction of calling the fifth function in the fifth shared library, which can be regarded as one. The library function wrapper technology is to replace the call of a function in a shared library supported by the x86 client with a function with the same function or the same function and function interface in a shared library supported by the Loongson host. Calling, which is beneficial to improve the utilization of the local shared library of the Loongson host, further reducing the translation of the function code of the shared library of the x86 client, thereby further reducing the amount of code translation.

In another possible implementation manner of the present invention, the Loongson host machine further includes a fifth shared library supported by the Loongson host, and the third function calls the fourth shared library supported by the x86 client (for example, libc.so The fourth function (for example, the malloc function), the above-mentioned Loongson host may include the fourth shared library supported by the above-mentioned x86 client including the third function (such as the fourth function in libc.so (for example, the malloc function). And an instruction translated into the third function of the fifth shared library in the fifth shared function; wherein the function function and the function interface of the fourth function and the fifth function are the same, or the fourth function and the foregoing The functions of the five functions have the same function. It can be understood that the above-mentioned Loongson host translates the instruction of the third function included in the third function to the fifth function in the fifth shared library. In essence, it can be regarded as a library function wrapper technology, that is, the call to a function in a shared library supported by the x86 client can be replaced with the Loongson host. The function of the shared function in a shared library is the same or the function function and function interface are the same function call, which is beneficial to improve the utilization of the local shared library of the Loongson host, and further reduce the function code of the shared library of the x86 client. The translation, in turn, helps to further reduce the amount of code translation.

In some possible implementation manners of the present invention, the Loongson host machine further includes a Loongson browser supported by the Loongson host machine, and if the second function includes an instruction to invoke a sixth function (such as the NPN_PostURL function) in the x86 browser, The step of translating the second function may further include: the above-mentioned Loongson host translating, by the above-mentioned second function, the instruction of the sixth function (such as the NPN_PostURL function) in the x86 browser supported by the x86 client described above into a call. The instruction of the seventh function (such as the NPN_PostURL function) in the Loongson browser, wherein the function function and the function interface of the sixth function and the seventh function are the same. It can be understood that the above second function is included in the above adjustment The instruction of the sixth function in the x86 browser supported by the above x86 client is translated into the instruction of calling the seventh function in the Loongson browser, which can be regarded as a library function packaging technology, which is about to be an x86 client. The call of a function in the supported x86 browser is replaced by the call of the same function and function interface in the Loongson browser supported by the Loongson host, which is beneficial to improve the local shared library utilization of the Loongson host. , further reducing the translation of the function code of the x86 client-related shared library, thereby further reducing the amount of code translation.

In another possible implementation manner of the present invention, the Loongson host machine further includes the Loongson browser supported by the Loongson host, and the third function in the x86 browser supported by the x86 client is used as the sixth function ( For example, when the NPN_PostURL function is used, the above-mentioned Loongson host may translate the instruction of the sixth function included in the x86 browser supported by the above-mentioned x86 client into the third function to call the above-mentioned Loongson browser. a call of a seven function (such as an NPN_PostURL function), wherein the functions of the sixth function and the function of the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same. It can be understood that the above-mentioned third function includes the above-mentioned instruction for calling the sixth function in the x86 browser supported by the x86 client, and the instruction for calling the seventh function in the Loongson browser is substantially visible. Is a library function wrapper technology, that is, you can replace the call of a function in the main program supported by the x86 client with the same function or function function and function interface in the main program supported by the Loongson host. The same function call, which is beneficial to improve the utilization of the local shared library of the Loongson host, further reducing the translation of the function code of the shared library of the x86 client, thereby further reducing the amount of code translation.

In some possible implementation manners of the present invention, the Loongson host machine executes the first function in the pseudo flash play plugin flashplayer_ls.so to call the translation function x86_exec in the first shared library bt.so to the x86flash play plugin flashplayer_x86.so Before the second function is translated to get the third function, the Loongson host can execute the x86 loader or the related function in the first shared library bt.so to play the above x86flash plugin flashplayer_x86.so and the Loongson host. A symbolic relocation is performed on the global variable of the same name. Specifically, after the Loongson host performs the initial symbol relocation by executing the x86 loader, the Loongson host can execute the related function in the first shared library bt.so to read the global variable list in the Loongson running environment and the x86 running environment. Shared global variables for both, based on their memory loading The order (ie, the loading order of the browser, shared library, and flash player plugin in the same runtime environment) is re-symbolized. After this process, the code in the two runtime environments can access the same global variable normally.

Among them, the specific ways of symbol relocation of the above-mentioned x86flash playback plug-in flashplayer_x86.so and the Loongson host's global variable of the same name may be various, as exemplified below.

For example, the Loongson host executes a loader or a related function in the first shared library bt.so to perform symbol relocation on the x86flash playback plug-in flashplayer_x86.so and the same-named global variable of the Loongson host, which may include: If the x86flash playback plugin flashplayer_x86.so contains the first global variable and the same name of the N global variable of the Loongson host, the Loongson host executes the loader or the first shared library bt.so related function to the above first global variable and The address of the first global variable loaded among the N global variables is set to the public address of the N global variables and the first global variable, and the N is a positive integer.

For another example, the Loongson host performs a loader or a related function in the first shared library bt.so to perform symbol relocation on the x86flash playback plug-in flashplayer_x86.so and the same-named global variable of the Loongson host, which may include: playing in a pseudo flash. After the plug-in flashplayer_ls.so is loaded, the address of the first global variable of the x86 flash playback plug-in flashplayer_x86.so is relocated to the address of the second global variable in the pseudo-flash playback plug-in flashplayer_ls.so. The declaration of the first global variable and the second global variable are the same.

It can be understood that the first global variable mentioned above may be any global variable included in the x86flash playback plug-in flashplayer_x86.so. Alternatively, the first global variable may also be a specific global variable included in the x86flash playback plugin flashplayer_x86.so. The symbol relocation mode of each global variable included in the x86flash playback plug-in flashplayer_x86.so can be similar to the symbol relocation mode of the first global variable.

In addition, the Loongson browser, the Loongson shared library, and the x86flash playback plug-in flashplayer_x86.so may pass function pointers through the arguments and return values of function calls. For example, the function A of the x86flash playback plug-in flashplayer_x86.so may call the function B in the Loongson graphics shared library with the function pointer x86_foo as the incoming parameter; the function B will use the function pointer to call the function pointed to by the function pointer x86_foo.

For example, function B in the actual program may be the function g_signal_connect, register a click event for a control (such as a button), or set a timer for gtk_timeout_add.

Similarly, when the Loongson browser or Loongson shared library calls the function of the x86flash playback plugin flashplayer_x86.so, it is also possible to pass the Loongson function pointer (such as ls_bar) as an incoming parameter to the x86flash playback plugin flashplayer_x86.so. function.

When the x86 client and the function of the Loongson host call each other, if the argument refers to the function pointer, the function pointer can be subjected to a certain translation process, which is beneficial to ensure the correctness of the function operation.

The first type of value conversion: when the second function includes a function pointer of the tenth function supported by the above x86 client (such as the x86 function pointer x86_foo) as an incoming parameter, to invoke the calling instruction of the eighth function supported by the Loongson host. The Loongson host can execute a correlation function in the first shared library bt.so to generate a ninth function (which can be regarded as a pseudo-base function (such as the x86_foo function in FIG. 3-f)), The function pointer of the tenth function supported by the above x86 client is used as an incoming parameter to call the calling instruction of the eighth function supported by the above-mentioned Loongson host, and is replaced by the function pointer of the ninth function supported by the Loongson host. Entering a parameter to invoke a call instruction of the eighth function supported by the Loongson host, wherein when the ninth function is invoked, the Loongson host executes the ninth function to invoke the translation in the first shared library bt.so The function, the above tenth function is translated, and the eleventh function supported by the Loongson host machine is obtained, and the Loongson host performs the eleventh function described above. It can be understood that in the presence of the function finger In the above scenario of the pin, the introduction of the ninth function as a bridge is beneficial to realizing the translation of the function pointed to by the function pointer at a suitable timing, which is beneficial to avoid errors as much as possible. The second function pointer replaced is in accordance with the Loongson host. The application binary interface can be called by the Loongson host function.

The second type of value conversion: if the incoming parameter of the second function includes a third function pointer, and the third function pointer is a function pointer of the above-mentioned Loongson host machine (the third function pointer may be determined according to the structure of the function pointer as the above-mentioned Loongson The function pointer of the host is still a function pointer of the above x86 client), and the call of the second function to the eleventh function pointed to by the third function pointer is translated into the above-mentioned third function pointing to the third function pointer The call of the eleventh function.

In addition, the definition of the same structure on the x86 client and the Loongson host may be different, and the structure may add null data between the domain and the domain in order to meet the data alignment requirements of each domain. This In some cases, the binary format of the same structure on the x86 client and the Loongson host is not necessarily the same. When these structures are passed as input parameters to another runtime environment, they may access the wrong structure body location, so it may be necessary to translate the passed structure.

Type 3 value conversion method 1:

In some possible implementation manners of the present invention, when the second function includes a call instruction that invokes the twelfth function with the first structure as an incoming parameter, the Loongson host may use the first structure as the incoming The parameter calls the calling instruction of the twelfth function, and translates into calling instruction of the twelfth function by using the second structure as the incoming parameter, and the first structure includes the domain of the domain included in the second structure. set. The first structure is a structure supported by the x86 client, and the second structure is a structure supported by the Loongson host, and the twelfth function is a function supported by the Loongson host; or the above A structure is a structure supported by the Loongson host, and the second structure is a structure supported by the x86 client, and the twelfth function is a function supported by the x86 client. For example, the domain included in the first structure described above may be the same as the domain included in the second structure.

Type 3 value conversion method 2:

In some possible implementations of the present invention, when the second function includes a call instruction that invokes the thirteenth function with the first structure body pointer as an incoming parameter, the step of translating the second function may further include: The Loongson host machine invokes the above-mentioned call instruction of the thirteenth function with the first structure body pointer as an incoming parameter, and translates the call instruction of the thirteenth function with the second structure body pointer as an incoming parameter. The first structure body pointer points to the first structure body, the second structure body pointer points to the second structure body, and the first structure body includes a domain that is a subset of the domains included in the second structure body. The first structure is a structure supported by an x86 client, and the second structure is a structure supported by a Loongson host, and the thirteenth function is a function supported by the Loongson host. Or the first structure is a structure supported by a Loongson host, and the second structure is a structure supported by an x86 client, and the thirteenth function is a function supported by the x86 client. For example, the domain included in the first structure may be the same as the domain included in the second structure.

Wherein, if a certain domain in the first structure is also a structure, the third type of value conversion mode 1 can also be performed on the domain. If a domain in the first structure is also a structure pointer, the third class value can also be made to the domain. Conversion method 2. Wherein, if a certain field in the first structure is a function pointer, the first type of value conversion can be performed on the domain. And so on.

Type 4 value conversion method 1:

When the incoming parameter of the second function includes the third structure, the Loongson host may replace the third structure as the incoming parameter of the second function with the fourth structure, and the third structure includes the domain And a subset of the domains included in the fourth structure; wherein the fourth structure is a structure supported by an x86 client, and the third structure is a structure supported by a Loongson host. For example, the domain included in the third structure described above may be the same as the domain included in the fourth structure.

Type 4 value conversion method 2:

When the incoming parameter of the second function includes the third structure body pointer, the Godson host may replace the third structure body pointer as the incoming parameter of the second function with the fourth structure body pointer, and the fourth structure body The pointer points to the fourth structure, the third structure pointer points to the third structure, and the third structure includes a field which is a subset of the fields included in the fourth structure. The fourth structure is a structure supported by an x86 client, and the third structure is a structure supported by a Loongson host. For example, the domain included in the third structure described above may be the same as the domain included in the fourth structure. .

Wherein, if a certain domain in the third structure is also a structure, the fourth type of value conversion mode 1 can also be performed on the domain. If a certain field in the third structure is also a structure pointer, the fourth type of value conversion mode 2 can also be performed on the domain. Wherein, if a certain field in the third structure is a function pointer, the second type of value conversion can be performed on the domain. And so on.

It can be seen that, in the solution of the embodiment, the second shared library supported by the Loongson host machine (pseudo flash play plugin flashplayer_ls.so) can be regarded as the third shared library supported by the x86 client (x86 flash play plugin). a pseudo shared library, because the function of the first function in the second shared library and the second function in the third shared library are the same (that is, the function interface provided by the second shared library and the third shared library described above) There is a non-empty intersection between the provided function interfaces, and the first function in the second shared library is mainly used to trigger the calling of the first shared library to translate the function having the same function interface in the third shared library, and this It can make the main program or other shared library on the Loongson host machine, and the second shared library can be used as a bridge to indirectly call the translation function translated by the first shared library by calling a function in the second shared library. Another function in the third shared library with the same function interface, due to the The second shared library is supported by the Loongson host. Therefore, the main program or other shared libraries on the Loongson host can recognize and directly call the functions in the second shared library, so that even if the third shared library is not dependent on the x86 client. The main program or other dependent shared libraries are translated, and can also be executed indirectly on the third shared library on the x86 client, which greatly reduces the support main program (or other related sharing) of the third shared library and the x86 client. Strong dependency between libraries), which helps to greatly reduce the amount of translation code, which can improve the efficiency of binary translation execution, thereby improving the user experience. .

Further, since the first shared library is compiled by the binary translator, when the function in the third shared library supported by the x86 client is called, the first shared library dynamically translates the called related function, so that It is beneficial to improve the pertinence and effectiveness of translation, and thus help to reduce the amount of invalid translation work, which in turn helps to further reduce the amount of translation code, thereby further improving the execution efficiency of binary translation, thereby further improving the user experience.

It can be understood that the above examples mainly illustrate that the client supports the x86 instruction set architecture and supports the Loongson instruction set architecture. The host machine supports the x86 instruction set architecture or other instruction set architecture. The implementation method of the client supporting the Loongson instruction set architecture or other instruction set architecture can be similarly referred to, and will not be described here.

Related devices for implementing the above schemes are also provided below.

Referring to FIG. 4, an embodiment of the present invention provides a host 400 that can include a storage unit 410, a calling unit 420, a translation unit 430, and an execution unit 440.

The storage unit 410 is configured to store a first shared library supported by the host, a second shared library supported by the host, and a third shared library supported by the client, where the first shared library includes a translation function, the host and the foregoing The client supports a different instruction set architecture.

The calling unit 420 is configured to execute the first function to invoke the translation function in the first shared library when the first function in the second shared library is called.

The translation unit 430 is configured to translate the second function of the function interface in the third shared library and the function interface of the first function by using the translation function in the first shared library that is invoked to obtain the host machine. A third function supported; wherein the function interface of the third function is the same as the function interface of the second function.

The executing unit 440 is configured to execute the third function described above.

Optionally, in some possible implementation manners of the present disclosure, the foregoing storage unit 410 is further configured to store a fifth shared library supported by the host machine, where the second function includes: calling the fourth shared library supported by the client. The instruction of the fourth function.

The above translation unit 430 can also be used to:

Converting, by the second function, an instruction that calls the fourth function in the fourth shared library to an instruction that invokes the fifth function in the fifth shared library, wherein the fourth function and the function of the fifth function The functions are the same, or the function functions and function interfaces of the fourth function and the fifth function described above are the same.

Optionally, in another possible implementation manner of the present invention, the foregoing storage unit 410 is further configured to store a fifth shared library supported by the host, where the third function invokes a fourth shared library supported by the client. In the fourth function, the above translation unit 430 is further configured to:

Translating, by the third function, an instruction for calling a fourth function in the fourth shared library supported by the client to an instruction of the third function calling the fifth function in the fifth shared library; the fourth function and the foregoing The functions of the fifth function have the same function, or the function functions and function interfaces of the fourth function and the fifth function described above are the same.

Optionally, in some possible implementation manners of the present disclosure, the foregoing storage unit 410 is further configured to store a second main program supported by the host, if the second function includes calling the first main program supported by the client. The instruction of the sixth function, the translation unit 430 is further configured to:

Translating, by the foregoing second function, the instruction for calling the sixth function in the first main program supported by the client to an instruction for calling the seventh function in the second main program, wherein the sixth function and the foregoing The functions of the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function described above are the same.

Optionally, in another possible implementation manner of the present invention, the foregoing storage unit 410 is further configured to store the second main program supported by the host, when the third function invokes the first main program supported by the client. In the sixth function, the above translation unit 430 is further configured to:

Translating, by the third function, an instruction for calling a sixth function in the first main program supported by the client, into a call of the third function in the third main program, the sixth function and The function of the seventh function described above has the same function, or the sixth function and the seventh function described above The function functions and function interfaces of the number are the same.

Optionally, in some possible implementation manners of the present invention, when the second function includes a function pointer of the tenth function supported by the client as an incoming parameter, the calling instruction of the eighth function supported by the host is invoked. The above translation unit 430 can also be used to:

The function pointer of the tenth function supported by the above client is used as an incoming parameter, and the calling instruction of the eighth function supported by the host is invoked, and the function pointer of the ninth function supported by the host is used as the incoming function. a parameter to invoke a call instruction of an eighth function supported by the host machine; when the ninth function is called, executing the ninth function to invoke the translation function in the first shared library to translate the tenth function The eleventh function supported by the above host.

Optionally, in some possible implementation manners of the present invention, when the second function includes a call instruction that invokes a twelfth function by using the first structure as an incoming parameter, the translation unit 430 is further configured to use the first The structure invokes the call instruction of the twelfth function as an incoming parameter, and translates to call the twelfth function with the second structure as the incoming parameter, wherein the first structure includes the second field A subset of the fields that the structure contains. The first structure is a structure supported by the client, and the second structure is a structure supported by the host, and the twelfth function is a function supported by the host. Alternatively, the first structure may be a structure supported by the host, and the second structure is a structure supported by the client, and the twelfth function is a function supported by the client.

Optionally, in another possible implementation manner of the present invention, when the second function includes a call instruction that invokes a thirteenth function by using the first structure body pointer as an incoming parameter, the translation unit 430 is further configured to: The host invokes the above-mentioned calling instruction that invokes the thirteenth function with the first structure body pointer as an incoming parameter, and translates to call the thirteenth function calling instruction with the second structure body pointer as an incoming parameter; wherein, the first structure The body pointer points to the first structure body, and the second structure body pointer points to the second structure body, wherein the first structure body includes a domain that is a subset of the domains included in the second structure body. The first structure is a structure supported by a client, and the second structure is a structure supported by a host, and the thirteenth function is a function supported by the host. Or the first structure is a structure supported by the host, and the second structure is a structure supported by the client, and the thirteenth function is a function supported by the client.

Optionally, in some possible implementation manners of the present invention, the host machine further includes:

The relocation unit 450 is configured to perform symbol relocation on the third shared library and the global variable of the same name of the host machine before translating the first function in the third shared library to obtain the second function.

For example, the relocation unit 450 may be specifically configured to: if the first global variable included in the third shared library and the N global variable of the host have the same name, first among the first global variable and the N global variables The address of the loaded global variable is set to the above N global variables and the public address of the first global variable;

For example, the relocation unit 450 is specifically configured to relocate the address of the first global variable in the third shared library to the second global variable in the second shared library after being loaded in the second shared library. An address, wherein the first global variable is the same as the second global variable.

It is to be understood that the functions of the functional modules of the host 400 of the present embodiment may be specifically implemented according to the method in the foregoing method embodiments. For the specific implementation process, refer to the related description of the foregoing method embodiments, and details are not described herein again.

It can be seen that, in the solution of the embodiment, the second shared library supported by the host 400 can be regarded as a pseudo shared library of the third shared library supported by the client, because the second shared library The first function is the same as the function interface of the second function in the third shared library, and the first function in the second shared library is mainly used to trigger the calling of the first shared library to translate the third shared library. A function having the same function interface, and this allows the main program or other shared library on the host machine 400 to be a bridge of the second shared library, and indirectly calling the first function by calling a function in the second shared library. Another function having the same function interface in the third shared library translated by the translation function in the shared library, since the second shared library is supported by the host 400, the main program or other shared library on the host 400 can Identifying and directly calling functions in the second shared library, so that even if the main program on the client that depends on the third shared library or other dependent shared libraries is not translated, the third total on the client The library indirectly calls the execution, which greatly reduces the strong dependency between the third shared library and the client's supporting main program (or other related shared libraries), which helps to greatly reduce the amount of translation code, thereby improving The efficiency of binary translation execution, which in turn enhances the user experience.

Referring to FIG. 5, FIG. 5 is a schematic diagram of a host 500 according to an embodiment of the present invention. The host 500 may include at least one bus 501, at least one processor 502 connected to the bus 501, and connected to the bus 501. At least one memory 503.

Among them, the above host machine and the above client support different instruction set architectures. The memory 503 is configured to store the first shared library supported by the host, the second shared library supported by the host, and the third shared library supported by the client. Wherein, the first shared library includes a translation function.

The processor 502 calls the code stored in the memory 503 through the bus 501 for executing the first function to invoke the translation function in the first shared library when the first function in the second shared library is called. Translating, by using the translation function in the first shared library, the third function of the function interface in the third shared library and the function interface of the first function, to obtain the third function supported by the host machine. Wherein the function interface of the third function is the same as the function interface of the second function; and the third function is executed.

Optionally, in some possible implementation manners of the present disclosure, the foregoing memory 503 is further configured to store a fifth shared library supported by the host machine, where the second function includes a fourth shared library that is supported by the client. The instruction of the four functions; the processor 502 is further configured to: translate the instruction included in the second function, which is the fourth function in the fourth shared library, into an instruction to invoke the fifth function in the fifth shared library, where The functions of the fourth function and the functions of the fifth function are the same, or the function functions and function interfaces of the fourth function and the fifth function are the same.

Optionally, in another possible implementation manner of the present invention, the foregoing memory 503 is further configured to store a fifth shared library supported by the host, where the third function invokes a fourth shared library supported by the client. In the fourth function, the processor 502 is further configured to: translate the instruction included in the third function, which is the fourth function in the fourth shared library supported by the client, into the third function to invoke the fifth shared library. The instruction of the fifth function; the function of the fourth function and the function of the fifth function are the same, or the function and function interface of the fourth function and the fifth function are the same.

Optionally, in some possible implementation manners of the present invention, the foregoing memory 503 is further configured to store the second main program supported by the host, if the second function includes the first one of the first main programs supported by the client. The six function instruction, the processor 502 is also used to:

Translating, by the foregoing second function, the instruction for calling the sixth function in the first main program supported by the client to an instruction for calling the seventh function in the second main program, wherein the sixth function and the foregoing The function of the seventh function has the same function, or the sixth function and the seventh function described above The function functions and function interfaces are the same.

Optionally, in another possible implementation manner of the present invention, the foregoing memory 503 is further configured to store a second main program supported by the host, where the third function invokes a first main program supported by the client. The processor 502 is further configured to: translate the instruction included in the third function, which is the sixth function in the first main program supported by the client, into the third function, and invoke the second main program. The function of the seventh function is the same as the function of the sixth function and the function function of the seventh function.

Optionally, in some possible implementation manners of the present invention, when the second function includes a function pointer of the tenth function supported by the client as an incoming parameter, the calling instruction of the eighth function supported by the host is invoked. The processor 502 is further configured to: use the function pointer of the tenth function supported by the client as the incoming parameter, and invoke the calling instruction of the eighth function supported by the host, and replace it with the host machine. The function pointer of the ninth function is used as an input parameter to call the call instruction of the eighth function supported by the host machine; when the ninth function is called, the ninth function is executed to invoke the translation function in the first shared library. Translating the above tenth function to obtain the eleventh function supported by the above host.

Optionally, in some possible implementation manners of the present invention, when the second function includes a call instruction that invokes a twelfth function with the first structure as an incoming parameter, the processor 502 is further configured to use the first structure The body invokes the call instruction of the twelfth function as an incoming parameter, and translates to call the twelfth function with the second structure as the incoming parameter, wherein the first structure includes the second structure A subset of the fields that the body contains. The first structure is a structure supported by the client, and the second structure is a structure supported by the host, and the twelfth function is a function supported by the host. Alternatively, the first structure may be a structure supported by the host, and the second structure is a structure supported by the client, and the twelfth function is a function supported by the client.

Optionally, in another possible implementation manner of the present invention, when the second function includes a call instruction that invokes a thirteenth function by using the first structure body pointer as an incoming parameter, the processor 502 is further configured to use the host machine. The above calling instruction of the thirteenth function is invoked by using the first structure body pointer as an incoming parameter, and is translated into a call instruction of the thirteenth function by using the second structure body pointer as an incoming parameter; The first structure body pointer points to the first structure body, and the second structure body pointer points to the second structure body, wherein the first structure body includes a domain that is a subset of the domains included in the second structure body. The first structure is a structure supported by a client, and the second structure is a structure supported by a host, and the thirteenth function is a function supported by the host. Or the first structure is a structure supported by the host, and the second structure is a structure supported by the client, and the thirteenth function is a function supported by the client.

Optionally, in some possible implementation manners of the present invention, the processor 502 is further configured to: before the first function in the third shared library is translated to obtain the second function, to the foregoing third shared library and the host machine Symbolic relocation of the global variable of the same name.

For example, the processor 502 is further configured to: if the first global variable included in the third shared library and the N global variable of the host have the same name, first load the first global variable and the N global variables. The address of the global variable is set to the above N global variables and the public address of the first global variable;

For another example, the processor 502 is further configured to relocate the address of the first global variable in the third shared library to the second global variable in the second shared library after being loaded in the second shared library. An address, wherein the first global variable and the second global variable are declared the same.

It is to be understood that the functions of the functional modules of the host device 500 of the present embodiment may be specifically implemented according to the method in the foregoing method embodiments. For the specific implementation process, reference may be made to the related description of the foregoing method embodiments, and details are not described herein again.

It can be seen that, in the solution of the embodiment, the second shared library supported by the host 500 can be regarded as a pseudo shared library of the third shared library supported by the client, because the second shared library The first function is the same as the function interface of the second function in the third shared library, and the first function in the second shared library is mainly used to trigger the calling of the first shared library to translate the third shared library. A function having the same function interface, and this allows the main program or other shared library on the host 500 to be a bridge of the second shared library, and the indirect call is first by calling a function in the second shared library. Another function having the same function interface in the third shared library translated by the translation function in the shared library, since the second shared library is supported by the host 500, the main program or other shared library on the host 500 can Identify and directly call functions in the second shared library, which can be implemented even if it is not dependent on the client The main program of the three shared libraries or other dependent shared libraries for translation, or indirect calls to the third shared library on the client, which greatly reduces the support of the third shared library and the client (or other Strong dependencies between related shared libraries), which greatly reduces the amount of translation code, which can improve the efficiency of binary translation execution, thereby improving the user experience.

Referring to FIG. 6, FIG. 6 is a structural block diagram of a host machine 600 according to another embodiment of the present invention. The host machine 600 can include at least one processor 601, at least one network interface 604, a memory 605, and at least one communication bus 602. Communication bus 602 is used to implement connection communication between these components. Wherein, the host machine 600 optionally includes a user interface 603, including a display (such as a touch screen, a liquid crystal display, a holographic or a projector, etc.), a pointing device (such as a mouse, a trackball touch panel or Touch screen, etc.), camera and/or sound pickup device, etc.

The memory 602 can include read only memory and random access memory and provides instructions and data to the processor 601. A portion of the memory 602 may also include a non-volatile random access memory.

In some implementations, the memory 605 stores the following elements, executable modules or data structures, or a subset thereof, or their extension set:

The operating system 6051 includes various system programs for implementing various basic services and processing hardware-based tasks.

The application module 6052 includes various applications for implementing various application services.

The application module 6052 may include, but is not limited to, at least one of the storage unit 410, the calling unit 420, the translation unit 430, the execution unit 440, and the relocation unit 450.

In the embodiment of the present invention, the host machine 600 and the client support different instruction set architectures. The memory 605 is configured to store the first shared library supported by the host, the second shared library supported by the host, and the third shared library supported by the client.

Wherein, the first shared library includes a translation function.

In the embodiment of the present invention, the processor 601 executes the first function to invoke the translation in the first shared library when the first function in the second shared library is invoked by calling the program or instruction stored in the memory 605. a function: using the translation function in the first shared library called to translate the function function interface in the third shared library and the second function function interface of the first function Obtaining a third function supported by the host machine; wherein the function interface of the third function is the same as the function interface of the second function; and the third function is executed.

Optionally, in some possible implementation manners of the present invention, the foregoing memory 605 is further configured to store a fifth shared library supported by the host machine, where the second function includes a fourth shared library that is supported by the client. The instruction of the four functions; the processor 601 is further configured to: translate the instruction of the second function included in the second shared library included in the second function to an instruction that invokes the fifth function in the fifth shared library, wherein The functions of the fourth function and the functions of the fifth function are the same, or the function functions and function interfaces of the fourth function and the fifth function are the same.

Optionally, in another possible implementation manner of the present invention, the foregoing memory 605 is further configured to store a fifth shared library supported by the host, where the third function invokes a fourth shared library supported by the client. In the fourth function, the processor 601 is further configured to: translate the instruction included in the third function, which is the fourth function in the fourth shared library supported by the client, into the third function to invoke the fifth shared library. The instruction of the fifth function; the function of the fourth function and the function of the fifth function are the same, or the function and function interface of the fourth function and the fifth function are the same.

Optionally, in some possible implementation manners of the present invention, the foregoing memory 605 is further configured to store the second main program supported by the host, if the second function includes the first one of the first main programs supported by the client. The six function instruction, the processor 601 is also used to:

Optionally, in another possible implementation manner of the present invention, the foregoing memory 605 is further configured to store a second main program supported by the host, where the third function invokes a first main program supported by the client. The processor 601 is further configured to: translate the instruction included in the third function, which is the sixth function included in the first main program supported by the client, into the third function, and invoke the second main program. The function of the seventh function is the same as the function of the sixth function and the function function of the seventh function.

Optionally, in some possible implementation manners of the present invention, when the foregoing second function includes the foregoing The function pointer of the tenth function supported by the home machine is used as an incoming parameter to invoke the calling instruction of the eighth function supported by the host, and the processor 601 can also be used to: the function of the tenth function supported by the above client. The pointer is used as an incoming parameter, and the calling instruction of the eighth function supported by the above host is called, and the function pointer of the ninth function supported by the host is used as an incoming parameter to call the eighth function supported by the host. Calling the instruction; when the ninth function is called, executing the ninth function to invoke the translation function in the first shared library to translate the tenth function to obtain the eleventh function supported by the host.

Optionally, in some possible implementation manners of the present invention, when the second function includes a call instruction that invokes a twelfth function with the first structure as an incoming parameter, the processor 601 is further configured to use the first structure The body invokes the call instruction of the twelfth function as an incoming parameter, and translates to call the twelfth function with the second structure as the incoming parameter, wherein the first structure includes the second structure A subset of the fields that the body contains. The first structure is a structure supported by the client, and the second structure is a structure supported by the host, and the twelfth function is a function supported by the host. Alternatively, the first structure may be a structure supported by the host, and the second structure is a structure supported by the client, and the twelfth function is a function supported by the client.

Optionally, in another possible implementation manner of the present invention, when the second function includes a call instruction that invokes a thirteenth function by using the first structure body pointer as an incoming parameter, the processor 601 is further configured to use the host machine. The calling instruction that invokes the thirteenth function by using the first structure body pointer as an incoming parameter is translated into a calling instruction that calls the thirteenth function with the second structure body pointer as an incoming parameter; wherein the first structure body pointer Pointing to the first structure, the second structure pointer points to the second structure, wherein the first structure includes a domain that is a subset of the domains included in the second structure. The first structure is a structure supported by a client, and the second structure is a structure supported by a host, and the thirteenth function is a function supported by the host. Or the first structure is a structure supported by the host, and the second structure is a structure supported by the client, and the thirteenth function is a function supported by the client.

Optionally, in some possible implementation manners of the present invention, the processor 601 is further configured to: before the first function in the third shared library is translated to obtain the second function, to the foregoing third shared library and the foregoing The host's global variable of the same name is symbol relocated.

For example, the processor 601 is further configured to: if the first global variable included in the third shared library and the N global variables of the host have the same name, first load the first global variable and the N global variables The address of the global variable is set to the above N global variables and the public address of the first global variable.

For another example, the processor 601 is further configured to relocate an address of the first global variable in the third shared library to a second global variable in the second shared library after being loaded in the second shared library. An address, wherein the first global variable and the second global variable are declared the same.

It is to be understood that the functions of the functional modules of the host device 600 of the present embodiment may be specifically implemented according to the method in the foregoing method embodiments. For the specific implementation process, reference may be made to the related description of the foregoing method embodiments, and details are not described herein again.

It can be seen that, in the solution of the embodiment, the second shared library supported by the host 600 can be regarded as a pseudo shared library of the third shared library supported by the client, because the second shared library The first function is the same as the function interface of the second function in the third shared library, and the first function in the second shared library is mainly used to trigger the calling of the first shared library to translate the third shared library. A function having the same function interface, and this allows the main program or other shared library on the host machine 600 to be the second shared library as a bridge, and the indirect call is first by calling a function in the second shared library. Another function having the same function interface in the third shared library translated by the translation function in the shared library, since the second shared library is supported by the host 600, the main program or other shared library on the host machine 600 can Identifying and directly calling functions in the second shared library, so that even if the main program on the client that depends on the third shared library or other dependent shared libraries is not translated, the third total on the client The library indirectly calls the execution, which greatly reduces the strong dependency between the third shared library and the client's supporting main program (or other related shared libraries), which helps to greatly reduce the amount of translation code, thereby improving The efficiency of binary translation execution, which in turn enhances the user experience.

Referring to FIG. 7, an embodiment of the present invention further provides a communication system, which may include: a first computing node 710 and a second computing node 720. The first computing node 710 and the second computing node 720 can be interconnected by an internetwork.

The second computing node 720 and the first computing node 710 support different instruction collectives. Department architecture. The second computing node 720 includes a first shared library supported by the second computing node 720 and a second shared library supported by the second computing node 720. Wherein, the first shared library includes a translation function.

The first computing node 710 is configured to send, to the second computing node 720, a third shared library supported by the first computing node 710.

a second computing node 720, configured to receive a third shared library from the first computing node 710; when the first function in the second shared library is invoked, execute the first function to invoke the first shared library Translating a function; using the translation function in the first shared library mentioned above, translating the function function interface in the third shared library with the second function function interface of the first function to obtain the second computing node The third function supported by 720; the function interface of the third function is the same as the function interface of the second function; and the third function is executed.

In some possible implementation manners of the present invention, the second computing node 720 further includes a fifth shared library supported by the second computing node 720; if the second function includes the fourth supported by the first computing node 710 The instruction of the fourth function in the shared library, the second computing node 720 is further configured to translate the instruction included in the second function, which is the fourth function in the fourth shared library, into the calling the fifth shared library. The instruction of the fifth function, wherein the functions of the fourth function and the function of the fifth function are the same, or the function functions and function interfaces of the fourth function and the fifth function are the same. It can be understood that the foregoing second computing node 720 translates the instruction of the second function included in the second shared library that is included in the second function into an instruction that invokes the fifth function in the fifth shared library, which is substantially It is a library function packaging technology, that is, the call of a function in a shared library supported by the first computing node 710 is replaced by the function function or function function of a shared library supported by the second computing node 720. The function interface is the same function call, which is beneficial to improve the utilization of the local shared library of the second computing node 720, further reducing the translation of the function code of the shared library associated with the first computing node 710, thereby further reducing the code. Translation volume.

In another possible implementation manner of the present invention, the second computing node 720 further includes a fifth shared library supported by the second computing node 720, where the third function invokes the fourth supported by the first computing node 710. When the fourth function in the library is shared, the second computing node 720 is further configured to translate the instruction of the fourth function included in the third shared library supported by the first computing node 710 into the foregoing The third function calls the instruction of the fifth function in the fifth shared library; wherein the function function and the function interface of the fourth function and the fifth function are the same, or the functions of the fourth function and the fifth function are the same. It can be understood that the foregoing second computing node 720 translates the instruction of the third function included in the third function, which is called the fourth function in the fourth shared library, into an instruction that invokes the fifth function in the fifth shared library, in essence, It can be seen as a library function packaging technique, that is, the function of a function in a shared library supported by the first computing node 710 can be replaced with a function function in a shared library supported by the second computing node 720. The same or the function function and the function interface are the same function call, which is beneficial to improve the utilization of the second shared node 720 local shared library, further reducing the translation of the function code of the shared library associated with the first computing node 710, and thus Help to further reduce the amount of code translation.

In some possible implementation manners of the present invention, the second computing node 720 further includes a second main program supported by the second computing node 720, where the second function includes calling the first supported by the first computing node 710. The second function node 720 is further configured to translate the instruction of the sixth function included in the first main program supported by the first computing node 710, which is included in the second function, into the instruction of the sixth function in the main program. The instruction of the seventh function in the second main program is called, wherein the functions of the sixth function and the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same. It can be understood that the above-mentioned second function includes the instruction that invokes the sixth function in the first main program supported by the first computing node 710, and translates the instruction into the seventh function in the second main program, essentially It can be regarded as a library function packaging technology, that is, the call of a function in the main program supported by the first computing node 710 is replaced by the function function or the function function in the main program supported by the second computing node 720. The function interface is the same function call, which is beneficial to improve the utilization of the local shared library of the second computing node 720, further reducing the translation of the function code of the shared library associated with the first computing node 710, thereby further reducing the code. Translation volume.

In another possible implementation manner of the present invention, the second computing node 720 further includes a second main program supported by the second computing node 720, where the third function invokes the first supported by the first computing node 710. In the sixth function of the main program, the second computing node 720 is further configured to translate the instruction included in the third function, which is the sixth function in the first main program supported by the first computing node 710, into the foregoing The three functions call the call of the seventh function in the second main program, the functions of the sixth function and the function of the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same. It can be understood that the above-mentioned third function includes the instruction that invokes the sixth function in the first main program supported by the first computing node 710, and translates the instruction into the seventh function in the second main program. Essentially, it can be regarded as a library function packaging technique, that is, the function of a function in the main program supported by the first computing node 710 can be replaced with the function function in the main program supported by the second computing node 720. The same or the function function and the function interface are the same function call, which is beneficial to improve the utilization of the local shared library of the second computing node 720, further reducing the translation of the function code of the shared library associated with the first computing node 710, and further Help to further reduce the amount of code translation.

In some possible implementation manners of the present invention, when the second function includes a function pointer of the tenth function supported by the first computing node 710 as an incoming parameter, the eighth function supported by the second computing node 720 is invoked. The second computing node 720 is further configured to use the function pointer of the tenth function supported by the first computing node 710 as an incoming parameter to invoke the eighth function supported by the second computing node 720. The instruction is invoked, and the function pointer of the ninth function supported by the second computing node 720 is used as an incoming parameter to invoke the calling instruction of the eighth function supported by the second computing node 720. When the ninth function is called, the second computing node 720 executes the ninth function to invoke the translation function in the first shared library to translate the tenth function, and the second computing node 720 supports the second computing node 720. In the eleventh function, the second computing node 720 executes the eleventh function described above. It can be understood that, in the above scenario where the function pointer exists, the introduction of the ninth function as a bridge is beneficial to realizing the translation of the function pointed to by the function pointer at a suitable timing, which is beneficial to avoid errors as much as possible.

In some possible implementation manners of the present invention, when the third year function includes a function pointer of the function S01 supported by the second computing node 720 as an incoming parameter, the second computing node is invoked. The calling instruction of the S02 function supported by 720, when the above function S01 is called, the second computing node 720 executes the above function S01, and the second computing node 720 does not translate the function S001.

In some possible implementation manners of the present invention, when the second function includes a call instruction that invokes a twelfth function with the first structure as an incoming parameter, the second computing node 720 is further configured to: The body invokes the call instruction of the twelfth function as an incoming parameter, and translates to call the twelfth function with the second structure as the incoming parameter, and the first structure includes the domain containing the second structure A subset of the domain. The first structure is a structure supported by the first computing node 710, and the second structure is a structure supported by the second computing node 720, and the twelfth function is supported by the second computing node 720. a function; or the first structure is a structure supported by the second computing node 720, and the second structure is a structure supported by the first computing node 710, and the twelfth function is the first calculating The function supported by node 710. For example, the domain included in the first structure may be the same as the domain included in the second structure.

In some possible implementation manners of the present invention, when the second function includes a call instruction that invokes a thirteenth function with the first structure body pointer as an incoming parameter, the second computing node 720 is further configured to: The structure pointer calls the call instruction of the thirteenth function as an incoming parameter, and translates to a call instruction that calls the thirteenth function with the second structure body pointer as an incoming parameter. The first structure pointer points to the first structure, the second structure pointer points to the second structure, and the first structure includes a field that is a subset of the domains included in the second structure. The first structure is a structure supported by the first computing node 710, and the second structure is a structure supported by the second computing node 720, and the thirteenth function is supported by the second computing node 720. function. Or the first structure is a structure supported by the second computing node 720, and the second structure is a structure supported by the first computing node 710, and the thirteenth function is a function supported by the first computing node 710. . For example, the domain included in the first structure may be the same as the domain included in the second structure.

In some possible implementation manners of the present invention, when the incoming parameter of the second function includes the third structure, the second computing node 720 is further configured to use the third parameter as the second function. The structure is replaced by a fourth structure, and the domain included in the third structure is a subset of domains included in the fourth structure; wherein the fourth structure is a structure supported by the first computing node 710, and the above The third structure is a structure supported by the second computing node 720. For example, the above third structural package The domain included may be the same as the domain included in the fourth structure described above.

In some possible implementations of the present invention, when the incoming parameter of the second function includes the third structure pointer, the second computing node 720 is further configured to use the third parameter as the incoming parameter of the second function. The structure pointer is replaced with a fourth structure body pointer, the fourth structure body pointer is directed to the fourth structure body, the third structure body pointer is directed to the third structure body, and the third structure body includes a domain containing the fourth structure body A subset of the domain. The fourth structure is a structure supported by the first computing node 710, and the third structure is a structure supported by the second computing node 720. For example, the domain included in the third structure described above may be the same as the domain included in the fourth structure.

In addition, in some possible implementation manners of the present invention, before the first function in the third shared library is translated to obtain the second function, the second computing node 720 is further configured to use the third shared library and The global variable of the same name of the second computing node 720 described above performs symbol relocation.

For example, the second computing node 720 performing symbol relocation on the global variable of the same name of the third shared library and the second computing node 720 includes: if the third shared library includes the first global variable and the second computing node 720 The N global variables have the same name, and the second computing node 720 sets the addresses of the first global variable and the first global variable loaded among the N global variables to the N global variables and the first global variable. Public address.

For another example, the second computing node 720 performing symbol relocation on the global variable of the same name of the third shared library and the second computing node 720 includes: after being loaded in the second shared library, the second computing node 720 The address of the first global variable in the third shared library is relocated to the address of the second global variable in the second shared library, wherein the declaration of the first global variable and the second global variable is the same.

The second computing node 720 and the first computing node 710 of the embodiment of the present invention support different instruction set architectures. For example, the second computing node 720 and the first computing node 710 can respectively support one of the following instruction set architectures. Kinds: POWER instruction set architecture, x86 instruction set architecture, Loongson instruction set architecture and MIPS instruction set architecture.

It can be seen that, in the solution of the embodiment, the second computing node 720 supporting the different instruction set architectures and the first computing node 710 can mutually transmit the shared libraries supported by each, for example, the foregoing first computing node 710 performs the second computing. The node 720 passes the third shared library, wherein the second shared library supported by the second computing node 720 introduced in the second computing node 720 can be regarded as a pseudo shared by the third shared library supported by the first computing node 710. a library, because the first function in the second shared library and the function interface of the second function in the third shared library are the same, the first function in the second shared library is mainly used to trigger the first share to be called The library is to translate the function of the third shared library with the same function interface, and this can make the main program or other shared library on the second computing node 720, the second shared library can be used as a bridge, by calling the second shared library. a function in the indirect call to another function in the third shared library translated by the translation function in the first shared library having the same function interface, since the second shared library is the second computational section Supported by 720, therefore, the main program or other shared library on the second computing node 720 can recognize and directly invoke functions in the second shared library, such that even if the third computing library is not dependent on the first computing node 710 The program or other dependent shared library is translated, and the third shared library on the first computing node 710 can also be invoked indirectly, which greatly reduces the supporting main program of the third shared library and the first computing node 710 ( Strong dependencies between other related shared libraries), which greatly reduces the amount of translation code, which improves the efficiency of binary translation execution and thus improves the user experience.

Further, since the first shared library includes a translation function, that is, the binary translator is compiled into the first shared library, when the function in the third shared library supported by the first computing node 710 is called, the first shared library is The related functions are called for dynamic translation, which is beneficial to improve the pertinence and effectiveness of translation, and is beneficial to reduce the amount of invalid translation work, thereby further reducing the amount of translation code, thereby further improving the execution efficiency of binary translation, thereby further enhancing users. Experience.

The embodiment of the present invention further provides a computer storage medium, wherein the computer storage medium may store a program, where the program includes some or all of the steps of the binary translation execution method of any one of the shared libraries described in the foregoing method embodiments. .

It should be noted that, for the foregoing method embodiments, for the sake of simple description, they are all expressed as a series of action combinations, but those skilled in the art should understand that the present invention is not limited by the described action sequence. Because certain steps may be performed in other sequences or concurrently in accordance with the present invention. In addition, those skilled in the art should also understand that the embodiments described in the specification are all preferred embodiments, and the actions and modules involved are not necessarily required by the present invention.

In the above embodiments, the descriptions of the various embodiments are different, and the details that are not detailed in a certain embodiment can be referred to the related descriptions of other embodiments.

In the several embodiments provided herein, it should be understood that the disclosed apparatus may be implemented in other ways. For example, the device embodiments described above are merely illustrative. For example, the division of the unit is only a logical function division. In actual implementation, there may be another division manner, for example, multiple units or components may be combined or may be Integrate into another system, or some features can be ignored or not executed. In addition, the mutual coupling or direct coupling or communication connection shown or discussed may be an indirect coupling or communication connection through some interface, device or unit, and may be electrical or otherwise.

The units described as separate components may or may not be physically separated, and the components displayed 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 of the embodiment.

In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above integrated unit can be implemented in the form of hardware or in the form of a software functional unit.

The integrated unit, if implemented in the form of a software functional unit and sold or used as a standalone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present invention is essential or the part contributing to the prior art or the entire technical solution. The portion or portion may be embodied in the form of a software product stored in a storage medium, including instructions for causing a computer device (which may be a personal computer, server or network device, etc.) to perform various embodiments of the present invention. All or part of the steps of the method described. The foregoing storage medium includes: a U disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a removable hard disk, a magnetic disk, or an optical disk, and the like. .

The above embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to be limiting; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art will understand that The technical solutions described in the embodiments are modified, or some of the technical features are replaced by equivalents; and the modifications or substitutions do not deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

A binary translation execution method of a shared library, wherein the method is applied to a host machine, where the host machine includes a first shared library supported by the host machine, a second shared library supported by the host machine, and a third shared library supported by the client, the first shared library including a translation function, the host and the client supporting different instruction set architectures,

The method includes:

When the first function in the second shared library is called, the host executes the first function to invoke a translation function in the first shared library;

The host machine translates a function function in the third shared library with a second function function of the first function by using a translation function in the first shared library of the call to obtain a second function a third function supported by the host; wherein a function interface of the third function and a function interface of the second function are the same;

The host executes the third function.
The method according to claim 1, wherein said host machine further comprises a fifth shared library supported by said host; if said second function comprises calling said fourth shared library supported by said client The instruction of the fourth function, the step of translating the second function, further includes:

The host translates, by the second function, an instruction that calls a fourth function in the fourth shared library into an instruction that invokes a fifth function in the fifth shared library, wherein the fourth The function has the same function as the function of the fifth function, or the function functions and function interfaces of the fourth function and the fifth function are the same.
The method according to claim 1, wherein the host machine further comprises a fifth shared library supported by the host, when the third function calls a fourth shared library supported by the client. In the fourth function, the method further includes:

Transmitting, by the host machine, an instruction of the third function included in the third function that is called by the third function to the third function in the fifth shared library An instruction; wherein the functions of the fourth function and the fifth function are the same, or the function functions and function interfaces of the fourth function and the fifth function are the same.
The method according to claim 1, wherein said host machine further comprises a second main program supported by said host, if said second function comprises calling said first main program supported by said client The instruction of the sixth function, the step of translating the second function, further includes:

The host translating, by the second function, the instruction that invokes the sixth function in the first main program supported by the client into an instruction that invokes the seventh function in the second main program, The functions of the sixth function and the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same.
The method according to claim 1, wherein said host machine further comprises a second main program supported by said host, when said third function calls said first main program supported by said client In the sixth function, the method further includes:

The host translates, by the third function, an instruction that calls a sixth function in the first main program supported by the client into a third function, and invokes a seventh function in the second main program. And the functions of the sixth function and the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same.
The method according to claim 1, wherein when said second function comprises a function pointer of a tenth function supported by said client as an incoming parameter to invoke an eighth function supported by said host The step of translating the second function, the method further includes: the host uses the function pointer of the tenth function supported by the client as an incoming parameter to invoke the host support The calling instruction of the eighth function is replaced by a function pointer of the ninth function supported by the host as an incoming parameter to invoke a calling instruction of the eighth function supported by the host;

Wherein, when the ninth function is called, the host executes the ninth function to invoke a translation function in the first shared library to translate the tenth function, to obtain the host support In an eleventh function, the host executes the eleventh function.
The method according to claim 1, wherein when said second function comprises a call instruction for calling a twelfth function with the first structure as an incoming parameter, the step of translating said second function is further include:

Transmitting, by the host machine, the calling instruction that invokes the twelfth function with the first structure as an incoming parameter, and calling the calling instruction of the twelfth function with the second structural body as an incoming parameter, the first The domain included in the structure is a subset of the domains included in the second structure;

The first structure is a structure supported by the client, and the second structure is a structure supported by the host, and the twelfth function is a function supported by the host. ;

Or the first structure is a structure supported by the host, and the second structure is a structure supported by the client, and the twelfth function is supported by the client The function.
The method of claim 1 wherein

When the second function includes a call instruction that invokes the thirteenth function with the first structure body pointer as an incoming parameter, the step of translating the second function further includes: the host machine The structure pointer calls the call instruction of the thirteenth function as an incoming parameter, and translates to a call instruction that calls the thirteenth function with the second structure body pointer as an incoming parameter;

Wherein the first structure body pointer points to the first structure body, the second structure body pointer points to the second structure body, and the first structure body includes a domain that is a subset of the domain included in the second structure body ;

Wherein the first structure is a structure supported by a client, and the second structure is a structure supported by a host, and the thirteenth function is a function supported by the host; or The first structure is a structure supported by the host, and the second structure is a structure supported by the client, and the thirteenth function is a function supported by the client.
The method according to claim 1, wherein when the incoming parameter of the second function comprises a third structure, the method further comprises: the host machine as an incoming parameter of the second function The third structure is replaced with a fourth structure, and the third structure includes a domain that is a subset of the domains included in the fourth structure;

The fourth structure is a structure supported by a client, and the third structure is a structure supported by a host.
The method of claim 1 wherein when the incoming parameter of the second function includes a third struct pointer, the method further comprises: the host will pass in as the second function The third structure body pointer of the parameter is replaced by a fourth structure body pointer, the fourth structure body pointer is directed to the fourth structure body, the third structure body pointer is directed to the third structure body, and the third structure body includes The domain is a subset of the domains included in the fourth structure;

The fourth structure is a structure supported by a client, and the third structure is a structure supported by a host.
A method according to any one of claims 1 to 10, characterized in that

Before the first function in the third shared library is translated to obtain the second function, the method further includes: the host performing symbol weight on the third shared library and the host with the same name global variable Positioning.
The method of claim 11, wherein the symbol relocating the same-named global variable of the third shared library and the host by the host comprises: if the third shared library includes the first global variable And the host has the same name as the N global variables of the host, and the host sets an address of the first global variable and the first global variable loaded among the N global variables to the N global variables. And a public address of the first global variable.
The method of claim 11, wherein the symbol relocation of the third shared library and the host of the same name global variable by the host machine comprises: after being loaded in the second shared library, Resetting the address of the first global variable in the third shared library to the address of the second global variable in the second shared library, wherein the first global variable and the second The declaration of global variables is the same.
A host machine, characterized in that the host machine comprises:

a storage unit, configured to store a first shared library supported by the host, a second shared library supported by the host, and a third shared library supported by the client, where the first shared library includes a translation function, the sink The host and the client support different instruction set architectures;

a calling unit, configured to: when the first function in the second shared library is called, execute the first function to invoke a translation function in the first shared library;

a translation unit, configured to translate, by using a translation function in the first shared library of the call, a function of the function interface of the third shared library and a second function of the first function to obtain a a third function supported by the host; wherein a function interface of the third function and a function interface of the second function are the same;

An execution unit, configured to execute the third function.
The host machine according to claim 14, wherein said storage unit is further configured to store And storing, by the host, a fifth shared library; wherein, if the second function includes an instruction to invoke a fourth function in a fourth shared library supported by the client;

The translation unit is also used to:

Translating, by the second function, an instruction that invokes a fourth function in the fourth shared library into an instruction that invokes a fifth function in the fifth shared library, wherein the fourth function and the The functions of the fifth function are the same, or the function functions and function interfaces of the fourth function and the fifth function are the same.
The host according to claim 14, wherein the storage unit is further configured to store a fifth shared library supported by the host, and when the third function calls a fourth shared library supported by the client In the fourth function, the translation unit is also used to:

Translating, by the third function, an instruction that invokes a fourth function in a fourth shared library supported by the client into an instruction that the third function calls a fifth function in the fifth shared library; The functions of the fourth function and the function of the fifth function are the same, or the function functions and function interfaces of the fourth function and the fifth function are the same.
The host according to claim 14, wherein said storage unit is further configured to store a second main program supported by said host, if said second function comprises invoking said first host supported by said client An instruction of a sixth function in the program, the translation unit is further configured to:

Translating, by the second function, the instruction that invokes the sixth function in the first main program supported by the client into an instruction that invokes a seventh function in the second main program, wherein The functions of the sixth function and the function of the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same.
The host according to claim 14, wherein said storage unit is further configured to store a second main program supported by said host, and when said third function calls said first main program supported by said client In the sixth function, the translation unit is also used to:

Translating, by the third function, an instruction that invokes a sixth function in the first main program supported by the client into a call of the third function in the third main program The functions of the sixth function and the seventh function are the same, or the function functions and function interfaces of the sixth function and the seventh function are the same.
The host machine according to claim 14, wherein when said second function includes a function pointer of a tenth function supported by said client as an incoming parameter to call an eighth function supported by said host Calling instruction, the translation unit is also used to:

The function pointer of the tenth function supported by the client is used as an incoming parameter, and the calling instruction of the eighth function supported by the host is invoked, and the function of the ninth function supported by the host is replaced. a pointer as an incoming parameter to invoke a call instruction of an eighth function supported by the host; when the ninth function is called, executing the ninth function to invoke a translation function pair in the first shared library The tenth function is translated to obtain an eleventh function supported by the host.
The host machine according to claim 14, wherein when said second function comprises a call instruction for calling a twelfth function with the first structure as an incoming parameter, said translation unit is further configured to: The first structure body calls the call instruction of the twelfth function as an incoming parameter, and translates into a call instruction that calls the twelfth function with the second structure body as an incoming parameter, wherein the first structure body includes a domain a subset of domains included in the second structure;

The first structure is a structure supported by the client, and the second structure is a structure supported by the host, and the twelfth function is a function supported by the host. ;

Or the first structure is a structure supported by the host, and the second structure is a structure supported by the client, and the twelfth function is supported by the client The function.
The host machine according to claim 14, wherein when said second function comprises a call instruction for calling a thirteenth function with the first structure body pointer as an incoming parameter,

The translation unit is further configured to: the host machine invokes the calling instruction that invokes the thirteenth function by using the first structure body pointer as an incoming parameter, and translates to calling the tenth with the second structure body pointer as an incoming parameter a call instruction of a three function; wherein the first structure body pointer points to the first structure body, and the second structure body pointer points to the second structure body, wherein the first structure body includes a domain a subset of the fields contained in the structure;

The first structure is a structure supported by a client, and the second structure is a structure supported by a host, and the thirteenth function is a function supported by the host;

Or the first structure is a structure supported by the host, and the second structure is a client A structure supported by the machine, and the thirteenth function is a function supported by the client.
A host machine according to any one of claims 14 to 21, characterized in that

The host machine further includes: a relocation unit, configured to perform the third-order shared library and the same-named global variable of the host machine before translating the first function in the third shared library to obtain the second function Symbol relocation.
A host according to claim 22, wherein

The relocation unit is specifically configured to: if the first global variable included in the third shared library and the N global variables of the host have the same name, the first global variable and the N global variables are included The address of the first loaded global variable is set to the public address of the N global variables and the first global variable;

or,

The relocation unit is specifically configured to relocate an address of the first global variable in the third shared library to a second in the second shared library after being loaded in the second shared library The address of the global variable, wherein the declaration of the first global variable and the second global variable are the same.