Systems and methods providing lightweight runtime code generation

• US 20040255268A1
• Filed: 06/13/2003
• Published: 12/16/2004
• Est. Priority Date: 06/13/2003
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Drayton, Peter F., Russi, Dario, Meijer, Erik
• Granted Patent: US 7,219,329 B2
• Time in Patent Office: Days
• US Class Current: 717/106
• CPC Class Codes: G06F 8/447 Target code generation
• CPC Class Codes: G06F 9/45516 Runtime code conversion or optimisation

Abstract

The present invention relates to systems and methods that facilitate dynamic programming language execution in a managed code environment. A runtime code generator is provided within the framework of a managed object environment. The code generator includes a class allocator that reserves one or more method slots for a dynamic method call. A dynamic method builder then employs the method slots to generate an intermediate language stream that forms a method description. The method description is then fed to a Just-In-Tine (JIT) compiler that returns at least one dynamically generated pointer to facilitate execution of the dynamic method call at runtime.

Claims

1. A runtime code generator for a managed object environment, comprising:

a class allocator that reserves one or more method slots for a dynamic method call; and

a dynamic method builder that employs the method slots to generate an intermediate language stream and return at least one pointer to facilitate execution of the dynamic method call at runtime.

2. The system of claim 1, the class allocator reserves the one or more method slots in a method table having memory locations for function pointers that are associated with the dynamic method call.

3. The system of claim 1, the dynamic method builder creates a method description from an intermediate language stream of metadata tokens that are submitted to a Just-In-Time compiler to resolve values for the at least one pointer.

4. The system of claim 3, further comprising a user model that is exposed as a set of APIs for interacting with the compiler.

5. The system of claim 4, the APIs include at least one of a create instance delegate API, a create static delegate API, and a create function pointer API.

6. The system of claim 4, the APIs include A Dynamic Method Builder class that extends a Method Builder class to create an IL stream that contains dynamically generated metadata tokens.

7. The system of claim 1, the dynamic method call is called by a dynamic programming language that generates instructions that are executed by a virtual machine.

8. The system of claim 7, the dynamic programming language includes at least one of C#, X#, Visual Basic, ECMAScript, PHP, Perl, Scheme, Ruby, Python, and Smalltalk.

9. The system of claim 7, the virtual machine includes at least one of a Virtual Execution System (VES), a Common Language Runtime (CLR), and a Java Virtual Machine.

10. The system of claim 1, at least one of the class allocator and the dynamic method builder conform to an “

ECMA Standard”

that defines a Common Language Infrastructure (CLI).

11. The system of claim 10, the ECMA standard includes at least five partitions, the partitions including a Partition I:

Architecture, a Partition II;

Metadata Definition and Semantics, a Partition III;

CIL Instruction Set, a Partition IV;

Profiles and Libraries and a Partition V;

Annexes.

12. The system of claim 10, the Common Language Infrastructure (CLI) includes at least one of a common type system, a metadata description, a common language specification, and a Virtual Execution System.

13. The system of claim 1, further comprising at least one of a class loader, a verifier, and a Garbage collector.

14. The system of claim 13, further comprising at least one source code compiler for compiling source code to an intermediate language.

15. The system of claim 1, further comprising a bytecode verifier for analyzing output from the source code compiler.

16. The system of claim 1, the dynamic method builder applied to at least one application including at least one of a staged computation, a marshalling application, a de-marshalling application, a serialization application, a de-serialization application, an object persistence application, and an object space application.

17. The system of claim 1, further comprising a garbage collector to reclaim the dynamic method call.

18. A computer readable medium having computer readable instructions stored thereon for implementing at least one of the class allocator and the dynamic method builder of claim 1.

19. A system that facilitates dynamic code execution, comprising:

means for allocating a method table having one or more slots for storing prospective function pointers;

means for generating a method description in accordance with the method table; and

means for generating at least one resolved function pointer from the method description.

20. A method that facilitates dynamic data type processing, comprising:

constructing a user model to interact with a compiler;

reserving memory locations in accordance with the user model;

calling a dynamic function via the user model; and

automatically generating a function pointer for the dynamic function.

21. The method of claim 20, further comprising automatically updating reserved memory locations with at least one address of a dynamically generated function pointer.

22. The method of claim 20, further comprising automatically creating a method description from an intermediate language stream of metadata tokens that are submitted to a compiler to resolve values for the function pointer.

23. The method of claim 20, the user model includes at least one of a create instance delegate, a create static delegate, and a create function pointer interface.

24. The method of claim 20, the user model includes A Dynamic Method Builder class that creates a stream that contains dynamically generated tokens.

25. The method of claim 24, the dynamic method builder class is applied to at least one application including at least one of a staged computation application, a marshalling application, a de-marshalling application, a serialization application, a de-serialization application, an object persistence application, and an object space application.

26. The method of claim 20, further comprising automatically garbage collecting dynamically generated code.

27. The method of claim 20, further comprising providing one or more security procedures to facilitate operations of the dynamic function, the security procedures including at least one of:

Instantiating a DynamicMethod resulting in a demand for ReflectionPermission(ReflectionPermissionFlag.ReflectionEmit).

Instantiating a DynamicMethod where a user desires to bypass JIT visibility checks (by specifying skipVisibility==true) resulting in a demand for ReflectionPermission(ReflectionPermissionFlag.MemberAccess).

Instantiating a DynamicMethod where a caller lives in a different assembly than another assembly a new method is emitted to, resulting in a demand for SecurityPermission(SecurityPermissionFlag.ControlEvidence).

28. A computer readable medium having a data structure stored thereon, comprising:

a first data field to reserve a function pointer slot;

a second data field to provide a method description for the function pointer slot; and

a third data field to communicate with a compiler in order to receive a pointer value with respect to the function pointer slot.

29. The computer readable medium of claim 28, further comprising a Dynamic Method Builder class having at least one of the following class members:

public DynamicMethod(string name, Type returntype, Type[ ] parameterTypes, Module module);

public DynamicMethod(string name, Type returntype, Type[ ] parameterTypes, Module module, bool skipVisiblity);

public DynamicMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[ ] parameterTypes, Module module, bool skipVisiblity);

public DynamicMethod(string name, Type returnType, Type[ ] parameterTypes, Type type);

public DynamicMethod(string name, Type returnType, Type[ ] parameterTypes, Type type, bool skipVisiblity); and

public DynamicMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[ ] parameterTypes, Type type, bool skipVisiblity).

30. The computer readable medium of claim 29, further comprising at least one of the following class members:

public Delegate CreateDelegate(Type type);

public Delegate CreateDelegate(Type type, object target); and

RuntimeMethodHandle.GetFunctionPointer( ).