È possibile scrivere un compilatore JIT (in codice nativo) interamente in un linguaggio .NET gestito

Question

Mi sto prendendo gioco dell'idea di scrivere un compilatore JIT e mi sto solo chiedendo se è anche teoricamente possibile scrivere l'intera cosa nel codice gestito. In particolare, una volta generato l'assemblatore in un array di byte, come ci si butta dentro per iniziare l'esecuzione?

Answer 1

E per la piena prova di concetto: ecco un pienamente in grado traduzione di approccio Rasmus' a JIT in 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 

che esegue felicemente cedendo

Value before: FFFFFFFC 
Value after: 7FFFFFFE 

Answer 2

Utilizzando un codice non sicuro, è possibile "hackerare" un delegato e farlo puntare a un codice assembly arbitrario che è stato generato e memorizzato in un array. L'idea è che il delegato abbia un campo _methodPtr, che può essere impostato usando Reflection. Ecco alcuni esempi di codice:

• Inline x86 ASM in C#

Questo è, naturalmente, un hack sporco che potrebbe smettere di funzionare in qualsiasi momento quando cambia .NET runtime.

Immagino che, in linea di principio, il codice di sicurezza completamente gestito non possa essere in grado di implementare JIT, perché ciò interromperà qualsiasi ipotesi di sicurezza su cui si basa il runtime. (A meno che il codice assembly generato sia stato fornito con una prova controllabile dalla macchina che non viola le ipotesi ...)

Answer 3

Sì, è possibile. In effetti, è il mio lavoro :)

Ho scritto GPU.NET interamente in F # (modulo i nostri test di unità) - in realtà disassembla e JIT in IL in fase di esecuzione, proprio come fa il CLR .NET. Emettiamo codice nativo per qualunque dispositivo di accelerazione sottostante che si desidera utilizzare; al momento supportiamo solo le GPU Nvidia, ma ho progettato il nostro sistema per essere retargetable con un minimo di lavoro, quindi è probabile che supporterete altre piattaforme in futuro.

Per quanto riguarda le prestazioni, devo ringraziare F - quando compilato in modalità ottimizzata (con tailcall), il compilatore JIT stesso è probabilmente più veloce del compilatore all'interno del CLR (che è scritto in C++, IIRC).

Per l'esecuzione, abbiamo il vantaggio di poter passare il controllo ai driver hardware per eseguire il codice jitted; tuttavia, questo non sarebbe più difficile da fare sulla CPU poiché .NET supporta i puntatori di funzioni al codice non gestito/nativo (anche se si perderebbe qualsiasi sicurezza/sicurezza normalmente fornita da .NET).

Answer 4

Il trucco deve essere VirtualAlloc con il EXECUTE_READWRITE -flag (richiede P/Invoke) e Marshal.GetDelegateForFunctionPointer.

Ecco una versione modificata dell'esempio intero rotazione (si noti che nessun codice non sicuro è necessario qui):

[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 (ora funziona sia con X86 e X64).