WO2015010479A1

WO2015010479A1 - Application program transplantation method based on virtual instructions

Info

Publication number: WO2015010479A1
Application number: PCT/CN2014/073905
Authority: WO
Inventors: 徐滢
Original assignee: 成都品果科技有限公司
Priority date: 2013-07-25
Filing date: 2014-03-21
Publication date: 2015-01-29
Also published as: CN103365665A

Abstract

Disclosed is an application program transplantation method based on virtual instructions, which relates to the technology of program transplantation and aims to provide a method capable of quickly and conveniently transplanting an application program of a Windows platform onto other application platforms such as an ios platform or an Android platform. The adopted technical solution comprises the steps as follows: step 101: in a Windows system, converting application programs into assembly codes; step 102: in the Windows system, converting the assembly codes into corresponding virtual instructions one by one according to the syntax of a set of virtual instruction sets, thereby obtaining virtualized assembly codes; and step 103: copying the virtualized assembly codes onto other application platforms and then operating the virtualized assembly codes after compilation, wherein at least one instruction in the virtual instruction set corresponds to an instruction in an assembly instruction set, and each instruction in the virtual instruction set is a macro or a function written in C language, and comprises at least one C language instruction.

Description

An application migration method based on virtual instruction

TECHNICAL FIELD The present invention relates to program porting techniques, and more particularly to a convenient virtual instruction based application porting method. BACKGROUND OF THE INVENTION With the popularity and performance of smartphones, consumers are hoping to run more applications on mobile platforms. Free applications that run on Windows systems can also run on mobile platforms. The current mainstream platforms for mobile phones include the lOS system and the AndroKi system. If you directly develop application software, writing code suitable for the mobile platform is time-consuming and energy-intensive. It is likely that such an application for mobile platforms has not yet been developed, and consumers are paying attention to another application. In the case of this, then obviously this does not have market benefits. Therefore, there is a need for a method for quickly and easily porting applications of the Windows platform to other application platforms such as the lOS platform or the Android platform. SUMMARY OF THE INVENTION The technical problem to be solved by the present invention is: To solve the above problems, an application migration method based on a virtual instruction is provided. The technical solution adopted by the present invention is as follows:

Step 101: Convert the application to assembly code on a Windows system;

Step 102: In the Windows system, the assembly code is converted into corresponding virtual instructions one by one according to the syntax of a set of virtual instruction sets, thereby obtaining the virtualized assembly code;

Step 103: Copy the virtualized assembly code to another application platform, and compile and run;

At least one instruction in the virtual instruction set corresponds to one instruction in the assembly instruction set; Each instruction in the virtual instruction set is a macro or function written in C language, and includes at least one C language instruction.

Preferably, the other application platform is an iOS system or an Android system.

Preferably, the assembly instruction set is an Intel x86 assembly instruction set.

In summary, due to the adoption of the above technical solution, the beneficial effects of the present invention are: Due to the use of a fixed virtual instruction set and its grammar, bulk virtualization of the assembly code corresponding to the application can be realized, and work efficiency is improved. The virtual instruction set and its grammar can be defined by those skilled in the art.

At least one instruction in the virtual instruction set corresponds to one of the existing standard assembly instructions, for example, the addition instruction in the virtual instruction set "add_dO(reg,immy' corresponds to the " _a dd _reg ,mim" instruction in the Intel x86 instruction set) Thus, the conversion of assembly instructions to virtual instructions can be quickly implemented.

Each instruction in the virtual instruction set is actually a macro or function written in C language, so that the converted virtual assembly code can run on all C-compatible platforms, such as iOS platform and Andr d platform. Of course, the platform compatible with C language is very wide. Basically, all platforms can run C language code. It can be seen that this method can be used to transplant applications on Windows platform to any other application platform.

DRAWINGS

The invention will be illustrated by way of example and with reference to the accompanying drawings in which:

Figure 1 is a flow chart of code processing of the present invention.

2 is a schematic diagram of correspondence between a part of the instructions of the Intel x86 assembly instruction set and a virtual instruction set instruction proposed by the present invention.

detailed description All features disclosed in this specification, or steps in all methods or processes disclosed, can be combined in any manner other than mutually exclusive features and/or steps. Any feature disclosed in this specification, unless specifically stated otherwise, may be replaced by other equivalents or alternative features having similar purposes. That is, unless specifically stated otherwise, each feature is only one example of a series of equivalent or similar features. As shown in FIG. 1, the application migration method disclosed by the present invention includes:

Step 101: Convert the application to assembly code on a Windows system;

Step 102: In the Windows system, each assembly instruction in the assembly code is converted into a corresponding virtual instruction one by one according to a grammar of a set of virtual instruction sets, thereby obtaining virtualized assembly code; Step 103: assembling the virtualized assembly code Copy to other application platforms and compile and run.

The virtual instruction set may be defined by a person skilled in the art according to its programming habit, but needs to satisfy the following basic conditions: at least one instruction in the virtual instruction set corresponds to one instruction in the assembly instruction set; and the virtual Each instruction in the instruction set is a macro or function written in C, containing at least one C language instruction. The virtual instruction set and the grammar embodiment disclosed by the present invention are now described by taking the Intel x86 assembly instruction set and the grammar as an example. However, those skilled in the art should not understand the present embodiment as a limitation of the present invention. A virtual instruction set aims to teach a person skilled in the art how to define a set of equivalent virtual instruction sets.

Those skilled in the art are aware that the general format of the instruction implemented by the Intel x86 assembly syntax is: mstl opl or inst2 opl, op2 or inst.3 ol , op2, op3 , where inst is an Intel x86 assembly instruction mnemonic, such as mov, add, and .... Op is the opcode, the opcode can be a register, it can be either memory or immediate. Virtuallnstname & flag? & ( & oprd? &:) namename

Flageflagsj? & type oprdreg |

Eflagsn? & f

Typemem & num memb { w j d | q 11 { numO ! 112

Aib|e|gjljo|p|c The above symbols are explained as follows _; virti!ailnst: virtual assembly

Reg: register

Ptr: memory pointer

Imm: immediately

Type: operand type

Mem: memory operand type

Num: the number of memory operands in the instruction operand (from zero)

Kbyte, byte

w:word _? word

d:dword, double word

q:qword» four words

t!tbyte, Αψ

X: multimedia instruction suffix

a: above, the unsigned number is greater than

b: below, the unsigned number is less than

e:equa.l, equal

g:greater, with number: greater than

l:less, the number of symbols is less than

0: overflow, operation overflow

p:panty _{5 The} least significant byte has an even number of bits

c: carry, unsigned number calculation carry

? As a placeholder, for example, d or 0 in add_ _d0 ( ); & is a connector, for example add_. d0 C ) add . and (10 is connected to add jiO to form a complete virtual instruction mnemonic .

With the definition of the above virtual instruction set, any tel x86 instruction can be rewritten as a virtual instruction. The above conversion principles are now explained by three different types of addition instructions; Among them, the generic force command add has the following form: add reg, imm; add reg, reg; add reg, mem? add mem? imm; add mem, reg, the flag register of its influence is c, ά ' , z _? S o reg: 3⁄4r, imm: _iL is the number, mem;

For the above Intd x86 instructions, the following virtual instructions can be defined that do not affect the flag bits:

add__dO(reg,imm) , add__dO(reg,reg) , add— d2(reg,mem), add— dl (mem, imm) , add dl(mem,reg). The virtual instruction that affects the z flag is s

Add_ z— dO(reg,imiii), add__ z__dO(reg,reg) ? Add_ z— d2(reg,nieiii), add— z___dl(mem,imm) , add __z___d 1 (mem, reg) , add nz d0(reg,imm), add

Nz___dO(reg,reg) , add__ nz__d2(reg,iiiem) , add__ nz___dl(meiii,imm) add— nz dl(mem,reg).

Virtual instructions that affect other flag bits are analogous.

Another example: Intel x86 floating-point addition instruction fadd has the following form: fadd reg, reg ; fadd mem32; fadd inem64, where mem32 is a 32-bit memory variable and mem64 is a 64-bit memory variable. The virtual instructions fadd d0(reg,reg), fadd d] (mem32) , fadd q 1 (mem64) can be defined accordingly. Each of the above virtual instructions is essentially a C-implemented macro or function. E.g

Add d0 (reg, imm) C language 'speech 33⁄4 is: #define add d0(reg,imm) reg imm.

Cc95 :

Mov edx,offset;

Objplaiieparamsi

Lea edx,[edx+4*edi+0xl0];

Mov eax,dword ptr;

Ds: [edx];

Mov eax.dword ptr ds: [eax]; movss;

Xmm0,dword ptr ds: [ea:x*4+fp1anestartparams];

Add dword ptr?

Ds: [edx], 0x4;

Mov eax,dword ptr ds:[ebx+0xlc] ;

Mov ecx, dword ptr;

Ds: [eax+OxOc] ι

Mov edx,dword ptr ds: [eax+OxlO];

Sub edx, ecx;

Sar

Edx, 0x3;

Cmp edi, edx; Jnb cdd5

Mov edx.dwor l ptr?

Ds: [edi*8+ecx] ;

Mov eax.dword ptr ds:[edx+0xl4];

Mov ecx, dword ptr?

Ds: [edx+0x4];

Neg eax;

Inc edi;

Add eax,dword ptr ss:[ebp-0x2c] ;

Imul

Eax,dword ptr ds: [edx+0x40]

Sub eax,dword ptr ds:[edx+( O ];

Cmp edi, dword?

Ptr ds:[ebx+Ox]0] ;

Movss dword ptr;

Ds: [eax*4+edx], xmm0?

Jl short cc95

By conversion we can get the following virtualization assembly code ₅ cc95 :

Inov dO(edx, offs( addr(objplanepararns)));

Lea___d0(edx, edx+4* edi+Ox 10); Mov__d2(eax,jiiem(edx));

Mov__d2(eax,___meni(eax));

And„d0(eax,0x000000 f);

M_ovss— d2(xmm0,— m :eax*4+— uvai(fplanestartpararns))); add— d 1 (__mem(edx), 0x4);

Mov__d2(eax,___meri (ebx+0xl c));

Mov___d2(ecx,_mem(eaxH- x0c));

Mov cl2 (eclx, mem(eax+Oxl 0));

sub__dO(edx,ecx);

Sar d0(edx,0x3);

C.mp— nb— dO(edi , edx) \

Jnb d0( cdd5 );

Mov__d2 (edx, __mem(edi * 8 +ecx)) %

m o v d2 (eax , m em (edx+Ox) 4·));

Mov_il2(ecx,__mem(edx+0x4));

Neg dO(eax);

Inc___dO(edi);

Add d2(eax, loc(ebp-0x2c))i

ΐΐΊΊΐι12 d2(ea?3⁄4:, rnem(edx+0x40));

Sub__d2(eax, __mem(edx+0 l 0));

Cmp—— 1—d2(edi, ——— mem(ebx+Oxl 0)·);

Lea___d0(edx, esi*4-fecx); Movss__dl(__mem(eax*4+edx),xmm0); jl d0( cc95 )?

When we define a set of virtual instructions, we can virtualize the assembly code. Since each virtualized instruction is implemented by the ANSI standard C language, the passive code level migration of the application is realized.

The invention is not limited to the specific embodiments described above. The invention extends to any new feature or any new combination disclosed in this specification, as well as any novel method or process steps or any new combination disclosed.

Claims

Claim

A virtual instruction-based application porting method, comprising:

Step 101: Convert the application to assembly code on a Windows system;

Step 102: In the Windows system, the assembly code is converted into corresponding virtual instructions one by one according to a set of virtual instruction set syntax, thereby obtaining virtualized assembly code;

Step 103: Copy the virtualized assembly code to another application platform, and run it after compiling; at least one instruction in the virtual instruction set corresponds to one instruction in the assembly instruction set; and each piece in the virtual instruction set A directive is a macro or function written in C that contains at least one C language instruction.

2. The virtual instruction based application porting method according to claim 1, wherein the other application platform is an iOS system or an Android system.

3. The virtual instruction based application porting method according to claim 1, wherein the assembly instruction set is an Intel x86 assembly instruction set.