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

Sto giocando con l'idea di scrivere un compilatore JIT e mi chiedo solo se sia anche teoricamente possibile scrivere il tutto in codice gestito. In particolare, una volta generato l'assembler in un array di byte, come ci salti per iniziare l'esecuzione?

E per la dimostrazione completa del concetto, ecco una traduzione completa dell'approccio di 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

Si, puoi. In effetti, è il mio lavoro :)

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

Per quanto riguarda le prestazioni, devo ringraziare F #: quando compilato in modalità ottimizzata (con tailcalls), il nostro compilatore JIT stesso è probabilmente veloce quanto il compilatore all'interno di 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 a funzione a codice non gestito / nativo (anche se si perde qualsiasi sicurezza normalmente fornita da .NET).

Il trucco dovrebbe essere VirtualAlloc con EXECUTE_READWRITE-flag (necessita di P / Invoke) e Marshal.GetDelegateForFunctionPointer .

Ecco una versione modificata dell'esempio rotate integer (nota che qui non è necessario codice non sicuro):

[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);
 }

Esempio completo (ora funziona sia con X86 che con X64).

Utilizzando codice non sicuro, è possibile "hackerare" un delegato e farlo puntare a un codice assembly arbitrario generato e archiviato in un array. L'idea è che il delegato abbia un _methodPtrcampo, che può essere impostato utilizzando Reflection. Ecco un codice di esempio:

• ASM x86 in linea in C #

Questo è, ovviamente, un trucco sporco che potrebbe smettere di funzionare in qualsiasi momento quando cambia il runtime .NET.

Immagino che, in linea di principio, non sia possibile consentire al codice sicuro completamente gestito di implementare JIT, perché ciò infrange qualsiasi presupposto di sicurezza su cui si basa il runtime. (A meno che, il codice assembly generato sia fornito con una prova verificabile dalla macchina che non viola i presupposti ...)