java - 解释器如何解释代码？

Question

为了简单起见，想象一下这个场景，我们有一台 2 位计算机，它有一对 2 位寄存器，称为 r1 和 r2，并且只适用于立即寻址。

假设位序列 00 意味着 add 到我们的 cpu。 01 表示将数据移动到 r1，10 表示将数据移动到 r2。

所以这台计算机有一个汇编语言和一个汇编器，其中的示例代码可以这样编写

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

简单地说，当我将此代码组装成本地语言时，文件将类似于:

0101 1010 0001

上面的 12 位是 native 代码:

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？如果是，它已经在 Native Code 中了，那为什么说 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