在程序集中编写JIT编译器-WritingaJITcompilerinassembly

18  

I wouldn't recommend writing a JIT in assembly at all. There are good arguments for writing the most frequently executed bits of the interpreter in assembly. For an example of how this looks like see this comment from Mike Pall, the author of LuaJIT.

我完全不建议在程序集中编写JIT。在汇编语言中编写最频繁执行的解释器位是有很好的理由的。要了解这种情况的示例，请参见《LuaJIT》的作者Mike Pall的评论。

As for the JIT, there are many different levels with varying complexity:

至于JIT，有很多不同的层次，复杂程度不同:

1. Compile a basic block (a sequence of non-branching instructions) by simply copying the interpreter's code. For example, the implementations of a few (register-based) bytecode instructions might look like this:

   通过简单地复制解释器的代码，编译一个基本块(非分支指令序列)。例如，一些(基于寄存器的)字节码指令的实现可能是这样的:

   ; ebp points to virtual register 0 on the stack
   instr_ADD:
       
       mov eax, [ebp + ecx * 4]  ; load first operand from stack
       add eax, [ebp + edx * 4]  ; add second operand from stack
       mov [ebp + ebx * 4], eax  ; write back result
       
   instr_SUB:
       ... ; similar
   

   So, given the instruction sequence ADD R3, R1, R2, SUB R3, R3, R4 a simple JIT could copy the relevant parts of the interpreters implementation into a new machine code chunk:

   因此，给定指令序列加上R3、R1、R2、R3、R3、R4，一个简单的JIT就可以将解释器实现的相关部分复制到一个新的机器代码块中:

       mov ecx, 1
       mov edx, 2
       mov ebx, 3
       mov eax, [ebp + ecx * 4]  ; load first operand from stack
       add eax, [ebp + edx * 4]  ; add second operand from stack
       mov [ebp + ebx * 4], eax  ; write back result
       mov ecx, 3
       mov edx, 4
       mov ebx, 3
       mov eax, [ebp + ecx * 4]  ; load first operand from stack
       sub eax, [ebp + edx * 4]  ; add second operand from stack
       mov [ebp + ebx * 4], eax  ; write back result
   

   This simply copies the relevant code, so we need to initialise the registers used accordingly. A better solution would be to translate this directly into machine instructions mov eax, [ebp + 4], but now you already have to manually encode the requested instructions.

   这只是复制相关的代码，因此我们需要初始化相应使用的寄存器。更好的解决方案是直接将其转换为机器指令mov eax [ebp + 4]，但是现在您已经需要手动编码所请求的指令。

   This technique removes the overheads of interpretation, but otherwise does not improve efficiency much. If the code is executed for only one or two times, then it may not worth it to first translate it to machine code (which requires flushing at least parts of the I-cache).

   这种技术消除了解释的开销，但没有提高效率。如果代码只执行一到两次，那么首先将其转换为机器码可能不值得(这需要至少刷新I-cache的一部分)。

2. While some JITs use the above technique instead of an interpreter, they then employ a more complicated optimisation mechanism for frequently executed code. This involves translating the executed bytecode into an intermediate representation (IR) on which additional optimisations are performed.

   虽然有些JITs使用上述技术而不是解释器，但是它们会为频繁执行的代码使用更复杂的优化机制。这涉及到将已执行的字节码转换为中间表示(IR)，在其中执行额外的优化。

   Depending on the source language and the type of JIT, this can be very complex (which is why many JITs delegate this task to LLVM). A method-based JIT needs to deal with joining control-flow graphs, so they use SSA form and run various analyses on that (e.g., Hotspot).

   根据源语言和JIT的类型，这可能非常复杂(这就是为什么许多JITs将这个任务委托给LLVM)。基于方法的JIT需要处理连接控制流图，因此他们使用SSA形式并对其进行各种分析(例如，Hotspot)。

   A tracing JIT (like LuaJIT 2) only compiles straight line code which makes many things easier to implement, but you have to be very careful how you pick traces and how you link multiple traces together efficiently. Gal and Franz describe one method in this paper (PDF). For another method see the LuaJIT source code. Both JITs are written in C (or perhaps C++).

   跟踪JIT(如LuaJIT 2)只编译直线代码，这使许多事情更容易实现，但是您必须非常小心地选择跟踪，以及如何高效地将多个跟踪链接在一起。Gal和Franz在本文中描述了一种方法。有关另一个方法，请参阅LuaJIT源代码。两个JITs都是用C(或者可能是c++)编写的。

7  

I suggest you look at the project http://code.google.com/p/asmjit/. By using the framework it provides, you can save a lot of energy. If you want write all things by hand, just read the source and rewrite it yourself, I think it's not very hard.

我建议您查看项目http://code.google.com/p/asmjit/。通过使用它提供的框架，您可以节省很多能源。如果你想手工写所有的东西，只要阅读源代码并自己重写，我认为这并不难。