Dynamic native binding

• US 8,091,076 B2
• Filed: 09/25/2008
• Issued: 01/03/2012
• Est. Priority Date: 07/15/2003
• Status: Active Grant

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Brown, Alexander B., North, Geraint M., Weigel, Frank Thomas, Knight, Gareth Anthony
• Primary Examiner(s): Deng, Anna
• Application Number:
  US12/237,945
• Publication Number:
  US 20090100416A1
• Time in Patent Office: 1,195 Days
• Field of Search: 717/136, 717/137
• US Class Current: 717/136
• CPC Class Codes: G06F 8/52 Binary to binary
• CPC Class Codes: G06F 9/4484 Executing subprograms
• CPC Class Codes: G06F 9/4486 Formation of subprogram jump address
• CPC Class Codes: G06F 9/45516 Runtime code conversion or optimisation

Abstract

A native binding technique is provided for insetting 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 calls are transformed from target code representations to be consistent with native code representations, native code calling conventions, and native function prototypes.

Claims

1. A method of translating subject program code executable by a subject processor into target program code executable by a target processor, said method comprising:

(a) dividing the subject program code into a plurality of subject program code units;

(b) translating one or more of the subject program code units into one or more target program code units using a translator executing on the target processor interleaved with execution of the target program code by the target processor; and

(c) executing the one or more target program code units on the target processor;

wherein the step (b) further comprises dynamically identifying, by the translator at run-time while the target program code is executing on the target processor, whether at least one of the subject program code units has a corresponding native code unit which is executable natively by the target processor, and, if so, identifying the native code unit which corresponds to the identified subject program code unit, wherein the identified subject program code unit corresponds to a subject function and the identified native code unit corresponds to a native function; and

wherein the step (c) further comprises executing the corresponding native code unit instead of executing a translated version of the identified subject program code unit comprising;

transforming in target code all subject register values from the target code representation to the native code representation;

invoking from target code a native code call stub function with the transformed subject register values according to a uniform call stub interface; and

invoking from the native code call stub function the native function with particular subject register values and/or parameter stack according to a prototype of the native function.

2. The method of claim 1, wherein:

in the step (b), dynamically replacing a call in the subject program code to the identified subject function instead with a call to the corresponding native function; and

in the step (c), executing the native function instead of executing a translated version of the subject function.

3. The method of claim 2, wherein the step (c) comprises:

transforming zero or more function parameters from a target code representation to a native code representation;

invoking the native function with the transformed function parameters according to the prototype of the native function; and

transforming zero or more return values of the invoked native function from a native code representation to a target code representation.

4. The method of claim 3, wherein at least one of the transformations in the transforming steps generates an intermediate representation of the transformation.

5. The method of claim 3, wherein at least one of the transformations in the transforming steps generates target code.

6. The method of claim 3, wherein the step (c) comprises:

transforming a function parameter from a target code representation to a native code representation;

invoking the native function with the transformed function parameter according to a prototype of the native function; and

transforming a result of the invoked native function from a native code representation to a target code representation.

7. The method of claim 3, wherein the function parameter transforming step and the native function invoking step are described in subject code by translator specific instructions added to the subject instruction set.

8. The method of claim 1, wherein the steps of identifying the certain subject code unit and its corresponding native code unit are performed using a bind point description.

9. The method of claim 8, wherein the bind point description includes a subject function definition and a native function definition, wherein the subject function definition identifies the certain subject program code unit having a corresponding native code unit and the native function definition identifies the corresponding native code unit.

10. The method of claim 9, further comprising inserting in the target code a call stub to the native function during translation of the subject code when encountering the subject function contained in the bind point description.

11. The method of claim 8, wherein the bind point description is embedded within a translator performing the translation.

12. The method of claim 8, further comprising reading the bind point description from a stored bind point description file at the beginning of translation execution.

13. The method of claim 8, wherein the bind point description includes a location in the subject code and a corresponding native function, wherein the location in the subject code identifies the certain subject program code unit having corresponding native code and the native function identifies the corresponding native code unit.

14. The method of claim 1, wherein the bind point description includes a location in the subject code and a reference to code to be invoked, wherein the location in the subject code identifies the certain subject program code unit having corresponding native code and the reference to code to be invoked identifies the corresponding native code unit.

15. The method of claim 14, wherein the code to be invoked is target code.

16. The method of claim 8, wherein the bind point description includes a native function call which is inserted in the target code either before, after, or in place of a subject function call.

17. The method of claim 8, further comprising the step of performing runtime symbol patching comprising:

encoding subject-to-native function mappings in a symbol table of the subject program,

replacing entries in the symbol table of the subject program with special native binding markers, and

interpreting the special native binding markers when encountered during translation as bind point descriptions to identify an appropriate native function to call.

18. The method of claim 1, further comprising:

parsing and decoding a native binding implementation scripting language containing native binding scripts;

interpreting the native binding scripts during translation; and

generating an intermediate representation of the native binding scripts to transform a function parameter from a target code representation to a native code representation.

19. The method of claim 18, further comprising:

integrating the intermediate representation of the native binding scripts into an intermediate representation forest for a block of subject code; and

generating target code for the intermediate representation forest.

20. The method of claim 1, further comprising:

transforming in target code all subject register values from a target code representation to a native code representation;

invoking from target code a native code call stub function with the transformed subject registers according to a uniform call stub interface;

interpreting the native code call stub function; and

generating an intermediate representation of the native code call stub function binding scripts to transform a function parameter from a target code representation to a native code representation.

21. The method of claim 20, further comprising:

integrating the intermediate representation of the native code call stub function into an intermediate representation forest for a block of subject code; and

generating target code for the intermediate representation forest.

22. The method of claim 3, wherein the native function executing step further comprises:

transforming in target code all subject register values from the target code representation to the native code representation;

invoking from target code a native code call stub function with the transformed subject register values;

invoking from the native code call stub function the native function with particular subject register values and/or parameter stack according to the prototype of the native function.

23. The method of claim 1, further comprising:

parsing a scripting language implementation of a native code call stub function;

compiling the parsed native code call stub function into a native code executable module; and

linking the native code executable module with an executable for performing the translation.

24. The method of claim 23, wherein the native code executable module is executable for:

transforming in target code all subject register values from the target code representation to the native code representation;

invoking from target code a native code call stub function with the transformed subject registers; and

invoking from the native code call stub function the native function with particular subject registers and/or parameter stack according to the prototype of the native function.

25. The method of claim 23, wherein the steps of identifying the certain subject code unit and its corresponding native code unit are performed using a bind point description, said bind point description including a subject function and a native code call stub function, wherein the subject function identifies the certain subject program code unit having the corresponding native code unit and the native code call stub function identifies the corresponding native code unit.

26. The method of claim 25, further comprising encoding the identity of the native function of the native code call stub function in the scripting language implementation of the native code executable module.

27. The method of claim 3, wherein the native function executing step further comprises:

transforming in target code all subject register values from the target code representation to the native code representation;

invoking from target code a target code call stub function with the transformed subject registers; and

invoking from the target code call stub function the native function with particular subject registers and/or parameter stack according to the prototype of the native function.

28. The method of claim 27, further comprising:

generating an intermediate representation of the native function executing step;

integrating the intermediate representation of the native function executing step into an intermediate representation forest for a block of subject code; and

generating target code for the intermediate representation forest.

29. The method of claim 1, wherein the identified subject code unit to be executed is a system call.

30. The method of claim 1, wherein the identified subject code unit to be executed is a library function.

31. A computer-readable storage medium having translator software resident thereon in the form of computer-readable code executable by a computer to translate subject program code executable by a subject processor into target program code executable by a target processor, wherein the translator software performs the steps of:

(a) dividing the subject program code into a plurality of subject program code units;

(b) translating one or more of the subject program code units into one or more target program code units using a translator executing on the target processor interleaved with execution of the target program code by the target processor; and

(c) executing the one or more target program code units on the target processor;

wherein the step (b) further comprises dynamically identifying, by the translator at run-time while the target program code is executing on the target processor, whether at least one of the subject program code units has a corresponding native code unit which is executable natively by the target processor, and, if so, identifying the native code unit which corresponds to the identified subject program code unit, wherein the identified subject program code unit corresponds to a subject function and the identified native code unit corresponds to a native function; and

wherein the step (c) further comprises executing the corresponding native code unit instead of executing a translated version of the identified subject program code unit comprising;

transforming in target code all subject register values from the target code representation to the native code representation;

invoking from target code a native code call stub function with the transformed subject register values according to a uniform call stub interface; and

invoking from the native code call stub function the native function with particular subject register values and/or parameter stack according to a prototype of the native function.

32. A computer apparatus, comprising:

a target processor; and

a memory arranged to store a subject program code executable by a subject processor, and a translator code to translate the subject program code into a target program code that is executed by the target processor, including performing the steps of;

(a) dividing the subject program code into a plurality of subject program code units;

(b) translating one or more of the subject program code units into one or more target program code units using a translator executing on the target processor interleaved with execution of the target program code by the target processor; and

(c) executing the one or more target program code units on the target processor;

wherein the step (b) further comprises dynamically identifying, by the translator at run-time while the target program code is executing on the target processor, whether at least one of the subject program code units as having a corresponding native code unit which is executable natively by the target processor, and identifying the native code unit which corresponds to the identified subject program code unit, wherein the identified subject program code unit corresponds to a subject function and the identified native code unit corresponds to a native function; and

wherein the step (c) further comprises executing the corresponding native code unit instead of executing a translated version of the identified subject program code unit comprising;

transforming in target code all subject register values from the target code representation to the native code representation;

invoking from target code a native code call stub function with the transformed subject register values according to a uniform call stub interface; and

invoking from the native code call stub function the native function with particular subject register values and/or parameter stack according to a prototype of the native function.