解释器如何解释代码？

Question

为简单起见，请设想这种情况，我们有一台2位计算机，它具有一对称为r1和r2的2位寄存器，并且仅适用于立即寻址。

假设位序列 00 表示 添加 到我们的CPU中。也 01 的装置将数据移动到R 1和 10组 的装置将数据移动到R2。

因此，这台计算机和一个汇编器都有一种汇编语言，其中的示例代码将像

mov r1,1
mov r2,2
add r1,r2

简而言之，当我将此代码汇编成本地语言时，文件将类似于：

0101 1010 0001

上面的12位是以下代码的本机代码：

Put decimal 1 to R1, Put decimal 2 to R2, Add the data and store in R1.

因此，这基本上就是编译代码的工作方式，对吗？

可以说有人为此架构实现了JVM。在Java中，我将编写如下代码：

int x = 1 + 2;

JVM将如何准确地解释此代码？我的意思是说最终必须将相同的位模式传递给CPU，不是吗？所有的cpu都有许多可以理解和执行的指令，毕竟它们只是一点点。可以说编译后的Java字节码如下所示：

1111 1100 1001

等等。这是否意味着解释在执行时将此代码更改为0101 1010
0001？如果是的话，它已经在本机代码中了，那么为什么要说JIT只在几次之后才启动？如果它不能完全将其转换为0101 1010
0001，那么它将做什么？它如何使cpu进行加法运算？

我的假设也许有一些错误。

我知道解释的速度很慢，编译的代码速度更快，但不具有可移植性，虚拟机可以“解释”代码，但是如何？我正在寻找“如何正确/技术地解释”。欢迎使用任何指针（例如书籍或网页），而不是答案。

Answer 1

不幸的是，您描述的CPU体系结构太局限了，无法通过所有中间步骤将其弄清楚。取而代之的是，我将编写伪C和伪x86汇编程序，希望以一种清晰的方式编写而不会非常熟悉C或x86。

编译后的JVM字节码可能看起来像这样：

ldc 0 # push first first constant (== 1)
ldc 1 # push the second constant (== 2)
iadd # pop two integers and push their sum
istore_0 # pop result and store in local variable

解释器在数组中具有（这些指令的二进制编码）这些指令，以及一个引用当前指令的索引。它还有一个常量数组，一个存储区用作堆栈，一个存储区用作局部变量。然后，解释器循环如下所示：

while (true) {
    switch(instructions[pc]) {
    case LDC:
        sp += 1; // make space for constant
        stack[sp] = constants[instructions[pc+1]];
        pc += 2; // two-byte instruction
    case IADD:
        stack[sp-1] += stack[sp]; // add to first operand
        sp -= 1; // pop other operand
        pc += 1; // one-byte instruction
    case ISTORE_0:
        locals[0] = stack[sp];
        sp -= 1; // pop
        pc += 1; // one-byte instruction
    // ... other cases ...
    }
}

该 C代码被编译为机器代码并运行。如您所见，它是高度动态的：每次执行该指令时，它都会检查每个字节码指令，并且所有值都会通过堆栈（即RAM）。

虽然实际的加法本身可能发生在寄存器中，但是加法周围的代码与Java到计算机的代码编译器发出的代码完全不同。这是C编译器可能将以上内容转换为（pseudo-x86）的摘录：

.ldc:
incl %esi # increment the variable pc, first half of pc += 2;
movb %ecx, program(%esi) # load byte after instruction
movl %eax, constants(,%ebx,4) # load constant from pool
incl %edi # increment sp
movl %eax, stack(,%edi,4) # write constant onto stack
incl %esi # other half of pc += 2
jmp .EndOfSwitch

.addi
movl %eax, stack(,%edi,4) # load first operand
decl %edi # sp -= 1;
addl stack(,%edi,4), %eax # add
incl %esi # pc += 1;
jmp .EndOfSwitch

您可以看到，加法运算的操作数来自内存，而不是进行硬编码，即使对于Java程序而言，它们是恒定的。那是因为 对于解释器来说
，它们不是常数。解释器将被编译一次，然后必须能够执行各种程序，而无需生成专门的代码。

JIT编译器的目的就是这样做：生成专用代码。JIT可以分析使用堆栈传输数据的方式，程序中各种常量的实际值以及执行的计算顺序，以生成更有效地执行相同操作的代码。在我们的示例程序中，它将为寄存器分配局部变量0，将常量表的访问替换为将常量移动到寄存器（movl %eax, $1）中，并将堆栈访问重定向到正确的机器寄存器。忽略通常可以完成的其他一些优化（复制传播，常量折叠和无效代码消除），最终可能会得到如下代码：

movl %ebx, $1 # ldc 0
movl %ecx, $2 # ldc 1
movl %eax, %ebx # (1/2) addi
addl %eax, %ecx # (2/2) addi
# no istore_0, local variable 0 == %eax, so we're done