CN1823323A - Method and apparatus for performing native binding - Google Patents

Method and apparatus for performing native binding Download PDF

Info

Publication number
CN1823323A
CN1823323A CNA2004800201024A CN200480020102A CN1823323A CN 1823323 A CN1823323 A CN 1823323A CN A2004800201024 A CNA2004800201024 A CN A2004800201024A CN 200480020102 A CN200480020102 A CN 200480020102A CN 1823323 A CN1823323 A CN 1823323A
Authority
CN
China
Prior art keywords
code
function
machine
source
call
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
CNA2004800201024A
Other languages
Chinese (zh)
Other versions
CN100483341C (en
Inventor
亚力克斯·布朗
杰兰特·诺斯
富兰克·托马斯·维格尔
加雷斯·安东尼·奈特
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
IBM United Kingdom Ltd
International Business Machines Corp
Original Assignee
Transitive Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Transitive Ltd filed Critical Transitive Ltd
Publication of CN1823323A publication Critical patent/CN1823323A/en
Application granted granted Critical
Publication of CN100483341C publication Critical patent/CN100483341C/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44Arrangements for executing specific programs
    • G06F9/455Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
    • G06F9/45504Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
    • G06F9/45516Runtime code conversion or optimisation
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • G06F8/52Binary to binary
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44Arrangements for executing specific programs
    • G06F9/448Execution paradigms, e.g. implementations of programming paradigms
    • G06F9/4482Procedural
    • G06F9/4484Executing subprograms
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44Arrangements for executing specific programs
    • G06F9/448Execution paradigms, e.g. implementations of programming paradigms
    • G06F9/4482Procedural
    • G06F9/4484Executing subprograms
    • G06F9/4486Formation of subprogram jump address

Abstract

A native binding technique is provided for inserting calls to native functions during translation of subject code to target code, such that function calls in the subject program to subject code functions are replaced in target code with calls to native equivalents of the same functions. Parameters of native function (117) calls are transformed from target code representations to be consistent with native code (28) representations, native code (28) calling conventions, and native function (117) prototypes.

Description

Be used to carry out the method and apparatus of native binding
Technical field
Present invention relates in general to computing machine and computer software fields, and relate more particularly to be used for for example translating the program code conversion method and apparatus of code translator, emulator and the accelerator of the program code that comprises function call.
Background technology
In embedded and non-embedded CPU, can find so dominant instruction set architecture (ISA), there are a large amount of softwares for this architecture, this architecture is considered for performance should be by " accelerations ", perhaps " conversion " can present the thousands of competent processor of better cost/performance benefits if one-tenth can be visited related software pellucidly.Also can find by in the ISA that in time is locked in them and can not relate to the dominant CPU architecture of performance or market scope.This architecture is benefited from " synthetic CPU " community's architecture.
The program code conversion method and apparatus helps this acceleration, translation and community's architecture ability, and for example in the common unsettled GB Patent Application No. of submitting on April 22nd, 2,003 03090560, propose, this application title is Block Translation Optimizationsfor Program Code Conversion, and disclosing of this patented claim is incorporated herein by reference.
Source (subject) program that is translated is generally included the multiple source code unit, and it comprises executable body and the multiple source storehouse of being derived from, and the some of them storehouse can be special-purpose, and some storehouses can be configured to the part (" system library ") of this source OS.When source program moved, because external libraries is carried out function call, control stream transmitted between the different units of source code.In some cases, this machine in particular source storehouse (being target architecture) version is available on target architecture.
According to the present invention, a kind of apparatus and method that in claims, illustrate are provided.From dependent claims and below instructions can be clear that preferred feature of the present invention.
Hereinafter summarized according to attainable many aspects of a plurality of embodiment of the present invention and advantage.It is as introducing to help those skilled in the art to understand detailed design discussion quickly, and this discussion is given birth hereinafter and can also not plan to limit the scope of claims in all senses.
Summary of the invention
Particularly, the inventor has developed a kind of optimisation technique that is intended to the accelerated procedure code conversion, and this technology especially can be used in combination with adopting source program code translation program when the operation of the translation of object code.A kind of native binding technology is provided, this technology is used for and will inserts this machine function calls to the translate duration of object code at source code, thus in the source program to the function call of source code function in object code by the replacement of calling to this machine equivalent of same functions.Represent to translate into the parameter of this machine function call consistent from object code with this machine coded representation, this machine code call stipulations and this machine function prototype.
Native binding is the directly source code mechanism of this machine version in storehouse for example of this machine of run time version unit (being target architecture) version rather than translation and execution equivalence of the source code that makes translation of the present invention.This has been avoided translating the expense of the source version in these storehouses.In addition, this machine version can be the much effective realization of identical function, because this machine version can utilize the architectural feature of the ignorant target architecture of source version.
Description of drawings
The accompanying drawing of incorporating the part of instructions and formation instructions into illustrates preferred at present the realization, and is as follows to this description of the drawings:
Fig. 1 is a block diagram of wherein using the device of embodiments of the invention;
Fig. 2 is the synoptic diagram that illustrates according to the native binding process of an illustrative embodiment of the present invention;
Fig. 3 is the synoptic diagram that illustrates according to the native binding process of an illustrative embodiment of the present invention;
Fig. 4 is the synoptic diagram that illustrates according to the native binding process of an illustrative embodiment of the present invention;
Fig. 5 is the synoptic diagram that illustrates according to the native binding process of an illustrative embodiment of the present invention; And
Fig. 6 is the process flow diagram that illustrates according to this machine function call of an illustrative embodiment of the present invention.
Embodiment
Be used to realize the illustrative apparatus of a plurality of new features of hereinafter discussing shown in Fig. 1.Fig. 1 illustrates target processor 13, and this processor comprises destination register 15 and stores the storer 18 of a plurality of software components 17,19,20,21,22 and 28.This software component comprises source code 17, operating system 20, interpreter code 19, interpreter code 21, global register store 27, native binding mechanism 22 and this machine (native) code 28 that will be translated.Interpreter code 21 also is called as object code 21.Global register store 27 also is called as source-register memory bank 27.Interpreter code 19 for example can be used as the emulator of the source code of an ISA being translated into the interpreter code of another ISA, or is used for source code is translated into the accelerator of the interpreter code of identical ISA.This machine code 28 is the codes at target processor 13 direct compilations.
Translation program 19 is promptly realized the compiled version of the source code of translation program, and interpreter code 21 is the translation of the source code 17 of translation program 19 generations, with operating system 20 operations of operation on target processor 13, this target processor is generally microprocessor or other suitable computing machine.Should be understood that the structure shown in Fig. 1 only is exemplary, for example can be positioned at operating system or the realization of the code under operating system according to software of the present invention, method and process.Source code 17, interpreter code 19, operating system 20 and memory mechanism can be those skilled in the art known various types of any one.
As used in the text, have difference between " object code " 21 and " this machine code " 28, translation produces when should " object code " being the operation by source code 17 fragments, should " this machine code " be the target architecture direct compilation.The aims of systems storehouse that destination OS provides is an example of this machine code 28.The translation in aims of systems storehouse is an example of object code 21.This machine code 28 is to generate in the outside of translation program 19, this means that translation program 19 does not generate this machine code 28, and translation program 19 is also had no chance and optimized this machine code 28.
In the device according to Fig. 1, program code conversion is preferably dynamically carried out when operation, object code 21 operations simultaneously.Translation program 19 is pressed the order operation of translation program 21.Above-mentioned translation program 19 is used as the application program of target architecture compiling usually.Source program 17 is translated program 19 translations directly to carry out on target architecture when operation.Translation program 19 can correctly be worked so that this is invoked at when passing to target OS 20 and the source operating system (OS) that conversion source program 17 carries out is called.
In the process that generates object code 21, generate intermediate representation (" IR ") tree according to the sourse instruction sequence.The IR tree is the abstract representation by the operation of the expression formula of source program calculating and execution.Subsequently, generate object code 21 according to this IR tree.
The set of the IR code described in the literary composition generically is called " tree ".Should point out that in form, this structure is actually directed acyclic graph (" DAG ") rather than tree.The formal definition of tree requires each node that a father node is arranged at most.Because described embodiment uses common subexpression elimination during IR generates, so node has a plurality of father nodes usually.For example, mark influences the IR of instruction results can be by two abstract register references, and these two register correspondences are in destination source-register and mark result parameter.
For example, sourse instruction " add %r1, %r2, %r3 " is carried out the content addition with source-register %r2 and %r3, and the result is stored in the source-register %r1.Therefore, this instruction is corresponding to abstract expression formula " %r1=%r2+%r3 ".This example comprises the definition to abstract register %r1 with the addition expression formula that comprises two subexpressions of representing instruction operands %r2 and %r3.In the situation of source program 17, these subexpressions corresponding to other, preferential sourse instruction, perhaps their the details constants immediately for example that can represent present instruction.
When analyzing " addition " instruction, generate new "+" IR node corresponding to the abstract mathematics operational symbol that is used for addition.This "+" IR node is stored the reference to other IR node of representing operand (be expressed as the subexpression tree in IR, often remain in the source-register).Should "+" node itself by source-register (abstract register that is used for %r1, the destination register of instruction) reference, this node definition the value of this register.For example, the part that the middle part of Figure 20 takes over illustrates the IR tree corresponding to X86 instruction " add %ecx, %edx ".
The technician should be understood that in an embodiment in the present technique field, and translation program 19 uses for example C++ realization of object-oriented programming language.For example, the IR node is implemented as the C++ object, and the reference of other node is implemented as the C++ reference corresponding to the C++ object of those other nodes.Therefore, the IR tree is implemented as the set of IR node object, and it comprises a plurality of references each other.
In addition, in the embodiment that discusses, IR generates and uses one group of abstract register.These abstract registers are corresponding to the special characteristic of source architecture.For example, there is unique abstract register (" source-register ") for each physical register on the architecture of source.Similarly, there is unique abstract register for each bar code label that exists on the architecture of source.The placeholder that abstract register is set as IR during IR generates.For example, the value of source-register %r2 that is arranged in the given position of sourse instruction sequence is represented that by specific I R expression tree this tree is associated with the abstract register that is used for source-register %r2.In an embodiment, abstract register is embodied as the C++ object, and its C++ reference via the root node object that specific IR is set is associated with this tree.
Being implemented between the member in interpreter code 19 and the object code 21 of abstract register distributes.In translation program 19, " abstract register " is the placeholder that uses during IR generates, thereby abstract register is associated with the IR tree of the value of calculating this abstract register, and this specific abstract register is corresponding with this IR tree.Equally, the abstract register in the translation program can be embodied as the C++ object, and it comprises the reference to IR node object (being the IR tree).The aggregate of all IR tree of abstract register bank reference is called as work IR forest (forest) (" forest ", this is because it comprises a plurality of abstract register roots, each this abstract register root refers to an IR tree).The snapshot of the abstract operation of the source program of the specific location of this work IR forest representative in source code.
Under the fundamental block pattern, using the addressable storage area of all interpreter code sequences is that global register store 27 is delivered to next fundamental block with state from a fundamental block.This global register store 27 is storage vaults of abstract register, each this abstract register corresponding to and value or other source architectural feature of emulation particular source register.During carrying out object code 21, abstract register is maintained in the destination register so that they can share instruction.During carrying out interpreter code 21, the value of abstract register is stored in global register store 27 or the destination register 15.
In object code 21, " abstract register " is the ad-hoc location in the global register store, to and synchronous from the value and the realistic objective register of the source-register of this position.Selectively, if from the global register store loaded value, then the abstract register in the object code 21 should be understood that it is destination register 15, before the value of the object register of this destination register term of execution of object code 21 is saved back in this register memory, keep the value of this object register temporarily.
Therefore, the source program in 19 times operations of translation program has two kinds of dissimilar codes carrying out with interleaving mode: interpreter code 19 and object code 21.Interpreter code 19 is to be realized according to the high-rise source code of translation program 19 by program compiler before when operation.Object code 21 be run time between generate by interpreter code 19 source code 17 according to the program that is translated.
The expression of this source processor state distributes between translation program 19 and object code 21 members equally.Translation program 19 with the source processor state storage at a plurality of explicit programming language devices for example in variable and/or the object; The compiler that is used to compile this translation program determine state and operation as how object code realize.Comparatively speaking, object code 21 implicitly is stored in destination register and memory location with the source processor state, and its target instruction target word by object code 21 is directly handled.
For example, the low layer of global register store 27 represents it only is the zone of the storer that distributes.Here it is object code 21 is how by preserving between the storage area that limits and each destination register and recovering to see abstract register and mutual with abstract register.But in the source code of translation program 19, global register store 27 is can be at more high-rise accessed and data array or the object handled.For object code 21, there is not high-rise expression.
Fig. 2-5 illustrates the different illustrative embodiment of the translation program 19 of Fig. 1.Fig. 2 illustrates and will be translated the illustrative embodiment of different compilation units of source program 106 of source code 17 forms of program 105 translation.Translation program 105 is as the executable program operation for this machine architecture (perhaps being called as target architecture) compiling, and wherein this this machine architecture comprises nativeOS 103 and this machine processor 101 (it is equivalent to target OS 20 and the target processor 13 of Fig. 1).Source program 106 in this example comprises source executable program 107 and multiple source storehouse, and the multiple source storehouse comprises source private library 109 and origin system storehouse 111.When not adopting native binding, the compilation unit of source program 106 is translated into object code 21, and is performed in translation program 105.
Fig. 3 illustrates wherein the block diagram of the workflow of the illustrative embodiment of utilizing native binding on the unit of the code of the program of translation.
Source program 106 comprises source executable program 107 and multiple source storehouse, and the multiple source storehouse comprises source private library 109 and origin system storehouse 111.Translation program 105 uses native binding to use the function calls in this machine system library 117 to be replaced the source program 106 of origin system built-in function 111 is called.
For example, for the MIPS-x86 translation, senior memcpy () (memory copy) routine of x86 aims of systems storehouse " libc " definable, this routine is utilized the SSE2 vector operation to carry out very fast byte and is duplicated.Use the native binding mechanism 22 of explanation in this application, the memcpy () that all are tied to this machine to calling of the memcpy in the MIPS source code.Eliminated the cost of source (MIPS) version of translation memcpy () function like this.In addition, this machine (x86) version of memcpy () function can be recognized the intricate of this machine hardware better, thereby can learn the mode of the Expected Results of the most effective this function of realization.
When the control that detects source program flows to into source code 17 for example during the part in storehouse, source---this machine version that has source code for this part---, native binding is realized by translation program 19.Translation program 19 is carried out this machine code 28 rather than the translate source code 17 of equivalence.
Except the goal systems library call, native binding can be used for code replacement more arbitrarily, for example replaces the version of this machine compiling of non-library function.In addition, by calling with this machine of replacement function replacement all to the origin system function, can use native binding to realize that on this machine architecture origin system calls, this replace this machine function can realize with to origin system function calls identical functions or call branch (stub) as the surrounding target system call.Also can use native binding, insert or replace (object code or this machine code form) arbitrary code sequence and/or function call to allow any position that defines in source program in any source code position except that the function call position.
The binding location expression
Native binding mechanism 22 requires translation program 19 that specific source code 17 functions are associated with the homologue of their this machine code 28, thus translation program 19 know with which source function of binding and which this machine function will with this source function binding.Translation program 19 can obtain this Function Mapping information in a different manner according to the realization of native binding mechanism 22.
In an embodiment, use special-purpose " binding position " descriptive language identification with bound source function.The binding location expression comprises: (a) will bound source function with (b) with this machine function of bound correspondence.Translation program 19 reads the binding location expression with identification binding position (will call the position of this machine function) when beginning to carry out.During source program was deciphered, the program of serving as interpreter 19 ran into these bindings during positions, and translation program 19 inserts involutory this suitable machine function calls branch in object code 21.In an embodiment, concrete binding location expression is embedded in the translation program 19.In another embodiment, the binding location expression is stored in the different files, and translation program 19 reads this document when operation, thereby allows the terminal user to control native binding knot system 22 by adding specific source to the Function Mapping of this machine.
In another embodiment, native binding binding position descriptive language allows to specify binds the position arbitrarily, thereby except that source function is called, also can insert this machine function call in other position in source code.In this embodiment, the binding location expression comprises: (a) this machine function of the position of definition in the source code (promptly just function call position) and the correspondence that (b) will bind.For example, can be identified as binding the position arbitrarily: the starting point of (1) function; (2) starting point of the setup code of source module; (3) depart from the constant offset amount (as the constant offset amount of the starting point of deflection function) of special symbol; (4) depart from the constant offset amount of first text segment in the module; Or (5) any calling to particular source function (in particular module, or in all modules except that this particular module).Difference between binding location type (1) and (5) is that (1) bind the entrance of source function and the calling station of (5) bound functions.
In some embodiment, native binding binding position descriptive language allows the terminal user to specify relative binding position, can insert this machine function call in this relative binding position in binding position (for example system source function call) before, afterwards or replace this position.For example, native binding binding location expression can specify in all calling of source function " bar () " called this machine function " foo () " afterwards at once.
Binding position descriptive language also is used in the code of link position insertion except that this machine function call.In this embodiment, the binding location expression comprises: (a) position that limits in the source program and (b) to target code block or with the reference of invoked machine program in machine code.If the code that inserts is an object code 21, then translation program 19 need not bound the position at this and carry out many work that are associated with parameter transformation and native call stipulations (hereinafter will illustrate) then, and it is just enough to call stipulations in this position in accordance with the object code of translation program special use.Target and this machine code insert and allow translation program 19 other task of execution on the program of translation for example to debug or performance simulation (profile) arbitrarily.
Can select in the embodiment, in being called as when operation symbol process of repairing, encode to the source is shone upon to this machine function in the symbol table at source program before when operation.Symbol is repaired with the clauses and subclauses in the symbol table of specific native binding marker character replacement source program during operation.This need be at source program by compiling (compilation time) afterwards but being translated (during operation) before, handle this source program.When the program of serving as interpreter 19 ran into the symbol table marker character when operation, translation program 19 was construed to the binding location expression with the symbol table marker character, and explained which this machine function they will call with identification.In this embodiment, be implicit expression to the position that is identified in the symbol table marker character in this symbol table with bound source function, this be because this symbol table marker character be placed on the corresponding symbol table clauses and subclauses of particular source function in.
Except discerning the binding position with the binding location expression, also the expansion of the sourse instruction group of available translation program special use is implicitly discerned and is bound the position in addition with showing, and this expansion is arranged on (" S-call " that see below) in this source code when source code is compiled.
Parameter transformation
When this machine of calling function, translation program 19 must be observed the stipulations of calling of object construction.As a comparison, need only the call stipulations of translation program 19 in accordance with some unanimity in whole object code 21, then object code 21 needn't need to call stipulations in accordance with object construction.In addition, translation program 19 may carry out data conversion between source machine state (as shown in the object code 21) and this machine machine state (shown in this machine code 28), this two states all is used for the input parameter of this machine function and the rreturn value of this function if any.The example of this data conversion can comprise: (i) endian conversion (being the byte exchange); (ii) data structure is aimed at; The (iii) conversion between source address and the destination address; And (iv) value transform (for example constant conversion or value convergent-divergent).
For example, on the MIPS architecture in register load transfer function coefficient, and on the x86 structure in the storehouse parameters transmission.In order to make the MIPS-x86 translation program call this machine function, x86 calls stipulations and requires function parameter is moved on to storehouse from source-register.
Fig. 6 illustrates translation program 19 and calls the step that this machine function is carried out.In order to call this machine function, translation program 19 must be carried out some steps: parameter sets up 501; Input parameter conversion 503; This machine function call 505; And conversion as a result 507.Parameter is set up the object code 21 of the value of 501 finger computing function call parameters.Form and position that input parameter conversion 503 organizes cost machine function code to wish the value of these parameters according to the expression of the object code 21 of function call parameter.This machine function call 505 is that the actual function of this machine function is called, and comprises the order that (reformatting) parameter group is made into the function prototype requirement in the mode that meets the native call stipulations.The order and the type of function prototype indicator function parameter, and the type of function return value.For example, if the native call stipulations require to transmit independent variable on storehouse, the object code 21 that then calls this machine function must be placed on independent variable on the storehouse in the correct order, and stack pointer is correspondingly advanced.Conversion as a result 507 is the rreturn value of this function of conversion if any; This function returns its form value consistent with this machine architecture, and translation program converts this value to expression that object code 21 uses.
It is not exclusive for native binding mechanism 22 that parameter sets up 501, and this is because no matter this function is to be called as the source code 21 or this machine code 28 that are translated, object code 21 all must the calculating parameter value.Do not know that at translation program 19 this machine function call will use under the situation of which particular source register (as parameter value), translation program 19 must be proofreaied and correct the values of the source-register that uses, and is in consistent state to guarantee source-register body 27.Translation program is optimized the calculating that inertia for example estimates that (lazy evaluation) can the source of delay register value, up to these values of needs, wherein proofreaies and correct the calculating that forces that is meant that it estimates the register of having been postponed.When being corrected, the value of source-register is stored in the source-register body 27 then.
Except the value (this need proofread and correct all source-registers in some cases) of the explicit parament of computing function, because the native call meeting has a negative impact to the form of storage access, so parameter establishment step 501 must guarantee that also the source memory space is in consistent state.In an embodiment, IR calibration source store status to this machine function call coding (no matter becoming native call branch or basis (underlying) this machine function), thereby before this machine function call, all loadings that took place before function call in the source program and storage are implanted in the object code, and after implanting function call before the native call, storage access should not take place equally.
" parameter transformation " 509 is used for unified referring to step 503,505 and 507, refers to the different data format of object code 21 and this machine code 28 and calls the whole of each conversion between the stipulations.The code of execution parameter conversion 509 is called as " calling branch ", and it comprises that around the minimum package (wrapper) of basis this machine function call its unique purposes is that permission object code 21 callers and this machine code 28 callees are mutual.Therefore, single " calling branch " can be divided into object code 21 and this machine code 28 components.Parameter transformation 509 is all in object code 21 or part depends on the realization of native binding in this machine code 28.
This machine code branches
In certain embodiments, parameter transformation 509 parts that are used for native binding are carried out by this machine code 28.The shortcoming of this machine code branches is that they can not be translated program 19 optimizations.In these embodiment, object code 21 is carried out some parameter transformations, and uses the native call stipulations to call native call branch.This this machine code 28 that calls branch is carried out other parameter transformation then and is called basis this machine function.
Fig. 4 illustrates the block diagram of use based on the operating process of the function call in the illustrative embodiment of the translation program 120 of the native binding of this machine code call branch 113.Source program 106 in this example comprises source executable program 107 and multiple source storehouse, and the multiple source storehouse comprises private library 109 and system library 111.Translation program 120 usefulness are called 111 call of replacement to the origin system built-in function to this machine code call branch 113.Call the object code 21 execution parameter conversion of this this machine code call branch 113.This machine code call branch 113 carries out other parameter transformation and parameter maps.This machine code call branch 113 calls this machine system library function 117 then.
This machine code branches: unified interface
In an embodiment, call the branch function interface and make the conversion 509 of this machine code parameter easier by defining a unification.Unified call the branch function interface and defined a fixing function signature for all native call branches and corresponding data types, it allows translation program 120 to call this to call branch and do not need the function signature (prototype) of basic this machine function is had any understanding.This allow all high-level programming languages for example C or C++ realize calling branch, this makes this native binding mechanism of the easier visit of terminal user of translation program 19.
In this embodiment, compile as this machine code executable code that is linked to the translation program executable program calling branch function.The term of execution, translation program 120 uses the native call stipulations to call this by this unified interface and calls branch.Because this calls the branch support interface is unified, so for all native calls, it is identical calling this object code sequence of calling branch.
For example, in an embodiment, it is the C function that the branch support interface is called in unification, this function just uses two parameters---the source address of calling station and to the reference of the uniform data structure that comprises all source register value, and return a value---the source address of the next sourse instruction that translation program should be carried out.Pass to the uniform data structure of calling branch and often comprise the currency of all source-registers, it is become source context (context) in addition.
Calling in the native binding mechanism of branch support interface based on unified, native binding is divided into several sections: the specific IR node type of (i) proofreading and correct all source register value; (ii) object code 21, and this code is compiled into unified context mechanism with all source-registers and called this according to the native call stipulations and call branch; And the native call branch that (iii) the particular source register value is compiled into function parameter and this machine of calling function.
At translate duration, native call IR node is translated in the native call position.Native call IR node comprises the coherent reference to the IR of all source-registers.These IR correlativitys of native call IR node can guarantee at the object code generation phase, will generate the object code corresponding to source register value before native call.But translation program is optimized for example calculating of inertia estimation source of delay register value, up to those values of needs.Native call IR correlativity is informed this code generation phase: all source register value of native call branch " needs ".Like this, translation program 19 before generation is used to call the object code 21 of native call branch 113, generate be used to proofread and correct the object code 21 of active register value.Equally,, regard native call IR node as memory reference, thereby before the function call in object code 21, (generating also) carries out all loadings and the storage before the function call in source code 17 for generating code.Similarly, postpone all loadings and the storage that take place after the function call in source code 17, after carrying out native call.
In case of necessity, translation program 19 can comprise that special-purpose abstract register is to keep this native call IR.At the IR generation phase of translation, abstract register is with acting on the placeholder that IR sets (being root node).The IR tree must be linked to abstract register, otherwise this IR tree can not be sent as object code.In other translation program, native call IR code can be connected to the abstract register that existing abstract register for example is used for (current block) successor address.
Call the object code 21 calibration source register values of native call branch 113, and then they are recorded in the context mechanism of source.Because this machine code call branch 113 is carried out by this machine code 28 in this embodiment, so must be with the expression of this machine of source context structure Chinese idiom structure unanimity.Like this, object code 21 where necessary execution parameter conversion 503 so that source register value is represented conversion cost machine coded representation from object code.Converting a plurality of values to process that the data structure consistent with another architecture represent is called as signal sometimes and compiles.
Object code 21 constitutes the source context that this machine of comprising all source register value is represented.Then, object code 21 calls this machine code call branch 113, and the source context is passed to this this machine code call branch as parameter.This calls branch 113 and calls this basis this machine function, extracts required specific source-register from the context of source, and they are passed to this machine function as suitable parameters.Thereby call the prototype encoder of branch 113, and define of the mapping of specific source-register to corresponding this machine function parameter to this machine function.
In some cases, this machine function interface can be different greatly with its source code equivalent, thereby must carry out other calculating (except that being used for data representation and calling the conversion of stipulations) to source data, so that source data is suitable for use as the source function parameter.In the case, call 113 pairs of source register value of branch and carry out other parameter transformation.For example, this machine function can be expected a special parameter different with its source code equivalent.In the case, call branch 113 and before this machine of calling function, suitable source register value is carried out the constant conversion, with the difference in the cell type that this parameter is described.
Using unified native call to divide among the embodiment of support interface, object code 21 is not represented alternative cost machine coded representation with all source-registers from object code with making any distinction between.Native call branch 113 extracts the prototype of this machine function then need be as specific (conversion) source-register of parameter.This machine function branch 113 also can carry out other parameter transformation, with the source version that reflects invoked function and the difference between this machine version.The expression difference that object code 21 is regulated between object code 21 and this machine code 28, and call the signature that branch 113 illustrates specific basis this machine function.
In this embodiment, source function and corresponding native call branch function that the identification of native binding binding location expression will binding, and to being identified in this to call branch be (promptly by the hard coded) of implicit expression in realizing the source function of binding on basis.
This machine code branches: compilation script
In another embodiment, the conversion of this machine code parameter uses special-purpose native binding programming language (hereinafter being called as " script ") to realize.Before carrying out or the term of execution, translation program 19 is analyzed the script that calls branch and is realized, but and it is compiled into the module that this machine is carried out.Call branch's module and link with the translation program executable program then, and use the native call stipulations to call (this machine) as described above and call branch function.
With the native binding script compile or be construed to the executable expression of calling branch.In an embodiment, before translation program is carried out, use independent instrument will bind location expression and be construed to executable machine code.In another embodiment, this will bind translation program the location expression explanation or be compiled into executable machine code or translation program IR (hereinafter being generated as object code) when operation.
In certain embodiments, script is the specific language of translation program special use.This script comprises the primitive (programming language program block) of the possible parameter transformation operation of explanation wide region, and it comprises: (i) description of data type; Conversion between (ii) this machine of object code and those data types is represented; The (iii) identification of this machine function; (iv) specific source-register is mapped to specific function parameter; (v) to the memory access of the storage space of source program; (vi) basic mathematical operation.Can select in the embodiment, script also comprises (vi) basic logic operation and the (overall situation storage of the nonce between vii) a plurality of native binding scripts.The realization of these primitive (this machine code that promptly uses translation program or specific purpose tool to generate from script) must with the expression of target architecture and to call stipulations consistent.
In this embodiment, source function and corresponding native call branch function that the identification of native binding binding location expression will binding, simultaneously to the basis with the source function of binding be identified in this script that calls branch realize in by hard coded.
Object code branch
In another embodiment, the parameter transformation that is used for native binding is carried out with object code fully.In this embodiment, translation program 19 detects native binding and calls when decoding, and parameter transformation is encoded into IR tree (finally being generated as object code).By the parameter transformation and the details of this machine of expression function prototype in IR, this machine code of calling holds into source code (calling the IR of branch and the IR of source code can not distinguish).This makes translation program can be optimized (for example by component masses) to the parameter transformation code.On the contrary, the source-register that the parameter transformation of carrying out in this machine code is for example carried out in this machine code call branch carries out in the outside of translation program to the mapping (mentioned above) of function parameter, and can not be optimised.
Fig. 5 illustrates the block diagram of the operating process of the function call in the illustrative embodiment of translation program 122 of the native binding that uses based target code call branch 115.Source program 106 comprises source executable program 107 and multiple source storehouse, and the multiple source storehouse comprises private library 109 and system library 111.Translation program 122 usefulness are called replacement calling origin system built-in function 111 to what object code called branch 115.Object code calls branch's 115 execution parameter conversion and parameter maps, calls the function in this machine system library 117 then.
Using object code to call among the embodiment of translation program 122 of branch 115, wherein object code 21 directly calls bound this machine function, and all parameter transformations and parameter maps are all carried out by object code 21.In these embodiment, the signature of object code 21 explanation expression conversion and specific machine function (being of the mapping of particular source register) to corresponding this machine function parameter.In order to make the mapping of object code 21 execution parameter, translation program 122 must be known the mapping that this machine function prototype and source-register arrive parameter at translate duration.In some cases, object code calls branch 115 and is translated in the piece that separates with the object code 21 that calls this branch (" caller object code ").In other cases, object code calls branch 115 and is translated in the piece identical with the object code 21 that calls this branch, this object code calls branch and can be integrated into this caller object code and optimize with this caller object code like this, and this is called as " early stage binding " mechanism.Call from many calling stations under the situation of specific source function at source program, it is disadvantageous calling branch 115 at the inline object code of each calling station, and this is because the meeting of duplicating of calling branch code that causes consumes too much storer.In this case, translation program 122 calls branch 115 with object code and remains independent piece, and the calling station of each translation can be called this piece, rather than calls branch at inline this of each calling station.A kind of optimization of native binding is only to use early stage binding (being the inline branch of calling) in the piece of carrying out very continually.
Object code branch: Schizo calls
In another embodiment, translation program 19 uses and is called as that Schizo calls or the mechanism of " S-call ", wherein promote the object code parameter transformation, when this source code of compiling, this source code is inserted in this native binding instruction by the sourse instruction group being expanded to the native binding instruction (being called as the S-Call order) that comprises the translation program special use.The program of serving as interpreter 19 is during with the decoding of this source code, its detection and explain these S-Call orders, and implant the IR (or object code) of suitable execution parameter conversion.
This S-Call mechanism needs the developer's of source program support.When the compiling source program, in the source program of compiling, the S-Call command code is become sourse instruction.Description is called branch and not only is confined to comprise the S-Call order this machine function calls, and they can comprise sourse instruction routine, legal that can help parameter transformation.When combination, S-Call order and conventional sourse instruction are encoded to parameter transformation required all information and operation.
In an embodiment, the S-Call command code is become the adjustable length instruction that is made of a plurality of subdivisions, thereby the S-Call command instruction can be greater than the source code instruction of routine, even can be the size of the sourse instruction of a plurality of routines.The S-Call order is that the subdivision that S-Call orders begins to discern this instruction, and this subdivision is known will to be interpreted into disable instruction on source structure, be called as Schizo Escape.Schizo Escape subdivision can randomly also be discerned the type of the order that comprises in the S-Call order.The S-Call order is preferably divisible into five kinds of command types: (1) marker character, and (2) parameter, call (3), and (4) duplicate and (5) are discarded.The classification of S-Call order is encoded into the unused bit of the Schizo Escape subdivision of front end.After the SchizoEscape is the combination of the option and/or the independent variable of classification special use, and wherein each all has predetermined operational code and form, and each all is encoded into one or more words (being the unit of nybble) in the S-Call command instruction.The S-Call command instruction finishes with the subdivision of the repetition of to start with Schizo Escape.To describe above-mentioned five kinds of S-Call order below in detail, and it should be understood that the whole of the present inventor will be intended that except above-mentioned five classes, the instruction of the native binding of the translation program special use of other type also can be used as the S-Call order.
S-Call " marker character " order is the optional markings symbol that is used to allow application binaries interface (ABI) specific optimisation.S-Call marker character order indication comprises the scope (starting and ending address) of the source code 17 of translation program private code (for example regulate and be branched off into this machine function), and it can overlap or not overlap with the four corner of source function.The order of S-Call marker character has two classes: starting and ending.The order of S-Call marker character has a character string independent variable, and it is the position create name that is labeled (being the title of bound source function).
S-Call " parameter " command recognition one will be as the value of this machine function parameter, and this value is carried out the suitable parameters conversion.In an embodiment, each S-Call parameter command pushes storehouse by the value with correspondence, and therefore requires the S-Call parameter to be in the corresponding order of and function prototype, has defined " next one " parameter of function call.
S-Call " calls " order will call coding to the actual function of this machine function.S-Call call instruction independent variable comprises position or title, specific address or the address position in the source machine state of invoked function of the rreturn value of storage function.
S-Call the Copy command subtend or from source-register or source memory location value of duplicating and carry out object code and the operation of the conversion of this machine between representing is encoded.
S-Call " abolishment " order makes the instruction ignore before them.As mentioned below, but this order use to allow source program correct execution when this machine move with unconditional branch, still allow translation program to discern and the translation program private part of interpretive code simultaneously.
At translate duration, translation program 19 detects Schizo Escape, and becomes the parameter transformation of correspondence and the IR of this machine function call operation to represent the S-Call command decode.Translation program 19 is combined into the IR forest of current block with parameter transformation IR, and it is generated as object code then.The parameter transformation operation is encoded into IR allows the parameter transformation code to incorporate into the IR of source code coding and therewith optimization.
Because S-Call order is the native binding instruction of translation program special use, thus use have only initial order operational code---Schizo Escape---that translation program 19 understands in source program to the S-Call command code.Source processor becomes illegal sourse instruction with the S-Call command interpretation.Like this, when moving, this machine of source program (promptly on target architecture) must avoid carrying out the S-Call order.This machine of source program operation that the source program software developer can use several different methods to allow S-Call to strengthen, (a) condition that comprises carry out and (b) branch analyze in advance.Condition is carried out and to be comprised the condition source code, and this code checks that according to runtime environment source program is this machine operation or as the program run that is translated, and if this machine operation then skip the S-Call order.Branch analyzes the unconditional branch instruction of the instruction of skipping all translation program special uses (such as, but be not limited to the S-Call order) that comprises in the implant source code in advance.When this machine moved, unconditional branch was skipped this translation program private code thus and is carried out.When as the program run that is translated, translation program is ignored all unconditional branch instructions, abolishes order (being that unconditional branch is the part that translation program is used for the sourse instruction pattern of identification translation program private code when decoding) for S-Call after this unconditional branch instruction.
Object code branch: outside Schizo branch
In another embodiment, the unit that compiles separately by calling of constituting of Schizo-call order and the common sourse instruction quilt that branch is positioned at source code.Translation program 19 uses special-purpose native binding binding position descriptive language (as mentioned above) that the binding position is appointed as in the source code position.When the program of serving as interpreter 19 arrives such binding position, shift control stream instead to carry out outside Schizo branch.From then on the position is outside, and the behavior of translation program is with call the behavior of describing for Schizo identical.In the time the S-Call order directly can not being inserted source code (for example, when the source code that is used for source storehouse/application program is unavailable), the outside Schizo permission use S-Call of branch order.
Object code branch: explain script
Can select in the embodiment, use the native binding implementation language (" script ") of above-mentioned special use to make the object code parameter transformation easier.In this embodiment, when operation, translation program is represented the IR that the native binding script is construed to parameter transformation.This translation program changes the IR forest that IR is combined into current block with parameter, and it is subsequently as optimised and be generated as object code.This translation program must comprise the fore-end that can analyze and decode script.
In this embodiment, source function and corresponding native call branch function that the identification of native binding binding location expression will binding, and to the hard coded in the realization of calling branch that is identified in of basis this machine function that will bind.
Object code branch: unified interface
Can select in the embodiment, as mentioned above, unified calling the branch function interface and make the object code parameter transformation easier by defining.Unification is called the branch function interface and has been defined a fixing function signature for all native call branches and corresponding data types, it allows translation program to call this and calls branch as this machine function, and does not need that the function signature (prototype) of basis this machine function is had any understanding.This allow with the advanced programming preamble for example C or C++ realize calling branch, this makes this native binding mechanism of the easier visit of terminal user of translation program.
To call the branch support interface opposite with the unification of above-mentioned this machine code, and in some embodiment, translation program is analyzed when operation and called branch and realize, and its IR that is construed to parameter transformation is represented.In other words, translation program will call branch and realize being compiled into translation program IR.Translation program changes the IR forest that IR is combined into current block with parameter, and it is subsequently as optimised and be generated as object code.Similar with compiler, this translation program must comprise the fore-end that can analyze and decode script.
In this embodiment, native binding is described source function and the corresponding native call branch function that identification will binding, and to the hard coded in the realization of calling branch that is identified in of basis this machine function that will bind.
Although illustrated and illustrated some preferred embodiments, those skilled in the art should be understood that and can realize multiple change and modification and can not deviate from the scope of the present invention that is defined by claims.
Note with about this instructions of this application simultaneously or before it, apply for and open to the public so that can check all papers and the document of this instructions, the content of all these papers and document is hereby incorporated by.
Except wherein such feature and/or at least some combinations repelled mutually in the step, the institute of disclosed all features and/or disclosed any method or process can be combined in any way in steps in this instructions (comprising arbitrary claim, summary and accompanying drawing).
Disclosed each feature can be identical by playing in this instructions (comprising any claim, summary and accompanying drawing), the optional characteristic of equivalence or similar effect replaces, unless offer some clarification in addition.Therefore, unless offer some clarification on an example of the general series that disclosed each feature only is equivalence or similar characteristics in addition.
The present invention is not limited to the details of aforesaid embodiment.The present invention can expand in this instructions (comprising any claims, summary and accompanying drawing) any novel characteristics in the disclosed feature or the combination of any novelty, the step of any novelty in the step of perhaps disclosed any method or process or the combination of any novelty.

Claims (43)

1, a kind ofly during translating the program codes (21) that to carry out by target processor (13), carries out native binding to carry out the method for this machine code (28) from the source program code (17) that can carry out by source processor, wherein this machine code (28) is can be by the code of target processor (13) execution, and described method comprises:
Identification has the particular source program code (17) of corresponding this machine code (28);
Identification is corresponding to this machine code (28) of this source program code that is identified (17); And
Carry out corresponding this machine code (28) rather than carry out the translated version of this source program code that is identified (17).
According to the method for claim 1, it is characterized in that 2, the source program code of this identification (17) is corresponding to source function (109), this machine code (28) of this identification is corresponding to this machine function (117), and wherein this this machine code (28) execution in step comprises:
In the translation process of source program code (17), carry out this machine function (117) rather than source function (109).
According to the method for claim 2, it is characterized in that 3, this this machine function (117) execution in step comprises:
With zero or more the polygamma function parameter represent alternative cost machine code (28) expression from object code;
Call this machine function (117) of function parameter with this conversion according to the prototype of this machine function (117); And
Zero or more rreturn values of this this machine that calls function (117) are represented that from this machine code (28) transforming to object code represents.
According to the method for claim 3, it is characterized in that 4, at least one conversion in this shift step generates the intermediate representation of this conversion.
According to the method for claim 3 or 4, it is characterized in that 5, at least one conversion in this shift step generates object code.
6, according to claim 3,4 or 5 method, it is characterized in that this machine function (117) execution in step also comprises:
All source register value in the object code are represented alternative cost machine code (28) expression from object code;
Call the branch support interface calls the source-register with this conversion from object code this machine code (28) and call branch function according to unified;
Call from this machine code (28) according to the prototype of this machine function (117) and to call this machine function (117) the branch function with particular source register and/or parameter storehouse.
According to any one method in the claim 3 to 6, it is characterized in that 7, this this machine function (117) execution in step comprises:
Function parameter is represented alternative cost machine code (28) expression from object code;
Call this machine function (117) of function parameter with conversion according to the prototype of this machine function (117); And
The result of this this machine that calls function (117) is represented that from this machine code (28) being transformed into object code represents.
According to any one method in the claim 3 to 7, it is characterized in that 8, the translation program special instruction by adding the sourse instruction group to is with source code described function parameter transformation step and this machine function (117) invocation step.
9, according to the method for any one claim of front, it is characterized in that, use the binding location expression to carry out the step of this machine code (28) of identification particular source and correspondence thereof.
10, according to the method for claim 9, it is characterized in that, this binding location expression comprises source function (109) and this machine function (117), wherein source function (109) identification has the specific source program code (17) of corresponding this machine code (28), corresponding this machine code (28) of this machine function (117) identification.
11, according to the method for claim 10, it is characterized in that, when this method also comprises the source function (109) that comprises in running into the binding location expression, in object code, be inserted in the call branch of the translate duration of this source code this machine function (117).
According to claim 9,10 or 11 method, it is characterized in that 12, this binding location expression is embedded in the translation program of carrying out this translation.
According to any one method in the claim 9 to 12, it is characterized in that 13, this method also is included in translation and carries out when beginning, and reads the binding location expression from the binding position description document of storage.
14, according to any one method in the claim 9 to 13, it is characterized in that, the binding location expression comprises position and corresponding this machine function (117) in this source code, wherein the location recognition in this source code has the specific source program code (17) of corresponding this machine code (28), corresponding this machine code (28) of this this machine function (117) identification.
15, according to any one method in the claim 9 to 14, it is characterized in that, the binding location expression comprise in this source code the position and to reference with invoked code, wherein the location recognition in this source code has the specific source program code (17) of corresponding this machine code (28), to corresponding this machine code (28) of reference identification with invoked code.
16, according to the method for claim 15, it is characterized in that, is object code with invoked code.
17, according to any one method in the claim 9 to 16, it is characterized in that, this binding location expression be included in source function (109) call before, afterwards or this machine function (117) that replaces this source function (109) to call inserting in this object code call.
According to any one method in the claim 9 to 17, it is characterized in that 18, symbol was repaired when this method was also carried out operation, symbol is repaired and is comprised during this operation:
In the symbol table of source program, this machine function (117) mapping code is arrived in the source,
Replace the clauses and subclauses in the symbol table of this source program with the native binding marker character of special use, and
The native binding marker character of the special use that will run at translate duration is construed to suitable this machine function (117) that the binding location expression will call with indication.
According to any one method in the claim 9 to 18, it is characterized in that 19, this binding location expression comprises the corresponding relation with outside Schizo call instruction, wherein the Schizo call instruction is the native binding instruction of translation program special use, and this method comprises:
When running into the binding location expression of the outside Schizo call instruction of identification at the source code translate duration, with the execution of translation circulation to outside Schizo call instruction.
According to the method for claim 19, it is characterized in that 20, this outside Schizo call instruction execution in step comprises:
Interprets external Schizo call instruction; And
Generate the intermediate representation of outside Schizo call instruction, this step is represented alternative cost machine code (28) expression with function parameter from object code, and this machine function (117) that calls the function parameter with this conversion according to the prototype of this machine function (117).
According to the method for claim 19, it is characterized in that 21, this outside Schizo call instruction execution in step comprises:
Interprets external Schizo call instruction; And
Generation is used for the object code of this outside Schizo call instruction, this step is represented alternative cost machine code (28) expression with function parameter from object code, and this machine function (117) that calls the function parameter with this conversion according to the prototype of this machine function (117).
According to the method for any one claim of front, it is characterized in that 22, this method also comprises:
Source code is inserted in the Schizo call instruction, and wherein the Schizo call instruction is the native binding instruction of translation program special use; And
Translate duration at source code detects the Schizo call instruction.
According to the method for claim 22, it is characterized in that 23, this method also comprises:
When the translate duration at source code runs into the Schizo call instruction, with the execution of translation circulation to the Schizo call instruction of this outside.
According to the method for claim 23, it is characterized in that 24, this Schizo call instruction execution in step comprises:
Interprets external Schizo call instruction; And
Generate the intermediate representation of this Schizo call instruction, this step is represented alternative cost machine code (28) expression with function parameter from object code, and this machine function (117) that calls the function parameter with this conversion according to the prototype of this machine function (117).
According to the method for claim 23, it is characterized in that 25, this Schizo call instruction execution in step comprises:
Explain this Schizo call instruction; And
Generation is used for the object code of this Schizo call instruction, this step is represented alternative cost machine code (28) expression with function parameter from object code, and this machine function (117) that calls the function parameter with this conversion according to the prototype of this machine function (117).
According to any one method in the claim 22 to 25, it is characterized in that 26, this Schizo call instruction is the instruction that comprises the variable-length of a plurality of subdivision instructions.
According to the method for claim 26, it is characterized in that 27, these a plurality of subdivision instructions comprise the instruction of Schizo Escape subdivision, described Schizo call instruction detects step and comprises that also detecting this Schizo Escape subdivision instructs.
According to the method for claim 27, it is characterized in that 28, the type by the Schizo call instruction of other subdivision instruction expression of this Schizo call instruction is also discerned in described Schizo Escape subdivision instruction.
According to the method for any one claim of front, it is characterized in that 29, this method also comprises:
The native binding realization descriptive language of analyzing and decoding and comprise the native binding script;
Explain this native binding script at translate duration; And
The intermediate representation that generates the native binding script is to represent alternative cost machine code (28) expression with function parameter from object code.
According to the method for claim 29, it is characterized in that 30, this method also comprises:
The intermediate representation of this native binding script is integrated into the intermediate representation forest that is used for source code block; And
Generation is used for the object code of this intermediate representation forest.
According to the method for any one claim of front, it is characterized in that 31, this method also comprises:
All source register value in the object code are represented alternative cost machine code (28) expression from object code;
Call the branch support interface calls the source-register with this conversion from object code this machine code (28) and call branch function according to unified;
This machine of explanation code (28) calls branch function; And
This machine of generation code (28) calls the intermediate representation of branch function binding script so that function parameter is represented alternative cost machine code (28) expression from object code.
32, be subordinated to the method for the claim of claim 21 according to claim 21 or any one, it is characterized in that, this method also comprises:
The intermediate representation that this machine code (28) is called branch function is integrated into the intermediate representation forest that is used for source code block; And
Generation is used for the object code of this intermediate representation forest.
33, be subordinated to the method for the claim of claim 3 according to claim 3 or any one, it is characterized in that, this this machine function (117) execution in step also comprises:
All source register value in the object code are represented alternative cost machine code (28) expression from object code;
This machine code (28) that calls the source-register with this conversion from object code calls branch function;
Call from this machine code (28) according to the prototype of this machine function (117) and to call this machine function (117) the branch function with particular source register and/or parameter storehouse.
According to the method for any one claim of front, it is characterized in that 34, this method also comprises:
This machine of analysis code (28) calls the script of branch function and realizes;
This machine code (28) after analyzing is called branch function compile cost machine code (28) executable module; And
This machine code (28) executable module and the executable program that is used to carry out translation are linked.
According to the method for claim 34, it is characterized in that 35, this this machine code (28) executable module can be carried out:
All source register value in the object code are represented alternative cost machine code (28) expression from object code;
This machine code (28) that calls the source-register with conversion from object code calls branch function;
Call from this machine code (28) according to the prototype of this machine function (117) and to call this machine function (117) the branch function with particular source register and/or parameter storehouse.
36, according to the method for claim 34 or 35, it is characterized in that, the step of this machine code (28) of this identification particular source and correspondence thereof uses the binding location expression to carry out, described binding location expression comprises that source function (109) and this machine code (28) call branch function, wherein this source function (109) identification has the particular source program code (17) of corresponding this machine code (28), and this machine code (28) calls corresponding this machine code (28) of branch function identification.
According to the method for claim 36, it is characterized in that 37, the sign of during the script that this method also is included in this machine code (28) executable module is realized this machine code (28) being called this machine function (117) of branch function is encoded.
38, be subordinated to the method for the claim of claim 3 according to claim 3 or any one, it is characterized in that, this this machine function (117) execution in step also comprises:
All source register value in the object code are represented alternative cost machine code (28) expression from object code;
The object code that calls the source-register with conversion from object code calls branch function;
Call from object code according to the prototype of this machine function (117) and to call this machine function (117) the branch function with particular source register and/or parameter storehouse.
According to the method for claim 38, it is characterized in that 39, this method also comprises:
The intermediate representation of this machine of generation function (117) execution in step;
The intermediate representation of this machine function (117) execution in step is integrated into the intermediate representation forest that is used for source code block; And
Generation is used for the object code of this intermediate representation forest.
40, according to the method for any one claim of front, it is characterized in that, is system call with the source function of carrying out (109).
41, according to the method for any one claim of front, it is characterized in that, is built-in function with the source function of carrying out (109).
42, a kind of computer-readable storage medium, resident can the execution to realize software on these medium by computing machine according to the computer-readable code form of any one method in the claim 1 to 41.
43, a kind of combination comprises:
Target processor (13); And
Be used for carrying out interpreter code according to any one method of claim 1 to 41.
CNB2004800201024A 2003-07-15 2004-07-13 Method and apparatus for performing native binding Active CN100483341C (en)

Applications Claiming Priority (3)

Application Number Priority Date Filing Date Title
GB0316531.3 2003-07-15
GBGB0316531.3A GB0316531D0 (en) 2003-07-15 2003-07-15 Method and apparatus for performing native binding
GB0320717.2 2003-09-04

Publications (2)

Publication Number Publication Date
CN1823323A true CN1823323A (en) 2006-08-23
CN100483341C CN100483341C (en) 2009-04-29

Family

ID=27763852

Family Applications (1)

Application Number Title Priority Date Filing Date
CNB2004800201024A Active CN100483341C (en) 2003-07-15 2004-07-13 Method and apparatus for performing native binding

Country Status (7)

Country Link
US (2) US8091076B2 (en)
EP (1) EP2015177A1 (en)
JP (2) JP4931583B2 (en)
CN (1) CN100483341C (en)
GB (2) GB0316531D0 (en)
HK (1) HK1068700A1 (en)
TW (1) TWI370990B (en)

Cited By (12)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101558382A (en) * 2006-10-02 2009-10-14 特兰斯蒂有限公司 Method and apparatus for administering a process filesystem with respect to program code conversion
CN102141929A (en) * 2010-10-21 2011-08-03 华为技术有限公司 Application program running method, simulator, host machine and system
CN103365668A (en) * 2012-03-26 2013-10-23 联想(北京)有限公司 Loading and linking method and device of dynamic link library
CN103620553A (en) * 2011-06-10 2014-03-05 微软公司 Binding executable code at runtime
CN103678115A (en) * 2012-09-07 2014-03-26 三星电子株式会社 Apparatus and method for detecting location of source code error in mixed-mode program
CN105122206A (en) * 2013-03-15 2015-12-02 索夫特机械公司 Method and apparatus for guest return address stack emulation supporting speculation
US9921842B2 (en) 2011-01-27 2018-03-20 Intel Corporation Guest instruction block with near branching and far branching sequence construction to native instruction block
US10042643B2 (en) 2011-01-27 2018-08-07 Intel Corporation Guest instruction to native instruction range based mapping using a conversion look aside buffer of a processor
US10185567B2 (en) 2011-01-27 2019-01-22 Intel Corporation Multilevel conversion table cache for translating guest instructions to native instructions
US10241795B2 (en) 2011-01-27 2019-03-26 Intel Corporation Guest to native block address mappings and management of native code storage
US10394563B2 (en) 2011-01-27 2019-08-27 Intel Corporation Hardware accelerated conversion system using pattern matching
US10514926B2 (en) 2013-03-15 2019-12-24 Intel Corporation Method and apparatus to allow early dependency resolution and data forwarding in a microprocessor

Families Citing this family (90)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7305700B2 (en) 2002-01-08 2007-12-04 Seven Networks, Inc. Secure transport for mobile communication network
US7917468B2 (en) 2005-08-01 2011-03-29 Seven Networks, Inc. Linking of personal information management data
US8468126B2 (en) 2005-08-01 2013-06-18 Seven Networks, Inc. Publishing data in an information community
US7853563B2 (en) 2005-08-01 2010-12-14 Seven Networks, Inc. Universal data aggregation
WO2006045102A2 (en) 2004-10-20 2006-04-27 Seven Networks, Inc. Method and apparatus for intercepting events in a communication system
US7706781B2 (en) 2004-11-22 2010-04-27 Seven Networks International Oy Data security in a mobile e-mail service
FI117152B (en) 2004-12-03 2006-06-30 Seven Networks Internat Oy E-mail service provisioning method for mobile terminal, involves using domain part and further parameters to generate new parameter set in list of setting parameter sets, if provisioning of e-mail service is successful
GB2424092A (en) * 2005-03-11 2006-09-13 Transitive Ltd Switching between code translation and execution using a trampoline
US7752633B1 (en) * 2005-03-14 2010-07-06 Seven Networks, Inc. Cross-platform event engine
US8438633B1 (en) 2005-04-21 2013-05-07 Seven Networks, Inc. Flexible real-time inbox access
WO2006136660A1 (en) 2005-06-21 2006-12-28 Seven Networks International Oy Maintaining an ip connection in a mobile network
GB0517357D0 (en) 2005-08-25 2005-10-05 Corizon Ltd User interface generation
US7769395B2 (en) 2006-06-20 2010-08-03 Seven Networks, Inc. Location-based operations and messaging
US8286238B2 (en) * 2006-09-29 2012-10-09 Intel Corporation Method and apparatus for run-time in-memory patching of code from a service processor
JP5448165B2 (en) * 2006-10-02 2014-03-19 インターナショナル・ビジネス・マシーンズ・コーポレーション Computer system adapted to support register window architecture, method of controlling the computer system, and computer program thereof
GB0623276D0 (en) * 2006-11-22 2007-01-03 Transitive Ltd Memory consistency protection in a multiprocessor computing system
KR100876606B1 (en) * 2007-01-22 2008-12-31 이쓰리넷(주) Heterogeneous interlocking program development method and its development device
US8693494B2 (en) 2007-06-01 2014-04-08 Seven Networks, Inc. Polling
US8805425B2 (en) 2007-06-01 2014-08-12 Seven Networks, Inc. Integrated messaging
US8364181B2 (en) 2007-12-10 2013-01-29 Seven Networks, Inc. Electronic-mail filtering for mobile devices
US9002828B2 (en) 2007-12-13 2015-04-07 Seven Networks, Inc. Predictive content delivery
US8862657B2 (en) 2008-01-25 2014-10-14 Seven Networks, Inc. Policy based content service
US20090193338A1 (en) 2008-01-28 2009-07-30 Trevor Fiatal Reducing network and battery consumption during content delivery and playback
US8787947B2 (en) 2008-06-18 2014-07-22 Seven Networks, Inc. Application discovery on mobile devices
US8078158B2 (en) 2008-06-26 2011-12-13 Seven Networks, Inc. Provisioning applications for a mobile device
US8909759B2 (en) 2008-10-10 2014-12-09 Seven Networks, Inc. Bandwidth measurement
US8843904B2 (en) * 2010-01-26 2014-09-23 International Business Machines Corporation Automated building and retargeting of architecture-dependent assets
EP3651028A1 (en) 2010-07-26 2020-05-13 Seven Networks, LLC Mobile network traffic coordination across multiple applications
US9077630B2 (en) 2010-07-26 2015-07-07 Seven Networks, Inc. Distributed implementation of dynamic wireless traffic policy
US8838783B2 (en) 2010-07-26 2014-09-16 Seven Networks, Inc. Distributed caching for resource and mobile network traffic management
US8886176B2 (en) 2010-07-26 2014-11-11 Seven Networks, Inc. Mobile application traffic optimization
US8843153B2 (en) 2010-11-01 2014-09-23 Seven Networks, Inc. Mobile traffic categorization and policy for network use optimization while preserving user experience
WO2012060995A2 (en) 2010-11-01 2012-05-10 Michael Luna Distributed caching in a wireless network of content delivered for a mobile application over a long-held request
CN103620576B (en) 2010-11-01 2016-11-09 七网络公司 It is applicable to the caching of mobile applications behavior and network condition
US8484314B2 (en) 2010-11-01 2013-07-09 Seven Networks, Inc. Distributed caching in a wireless network of content delivered for a mobile application over a long-held request
WO2012060997A2 (en) 2010-11-01 2012-05-10 Michael Luna Application and network-based long poll request detection and cacheability assessment therefor
CA2798523C (en) 2010-11-22 2015-02-24 Seven Networks, Inc. Aligning data transfer to optimize connections established for transmission over a wireless network
US8549464B2 (en) 2010-11-22 2013-10-01 Microsoft Corporation Reusing expression graphs in computer programming languages
GB2500327B (en) 2010-11-22 2019-11-06 Seven Networks Llc Optimization of resource polling intervals to satisfy mobile device requests
GB2501416B (en) 2011-01-07 2018-03-21 Seven Networks Llc System and method for reduction of mobile network traffic used for domain name system (DNS) queries
US9141360B1 (en) * 2011-03-16 2015-09-22 Google Inc. Web application module translation service
US8694978B1 (en) * 2011-03-25 2014-04-08 Google Inc. Function side-effect modeling by prototyping
WO2012145533A2 (en) 2011-04-19 2012-10-26 Seven Networks, Inc. Shared resource and virtual resource management in a networked environment
EP2702500B1 (en) 2011-04-27 2017-07-19 Seven Networks, LLC Detecting and preserving state for satisfying application requests in a distributed proxy and cache system
GB2496537B (en) 2011-04-27 2014-10-15 Seven Networks Inc System and method for making requests on behalf of a mobile device based on atmoic processes for mobile network traffic relief
US8990515B2 (en) 2011-06-14 2015-03-24 Microsoft Technology Licensing, Llc Aliasing buffers
EP2737742A4 (en) 2011-07-27 2015-01-28 Seven Networks Inc Automatic generation and distribution of policy information regarding malicious mobile traffic in a wireless network
US8934414B2 (en) 2011-12-06 2015-01-13 Seven Networks, Inc. Cellular or WiFi mobile traffic optimization based on public or private network destination
WO2013086214A1 (en) 2011-12-06 2013-06-13 Seven Networks, Inc. A system of redundantly clustered machines to provide failover mechanisms for mobile traffic management and network resource conservation
WO2013086455A1 (en) 2011-12-07 2013-06-13 Seven Networks, Inc. Flexible and dynamic integration schemas of a traffic management system with various network operators for network traffic alleviation
WO2013086447A1 (en) 2011-12-07 2013-06-13 Seven Networks, Inc. Radio-awareness of mobile device for sending server-side control signals using a wireless network optimized transport protocol
EP2792188B1 (en) 2011-12-14 2019-03-20 Seven Networks, LLC Mobile network reporting and usage analytics system and method using aggregation of data in a distributed traffic optimization system
US9832095B2 (en) 2011-12-14 2017-11-28 Seven Networks, Llc Operation modes for mobile traffic optimization and concurrent management of optimized and non-optimized traffic
WO2013090821A1 (en) 2011-12-14 2013-06-20 Seven Networks, Inc. Hierarchies and categories for management and deployment of policies for distributed wireless traffic optimization
US8909202B2 (en) 2012-01-05 2014-12-09 Seven Networks, Inc. Detection and management of user interactions with foreground applications on a mobile device in distributed caching
WO2013116856A1 (en) 2012-02-02 2013-08-08 Seven Networks, Inc. Dynamic categorization of applications for network access in a mobile network
WO2013116852A1 (en) 2012-02-03 2013-08-08 Seven Networks, Inc. User as an end point for profiling and optimizing the delivery of content and data in a wireless network
US9081896B1 (en) * 2012-03-21 2015-07-14 Amazon Technologies, Inc. Generating a replacement binary for emulation of an application
US9851987B2 (en) 2012-03-22 2017-12-26 Intel Corporation Nested emulation and dynamic linking environment
CN104205049B (en) * 2012-03-22 2018-05-11 英特尔公司 Hybrid analog-digital simulation and kernel function processing system and method
US9678728B1 (en) * 2012-03-29 2017-06-13 Emc International Company Version compatibility
US8812695B2 (en) 2012-04-09 2014-08-19 Seven Networks, Inc. Method and system for management of a virtual network connection without heartbeat messages
WO2013155208A1 (en) 2012-04-10 2013-10-17 Seven Networks, Inc. Intelligent customer service/call center services enhanced using real-time and historical mobile application and traffic-related statistics collected by a distributed caching system in a mobile network
US8775631B2 (en) 2012-07-13 2014-07-08 Seven Networks, Inc. Dynamic bandwidth adjustment for browsing or streaming activity in a wireless network based on prediction of user behavior when interacting with mobile applications
US8819648B2 (en) 2012-07-20 2014-08-26 International Business Machines Corporation Control flow management for execution of dynamically translated non-native code in a virtual hosting environment
EP2883133A4 (en) * 2012-08-08 2016-03-23 Intel Corp Isa bridging including support for call to overidding virtual functions
US9161258B2 (en) 2012-10-24 2015-10-13 Seven Networks, Llc Optimized and selective management of policy deployment to mobile clients in a congested network to prevent further aggravation of network congestion
NO334888B1 (en) * 2012-11-09 2014-06-30 Outracks Technologies As Procedure for automatically generating drawing operations from graphics resources
US9307493B2 (en) 2012-12-20 2016-04-05 Seven Networks, Llc Systems and methods for application management of mobile device radio state promotion and demotion
US9241314B2 (en) 2013-01-23 2016-01-19 Seven Networks, Llc Mobile device with application or context aware fast dormancy
US8874761B2 (en) 2013-01-25 2014-10-28 Seven Networks, Inc. Signaling optimization in a wireless network for traffic utilizing proprietary and non-proprietary protocols
US9326185B2 (en) 2013-03-11 2016-04-26 Seven Networks, Llc Mobile network congestion recognition for optimization of mobile traffic
US9065765B2 (en) 2013-07-22 2015-06-23 Seven Networks, Inc. Proxy server associated with a mobile carrier for enhancing mobile traffic management in a mobile network
US9348565B2 (en) * 2014-03-12 2016-05-24 International Business Machines Corporation Compact data marshaller generation
US10120663B2 (en) * 2014-03-28 2018-11-06 Intel Corporation Inter-architecture compatability module to allow code module of one architecture to use library module of another architecture
US20150379169A1 (en) * 2014-06-27 2015-12-31 Yong Wu Efficient emulation for pseudo-wrapped callback handling in binary translation software
EP3281105B1 (en) * 2015-04-10 2023-10-25 Google LLC Binary translation into native client
KR102023668B1 (en) * 2015-04-10 2019-09-20 구글 엘엘씨 Binary Translation for Shared Object Levels
US9335982B1 (en) * 2015-04-28 2016-05-10 Microsoft Technology Licensing, Llc Processor emulation using multiple translations
GB2537936B (en) * 2015-05-01 2020-01-22 Advanced Risc Mach Ltd System and method for translating a guest instruction of a guest architecture into at least one host instruction of a host architecture
JP5942018B1 (en) * 2015-06-23 2016-06-29 株式会社エクサ Source code conversion program
US10303498B2 (en) 2015-10-01 2019-05-28 Microsoft Technology Licensing, Llc Performance optimizations for emulators
US10452409B2 (en) * 2015-10-23 2019-10-22 Oracle International Corporation Universal adapter for native calling
US10282182B2 (en) * 2016-09-23 2019-05-07 Intel Corporation Technologies for translation cache management in binary translation systems
US10019244B1 (en) * 2016-09-28 2018-07-10 Amazon Technologies, Inc. Interpreting program code using a symbol table
US11556317B2 (en) 2020-05-22 2023-01-17 Fujitsu Limited Instruction translation support method and information processing apparatus
US11635947B2 (en) 2020-05-22 2023-04-25 Fujitsu Limited Instruction translation support method and information processing apparatus
US11042422B1 (en) 2020-08-31 2021-06-22 Microsoft Technology Licensing, Llc Hybrid binaries supporting code stream folding
US11231918B1 (en) 2020-08-31 2022-01-25 Microsoft Technologly Licensing, LLC Native emulation compatible application binary interface for supporting emulation of foreign code
US11403100B2 (en) * 2020-08-31 2022-08-02 Microsoft Technology Licensing, Llc Dual architecture function pointers having consistent reference addresses

Family Cites Families (22)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5379432A (en) * 1993-07-19 1995-01-03 Taligent, Inc. Object-oriented interface for a procedural operating system
US5930509A (en) * 1996-01-29 1999-07-27 Digital Equipment Corporation Method and apparatus for performing binary translation
US6314558B1 (en) * 1996-08-27 2001-11-06 Compuware Corporation Byte code instrumentation
US5937193A (en) * 1996-11-27 1999-08-10 Vlsi Technology, Inc. Circuit arrangement for translating platform-independent instructions for execution on a hardware platform and method thereof
US6026238A (en) * 1997-08-18 2000-02-15 Microsoft Corporatrion Interface conversion modules based upon generalized templates for multiple platform computer systems
US6199202B1 (en) * 1998-01-06 2001-03-06 Hewlett-Packard Company Method and apparatus for the inter-operation of differing architectural and run time conventions
US6609144B1 (en) * 1998-05-04 2003-08-19 Matsushita Electric Industrial Co., Ltd. Program reception/execution apparatus that can commence execution of a machine program having only received the program in part, and a program transmission apparatus that enables such execution
US20020147969A1 (en) * 1998-10-21 2002-10-10 Richard A. Lethin Dynamic optimizing object code translator for architecture emulation and dynamic optimizing object code translation method
US8121828B2 (en) * 1999-01-28 2012-02-21 Ati Technologies Ulc Detecting conditions for transfer of execution from one computer instruction stream to another and executing transfer on satisfaction of the conditions
EP1052806B1 (en) * 1999-05-13 2006-03-22 Canon Kabushiki Kaisha Apparatus for searching a device on a network
JP2000330792A (en) * 1999-05-18 2000-11-30 Matsushita Electric Ind Co Ltd System for controlling byte code program execution
GB9920676D0 (en) * 1999-09-01 1999-11-03 Tao Group Ltd Translating and executing object-oriented computer programs
GB9921720D0 (en) * 1999-09-14 1999-11-17 Tao Group Ltd Loading object-oriented computer programs
WO2002052409A2 (en) * 2000-11-13 2002-07-04 Sun Microsystems, Inc. Method and apparatus for increasing performance of an interpreter
US6836884B1 (en) * 2001-06-04 2004-12-28 Microsoft Corporation Method and system for editing software programs
US7107584B2 (en) * 2001-10-23 2006-09-12 Microsoft Corporation Data alignment between native and non-native shared data structures
US6907519B2 (en) * 2001-11-29 2005-06-14 Hewlett-Packard Development Company, L.P. Systems and methods for integrating emulated and native code
JP4044756B2 (en) * 2001-12-11 2008-02-06 松下電器産業株式会社 Program conversion device, program conversion method, and program for realizing the program conversion device
GB0202728D0 (en) * 2002-02-06 2002-03-27 Transitive Technologies Ltd Condition code flag emulation for program code conversion
US7124445B2 (en) * 2002-06-21 2006-10-17 Pace Anti-Piracy, Inc. Protecting software from unauthorized use by converting source code modules to byte codes
CA2514831A1 (en) * 2003-02-14 2004-08-26 Research In Motion Limited System and method of compact messaging in network communications
US7360206B1 (en) * 2003-03-13 2008-04-15 Network Appliance, Inc. Method for an interpreter to control a native function call based on a signature of the native function

Cited By (21)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101558382A (en) * 2006-10-02 2009-10-14 特兰斯蒂有限公司 Method and apparatus for administering a process filesystem with respect to program code conversion
CN102141929B (en) * 2010-10-21 2014-05-07 华为技术有限公司 Application program running method, simulator, host machine and system
CN102141929A (en) * 2010-10-21 2011-08-03 华为技术有限公司 Application program running method, simulator, host machine and system
US9921842B2 (en) 2011-01-27 2018-03-20 Intel Corporation Guest instruction block with near branching and far branching sequence construction to native instruction block
US10185567B2 (en) 2011-01-27 2019-01-22 Intel Corporation Multilevel conversion table cache for translating guest instructions to native instructions
US11467839B2 (en) 2011-01-27 2022-10-11 Intel Corporation Unified register file for supporting speculative architectural states
US10394563B2 (en) 2011-01-27 2019-08-27 Intel Corporation Hardware accelerated conversion system using pattern matching
US10042643B2 (en) 2011-01-27 2018-08-07 Intel Corporation Guest instruction to native instruction range based mapping using a conversion look aside buffer of a processor
US10241795B2 (en) 2011-01-27 2019-03-26 Intel Corporation Guest to native block address mappings and management of native code storage
CN103620553A (en) * 2011-06-10 2014-03-05 微软公司 Binding executable code at runtime
CN103620553B (en) * 2011-06-10 2016-10-12 微软技术许可有限责任公司 Operationally place's binding executable code
CN103365668B (en) * 2012-03-26 2017-12-26 联想(北京)有限公司 A kind of dynamic link library loads and the method, apparatus of link
CN103365668A (en) * 2012-03-26 2013-10-23 联想(北京)有限公司 Loading and linking method and device of dynamic link library
CN103678115B (en) * 2012-09-07 2017-09-08 三星电子株式会社 The apparatus and method of the position of source code mistake are detected in mixed mode program
CN103678115A (en) * 2012-09-07 2014-03-26 三星电子株式会社 Apparatus and method for detecting location of source code error in mixed-mode program
US10228950B2 (en) 2013-03-15 2019-03-12 Intel Corporation Method and apparatus for guest return address stack emulation supporting speculation
CN105122206B (en) * 2013-03-15 2018-11-09 英特尔公司 The method and apparatus of visitor's return-address stack emulation for supporting to speculate
US10514926B2 (en) 2013-03-15 2019-12-24 Intel Corporation Method and apparatus to allow early dependency resolution and data forwarding in a microprocessor
US10810014B2 (en) 2013-03-15 2020-10-20 Intel Corporation Method and apparatus for guest return address stack emulation supporting speculation
US11294680B2 (en) 2013-03-15 2022-04-05 Intel Corporation Determining branch targets for guest branch instructions executed in native address space
CN105122206A (en) * 2013-03-15 2015-12-02 索夫特机械公司 Method and apparatus for guest return address stack emulation supporting speculation

Also Published As

Publication number Publication date
GB2404042A (en) 2005-01-19
TW200517959A (en) 2005-06-01
JP2011123917A (en) 2011-06-23
JP5209073B2 (en) 2013-06-12
CN100483341C (en) 2009-04-29
US8108842B2 (en) 2012-01-31
US20090094586A1 (en) 2009-04-09
GB2404042B (en) 2005-06-29
US20090100416A1 (en) 2009-04-16
JP4931583B2 (en) 2012-05-16
GB0316531D0 (en) 2003-08-20
JP2007529063A (en) 2007-10-18
TWI370990B (en) 2012-08-21
HK1068700A1 (en) 2005-04-29
EP2015177A1 (en) 2009-01-14
US8091076B2 (en) 2012-01-03
GB0320717D0 (en) 2003-10-08

Similar Documents

Publication Publication Date Title
CN1823323A (en) Method and apparatus for performing native binding
CN101189578B (en) Method and apparatus for combined execution of native code and target code during program code conversion
US6609248B1 (en) Cross module representation of heterogeneous programs
US8453128B2 (en) Method and system for implementing a just-in-time compiler
KR101150003B1 (en) Software development infrastructure
CN1146788C (en) Device and method used in instruction selection of multiplatform environment
US7434209B2 (en) Method and apparatus for performing native binding to execute native code
JP4766540B2 (en) Method and apparatus for performing verification of program code conversion
JP2007529063A5 (en)
CN1922574A (en) Method and system for performing link-time code optimization without additional code analysis
Cifuentes et al. The design of a resourceable and retargetable binary translator
Yadavalli et al. Raising binaries to LLVM IR with MCTOLL (WIP paper)
US20080301652A1 (en) Apparatus and method for accelerating java translation
Cifuentes et al. Experience in the design, implementation and use of a retargetable static binary translation framework
Juričić Detecting source code similarity using low-level languages
Hirschowitz et al. Compilation of extended recursion in call-by-value functional languages
Campbell et al. Introduction to compiler construction in a Java world
WO2002097552A2 (en) Method for fast compilation of preverified java bytecode to high quality native machine code
US20040045018A1 (en) Using address space bridge in postoptimizer to route indirect calls at runtime
Ramsey et al. A transformational approach to binary translation of delayed branches
Klimiankou Interpretizer: A Compiler-Independent Conversion of Switch-Based Dispatch into Threaded Code
Lattner et al. Jello: a retargetable Just-In-Time compiler for LLVM bytecode
Blume et al. Calling variadic functions from a strongly-typed language
Morgan Implementation of an Imperative Object Calculus
Bharadwaj Optimizing Jython using invokedynamic and gradual typing

Legal Events

Date Code Title Description
C06 Publication
PB01 Publication
C10 Entry into substantive examination
SE01 Entry into force of request for substantive examination
C14 Grant of patent or utility model
GR01 Patent grant
ASS Succession or assignment of patent right

Owner name: INTERNATIONAL BUSINESS MACHINE CORP.

Free format text: FORMER OWNER: IBM YING CO., LTD.

Effective date: 20090731

Owner name: IBM YING CO., LTD.

Free format text: FORMER OWNER: TRANSITIVE LTD.

Effective date: 20090731

C41 Transfer of patent application or patent right or utility model
TR01 Transfer of patent right

Effective date of registration: 20090731

Address after: American New York

Patentee after: International Business Machines Corp.

Address before: Hampton

Patentee before: IBM UK Ltd.

Effective date of registration: 20090731

Address after: Hampton

Patentee after: IBM UK Ltd.

Address before: London, England

Patentee before: Transitive Ltd.