क्या एक पूरी तरह से प्रबंधित .NET भाषा

Question

में एक जेआईटी कंपाइलर (मूल कोड में) लिखना संभव है। मैं एक जेआईटी कंपाइलर लिखने के विचार से टकरा रहा हूं और सोच रहा हूं कि क्या यह पूरी बात लिखने के लिए सैद्धांतिक रूप से संभव है प्रबंधित कोड में। विशेष रूप से, एक बार जब आप एक बाइट सरणी में असेंबलर उत्पन्न कर लेते हैं तो आप इसे निष्पादन शुरू करने के लिए कैसे कूदते हैं?

Answer 1

और अवधारणा यहां का पूरा सबूत के लिए एक पूरी तरह सक्षम एफ #

open System 
open System.Runtime.InteropServices 

type AllocationType = 
    | COMMIT=0x1000u 

type MemoryProtection = 
    | EXECUTE_READWRITE=0x40u 

type FreeType = 
    | DECOMMIT = 0x4000u 

[<DllImport("kernel32.dll", SetLastError=true)>] 
extern IntPtr VirtualAlloc(IntPtr lpAddress, UIntPtr dwSize, AllocationType flAllocationType, MemoryProtection flProtect); 

[<DllImport("kernel32.dll", SetLastError=true)>] 
extern bool VirtualFree(IntPtr lpAddress, UIntPtr dwSize, FreeType freeType); 

let JITcode: byte[] = [|0x55uy;0x8Buy;0xECuy;0x8Buy;0x45uy;0x08uy;0xD1uy;0xC8uy;0x5Duy;0xC3uy|] 

[<UnmanagedFunctionPointer(CallingConvention.Cdecl)>] 
type Ret1ArgDelegate = delegate of (uint32) -> uint32 

[<EntryPointAttribute>] 
let main (args: string[]) = 
    let executableMemory = VirtualAlloc(IntPtr.Zero, UIntPtr(uint32(JITcode.Length)), AllocationType.COMMIT, MemoryProtection.EXECUTE_READWRITE) 
    Marshal.Copy(JITcode, 0, executableMemory, JITcode.Length) 
    let jitedFun = Marshal.GetDelegateForFunctionPointer(executableMemory, typeof<Ret1ArgDelegate>) :?> Ret1ArgDelegate 
    let mutable test = 0xFFFFFFFCu 
    printfn "Value before: %X" test 
    test <- jitedFun.Invoke test 
    printfn "Value after: %X" test 
    VirtualFree(executableMemory, UIntPtr.Zero, FreeType.DECOMMIT) |> ignore 
    0 

कि खुशी से एक में एक JIT कम्पाइलर लेखन

Value before: FFFFFFFC 
Value after: 7FFFFFFE 

Answer 2

असुरक्षित कोड का उपयोग करके, आप एक प्रतिनिधि को "हैक" कर सकते हैं और इसे एक मनमानी असेंबली कोड को इंगित कर सकते हैं जिसे आपने जेनरेट किया है और एक सरणी में संग्रहीत किया है। विचार यह है कि प्रतिनिधि के पास _methodPtr फ़ील्ड है, जिसे प्रतिबिंब का उपयोग करके सेट किया जा सकता है। यहां कुछ नमूना कोड है:

• Inline x86 ASM in C#

यह वह जगह है, ज़ाहिर है, एक गंदा हैक है कि किसी भी समय था जब .NET रनटाइम परिवर्तन पर काम करना बंद कर सकता है की।

मुझे लगता है कि, सिद्धांत रूप में, पूरी तरह से प्रबंधित सुरक्षित कोड को जेआईटी को लागू करने की अनुमति नहीं दी जा सकती है, क्योंकि यह रनटाइम पर निर्भर करता है कि किसी भी सुरक्षा धारणा को तोड़ देगा। (जब तक, जेनरेटेड असेंबली कोड मशीन-चेक करने योग्य सबूत के साथ नहीं आया है कि यह धारणाओं का उल्लंघन नहीं करता है ...)

Answer 3

हाँ, आप कर सकते हैं। असल में, यह मेरा काम है :)

मैंने पूरी तरह से एफ # (मॉड्यूलो हमारे यूनिट परीक्षण) में GPU.NET लिखा है - यह वास्तव में .NET CLR की तरह रन-टाइम पर डिस्सेबल और जेआईटीएस आईएल लिखा है। हम जो भी अंतर्निहित त्वरण उपकरण का उपयोग करना चाहते हैं उसके लिए हम देशी कोड उत्सर्जित करते हैं; वर्तमान में हम केवल एनवीडिया जीपीयू का समर्थन करते हैं, लेकिन मैंने अपने सिस्टम को कम से कम काम के साथ पुनः लक्षित करने के लिए डिज़ाइन किया है, इसलिए संभवतः हम भविष्य में अन्य प्लेटफॉर्म का समर्थन करेंगे।

प्रदर्शन के लिए, मेरे पास एफ # धन्यवाद है - ऑप्टिमाइज्ड मोड (टेलकॉल के साथ) में संकलित होने पर, हमारे जेआईटी कंपाइलर शायद सीएलआर (जो सी ++, आईआईआरसी में लिखा गया है) के भीतर कंपाइलर जितना तेज हो।

निष्पादन के लिए, हमारे पास जेट कोड चलाने के लिए हार्डवेयर ड्राइवरों को नियंत्रण पास करने में सक्षम होने का लाभ है; हालांकि, सीपीयू पर ऐसा करना मुश्किल नहीं होगा क्योंकि .NET फ़ंक्शन पॉइंटर्स को अप्रबंधित/मूल कोड के लिए समर्थन करता है (हालांकि आप सामान्य रूप से .NET द्वारा प्रदान की गई कोई सुरक्षा/सुरक्षा खो देंगे)।

Answer 4

चाल VirtualAllocEXECUTE_READWRITE -flag (पी/Invoke की आवश्यकता है) और Marshal.GetDelegateForFunctionPointer के साथ होना चाहिए।

[UnmanagedFunctionPointer(CallingConvention.Cdecl)] 
public delegate uint Ret1ArgDelegate(uint arg1); 

public static void Main(string[] args){ 
    // Bitwise rotate input and return it. 
    // The rest is just to handle CDECL calling convention. 
    byte[] asmBytes = new byte[] 
    {   
     0x55,    // push ebp 
     0x8B, 0xEC,  // mov ebp, esp 
     0x8B, 0x45, 0x08, // mov eax, [ebp+8] 
     0xD1, 0xC8,  // ror eax, 1 
     0x5D,    // pop ebp 
     0xC3    // ret 
    }; 

    // Allocate memory with EXECUTE_READWRITE permissions 
    IntPtr executableMemory = 
     VirtualAlloc(
      IntPtr.Zero, 
      (UIntPtr) asmBytes.Length,  
      AllocationType.COMMIT, 
      MemoryProtection.EXECUTE_READWRITE 
     ); 

    // Copy the machine code into the allocated memory 
    Marshal.Copy(asmBytes, 0, executableMemory, asmBytes.Length); 

    // Create a delegate to the machine code. 
    Ret1ArgDelegate del = 
     (Ret1ArgDelegate) Marshal.GetDelegateForFunctionPointer(
      executableMemory, 
      typeof(Ret1ArgDelegate) 
     ); 

    // Call it 
    uint n = (uint)0xFFFFFFFC; 
    n = del(n); 
    Console.WriteLine("{0:x}", n); 

    // Free the memory 
    VirtualFree(executableMemory, UIntPtr.Zero, FreeType.DECOMMIT); 
} 

Full example (अब दोनों x86 और x64 के साथ काम करता है):

यहाँ घुमाने पूर्णांक उदाहरण का एक संशोधित संस्करण (ध्यान दें कि असुरक्षित कोड यहाँ की जरूरत है) है।