Có thể viết trình biên dịch JIT (sang mã gốc) hoàn toàn bằng ngôn ngữ .NET được quản lý không

Question 1

Tôi đang đùa giỡn với ý tưởng viết một trình biên dịch JIT và tôi chỉ đang tự hỏi liệu về mặt lý thuyết có thể viết toàn bộ trong mã được quản lý hay không. Đặc biệt, khi bạn đã tạo trình hợp dịch thành một mảng byte, làm cách nào để bạn chuyển vào đó để bắt đầu thực thi?

Question 2

Và để có bằng chứng đầy đủ về khái niệm ở đây là bản dịch đầy đủ khả năng của phương pháp tiếp cận JIT của Rasmus thành 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

điều đó vui vẻ thực hiện mang lại

Value before: FFFFFFFC
Value after: 7FFFFFFE

Question 3

Có, bạn có thể. Trên thực tế, đó là công việc của tôi :)

Tôi đã viết GPU.NET hoàn toàn bằng F # (modulo các bài kiểm tra đơn vị của chúng tôi) - nó thực sự tháo rời và JITs IL tại thời điểm chạy, giống như .NET CLR. Chúng tôi phát ra mã gốc cho bất kỳ thiết bị tăng tốc cơ bản nào bạn muốn sử dụng; hiện tại chúng tôi chỉ hỗ trợ GPU Nvidia, nhưng tôi đã thiết kế hệ thống của mình có thể nhắm mục tiêu lại với mức công việc tối thiểu nên có khả năng chúng tôi sẽ hỗ trợ các nền tảng khác trong tương lai.

Đối với hiệu suất, tôi có F # để cảm ơn - khi được biên dịch ở chế độ tối ưu hóa (với các cuộc gọi riêng), bản thân trình biên dịch JIT của chúng tôi có thể nhanh ngang với trình biên dịch trong CLR (được viết bằng C ++, IIRC).

Để thực thi, chúng tôi có lợi ích là có thể chuyển quyền kiểm soát cho trình điều khiển phần cứng để chạy mã jitted; tuy nhiên, điều này sẽ không khó thực hiện hơn trên CPU vì .NET hỗ trợ con trỏ chức năng đến mã không được quản lý / gốc (mặc dù bạn sẽ mất mọi an toàn / bảo mật thường được cung cấp bởi .NET).

Question 4

Thủ thuật nên là VirtualAlloc với EXECUTE_READWRITE-flag (cần P / Invoke) và Marshal.GetDelegateForFunctionPointer .

Đây là phiên bản đã sửa đổi của ví dụ số nguyên xoay (lưu ý rằng không cần mã không an toàn ở đây):

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

Ví dụ đầy đủ (hiện hoạt động với cả X86 và X64).

Question 5

Sử dụng mã không an toàn, bạn có thể "hack" một đại biểu và làm cho nó trỏ đến một mã lắp ráp tùy ý mà bạn đã tạo và lưu trữ trong một mảng. Ý tưởng là đại biểu có một _methodPtrtrường, có thể được đặt bằng cách sử dụng Phản chiếu. Đây là một số mã mẫu:

ASM nội tuyến x86 trong C #

Tất nhiên, đây là một bản hack bẩn có thể ngừng hoạt động bất cứ lúc nào khi thời gian chạy .NET thay đổi.

Tôi đoán rằng, về nguyên tắc, mã an toàn được quản lý đầy đủ không thể được phép triển khai JIT, bởi vì điều đó sẽ phá vỡ mọi giả định bảo mật mà thời gian chạy dựa vào. (Trừ khi, mã lắp ráp được tạo đi kèm với bằng chứng có thể kiểm tra bằng máy rằng nó không vi phạm các giả định ...)