क्या यह पूरी तरह से एक प्रबंधित .NET भाषा में JIT संकलक (मूल कोड में) लिखना संभव है

Question 1

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

Question 2

और अवधारणा के पूर्ण प्रमाण के लिए यहाँ Rasmus के दृष्टिकोण का पूरी तरह से सक्षम अनुवाद है JIT में F #

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

जो खुशी से पैदावार को अंजाम देता है

Value before: FFFFFFFC
Value after: 7FFFFFFE

Question 3

हाँ तुम कर सकते हो। वास्तव में, यह मेरा काम है :)

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

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

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

Question 4

चाल होना चाहिए VirtualAlloc साथ EXECUTE_READWRITE-flag और (पी / आह्वान की जरूरत है) 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);
 }

पूर्ण उदाहरण (अब X86 और X64 दोनों के साथ काम करता है)।

Question 5

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

इनलाइन x86 ASM C # में

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

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