用Java手写JVM第五章——指令集和解释器
文章目录
- 代码目录
- 一、字节码和指令集
- 二、指令和指令解码
-
- Instruction
- ①InstructionNoOperands
- ②InstructionBranch
- ③InstructionIndex8
- ④InstructionIndex16
- BytecodeReader
- 三、九种指令的实现
-
- 1、常量指令
-
- ①nop指令：
- ②const指令：
- ③BIPUSH和SIPUSH指令：
- 2、加载指令
- 3、存储指令
- 4、栈指令
-
- ①pop和pop2指令：
- ②dup指令：
- ③swap指令：
- 5、数字指令
-
- ①算术指令：
- ②位移指令：
- ③布尔运算指令：
- ④iinc指令：
- 6、类型转换指令
- 7、比较指令
-
- ①lcmp指令：
- ②fcmp和dcmp指令：
- ③ifcond指令：
- ④if_icmp指令：
- ⑤if_acmp指令：
- 8、控制指令
-
- ①goto指令：
- ②tableswitch指令：
- ③lookupswitch指令：
- 9、扩展指令
-
- ①WIDE指令：
- ②IFNULL和IFNONNULL指令：
- ③GOTO_W指令：
- 四、解释器
- 五、测试
由第3章可知，编译之后的Java方法以字节码的形式存储在class文件中。在第4章中，初步实现了Java虚拟机栈、帧、操作数栈和局部变量表等运行时数据区。本章将在前两章的基础上编写一个简单的解释器，并且实现大约150条指令。
代码目录
ZYX-demo-jvm-04
├── pom.xml
└── src
└── main
│ └── java
│ └── org.ZYX.demo.jvm
│ ├── classfile
│ │ ├── attributes
│ │ ├── constantpool
│ │ ├── ClassFile.java
│ │ ├── ClassReader.java
│ │ └── MemberInfo.java
│ ├── classpath
│ │ ├── impl
│ │ │ ├── CompositeEntry.java
│ │ │ ├── DirEntry.java
│ │ │ ├── WildcardEntry.java
│ │ │ └── ZipEntry.java
│ │ ├── Classpath.java
│ │ └── Entry.java
│ ├── rtda
│ │ ├── Frame.java
│ │ ├── JmvStack.java
│ │ ├── LocalVars.java
│ │ ├── OperandStack.java
│ │ ├── Slot.java
│ │ └── Thread.java
│ ├── instructions
│ │ ├── base
│ │ ├── conparisons
│ │ ├── constants
│ │ ├── control
│ │ ├── conversions
│ │ ├── extended
│ │ ├── loads
│ │ ├── math
│ │ ├── stack
│ │ ├── stores
│ │ └── Factory.java
│ ├── Cmd.java
│ ├── Interpret.java
│ └── Main.java
└── test
└── java
└── org.ZYX.demo.test
└── HelloWorld.java
一、字节码和指令集
字节码就是运行在Java虚拟机上的机器码。我们已经知道，每一个类或者接口都会被Java编译器编译成一个class文件，类或接口的方法信息就放在class文件的method_info结构中。如果方法不是抽象的，也不是本地方法，方法的Java代码就会被编译器编译成字节码（即使方法是空的，编译器也会生成一条return语句），存放在method_info结构的Code属性中。
字节码中存放编码后的Java虚拟机指令。每条指令都以一个单字节的操作码（opcode）开头。由于只使用一字节表示操作码，显而易见，Java虚拟机最多只能支持256（2^8）条指令。
到第八版为止，Java虚拟机规范已经定义了205条指令，操作码分别是0（0x00）到202（0xCA）、254（0xFE）和255（0xFF）。为了方便记忆，每个操作码又有独自的助记符。
Java虚拟机规范把已经定义的205条指令按用途分成了11类，分别是：常量（constants）指令、加载（loads）指令、存储（stores）指令、操作数栈（stack）指令、数学（math）指令、转换（conversions）指令、比较（comparisons）指令、控制（control）指令、引用（references）指令、扩展（extended）指令和保留（reserved）指令。
本章将要实现的指令涉及11类中的9类。为了便于管理，我们把所有指令都共用的代码则放在base里。
二、指令和指令解码
Java虚拟机解释器的大致逻辑是一个循环，每次循环都包含三个部分：计算pc、指令解码、指令执行。我们采用一种方式：把指令抽象成接口，解码和执行逻辑写在具体的指令实现中。
Instruction
首先是定义Instruction指令接口，代码如下：
public interface Instruction {
//从字节码中提取操作数；
void fetchOperands(BytecodeReader reader);
//执行指令逻辑；
void execut (Frame frame);
}
①InstructionNoOperands
再编写Instruction的实现类①InstructionNoOperands，表示没有操作数的指令，代码如下：
public class InstructionNoOperands implements Instruction {
@Override
public void fetchOperands(BytecodeReader reader) {
//empty
}
@Override
public void execute(Frame frame) {
// nothing to do
}
}
②InstructionBranch
②InstructionBranch，表示跳转指令，代码如下：
public class InstructionBranch implements Instruction {
//跳转偏移量；
protected int offset;
//从字节码中读取一个Int16整数，赋给Offset字段；
@Override
public void fetchOperands(BytecodeReader reader) {
this.offset = reader.readShort();
}
@Override
public void execute(Frame frame) {
}
}
③InstructionIndex8
③InstructionIndex8，存储和加载类指令需要根据索引存取局部变量表，索引由单字节操作数给出。把这类指令抽象成InstructionBranch结构体，用Index字段表示局部变量表索引。代码如下：
public class InstructionIndex8 implements Instruction {
public int idx;
//从字节码中读取一个int8整数，赋给Index字段；
@Override
public void fetchOperands(BytecodeReader reader) {
this.idx = reader.readByte();
}
@Override
public void execute(Frame frame) {
}
}
④InstructionIndex16
④InstructionIndex16，有一些指令需要访问运行时常量池，常量池索引由两字节操作数给出。把这类指令抽象InstructionIndex16结构体，用Index字段表示常量池索引。代码如下：
public class InstructionIndex16 implements Instruction {
protected int idx;
//从字节码中读取一个int16整数，赋给Index字段；
@Override
public void fetchOperands(BytecodeReader reader) {
this.idx = reader.readShort();
}
@Override
public void execute(Frame frame) {
}
}
BytecodeReader
指令接口和“抽象”指令定义好了，再来看看BytecodeReader:
public class BytecodeReader {
//code字段存放字节码，pc字段记录读取到了哪个字节；
private byte[] codes;
private int pc;
//为了避免每次解码指令都新创建一个BytecodeReader实例，给它定义一个Reset（）方法；
public void reset(byte[] codes, int pc) {
this.codes = codes;
this.pc = pc;
}
public int pc() {
return this.pc;
}
//[go]int8 = [java]byte
public byte readByte() {
byte code = this.codes[this.pc];
this.pc++;
return code;
}
//[go]int16 = [java]short，连续读取2字节；
public short readShort() {
byte byte1 = readByte();
byte byte2 = readByte();
return (short) ((byte1 << 8) | byte2);
}
//[go]int32 = [java]int，连续读取4字节；
public int readInt() {
int byte1 = this.readByte();
int byte2 = this.readByte();
int byte3 = this.readByte();
int byte4 = this.readByte();
return (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;
}
//used by lookupswitch and tableswitch，后面实现这两种指令时再介绍；
public int[] readInts(int n) {
int[] ints = new int[n];
for (int i = 0; i < n; i++) {
ints[i] = this.readInt();
}
return ints;
}
//used by lookupswitch and tableswitcch；
public void skipPadding() {
while (this.pc % 4 != 0) {
this.readByte();
}
}
}
三、九种指令的实现
在接下来的9个小节中，将按照分类依次实现约150条指令，占整个指令集的3/4。很多指令其实是非常相似的。比如iload、lload、fload、dload和aload这5条指令，除了操作的数据类型不同以外，代码几乎一样。再比如iload_0、iload_1、iload_2和iload_3这四条指令，只是iload指令的特例（局部变量表索引隐含在操作码中），操作逻辑完全一样。
1、常量指令
常量指令把常量推入操作数栈顶。常量可以来自三个地方：隐含在操作码里、操作数和运行时常量池。常量指令共有21条，本节实现其中的18条。另外3条是ldc系列指令，用于从运行时常量池中加载常量，将在第6章介绍。
①nop指令：
nop指令是最简单的一条指令，因为它什么也不用做。代码如下：
public class NOP extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
//啥也不用做
}
}
②const指令：
这一系列指令把隐含在操作码中的常量值推入操作数栈顶。其中定义了15条指令，它们都继承自InstructionNoOperands：
ACONST_NULL
DCONST_0
DCONST_1
FCONST_0
FCONST_1
FCONST_2
ICONST_M1
ICONST_0
ICONST_1
ICONST_2
ICONST_3
ICONST_4
ICONST_5
LCONST_0
LCONST_1
以三条指令为例进行说明：
ACONST_NULL
//把null引用推入操作数栈顶；
public class ACONST_NULL extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
frame.operandStack().pushRef(null);
}
}
DCONST_0
//把double型0推入操作数栈顶；
public class DCONST_0 extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
frame.operandStack().pushDouble(0.0);
}
}
ICONST_M1
//把int型-1推入操作数栈顶
public class ICONST_M1 extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
frame.operandStack().pushInt(-1);
}
}
③BIPUSH和SIPUSH指令：
bipush指令从操作数中获取一个byte型整数，扩展成int型，然后推入栈顶。sipush指令从操作数中获取一个short型整数，扩展成int型，然后推入栈顶。代码如下：
public class BIPUSH implements Instruction {
private byte val;
@Override
public void fetchOperands(BytecodeReader reader) {
this.val = reader.readByte();
}
@Override
public void execute(Frame frame) {
frame.operandStack().pushInt(val);
}
}
public class SIPUSH implements Instruction {
private short val;
@Override
public void fetchOperands(BytecodeReader reader) {
this.val = reader.readShort();
}
@Override
public void execute(Frame frame) {
frame.operandStack().pushInt(val);
}
}
2、加载指令
加载指令从局部变量表获取变量，然后推入操作数栈顶。加载指令共33条，按照所操作变量的类型可以分为6类：aload系列指令操作引用类型变量、dload系列操作double类型变量、fload系列操作float变量、iload系列操作int变量、lload系列操作long变量、xaload操作数组。本节实现其中的25条，数组和xaload系列指令将在第8章讨论。下面以iload系列为例介绍加载指令。
ILOAD extends InstructionIndex8;
ILOAD_0 extends InstructionNoOperands;
ILOAD_1 extends InstructionNoOperands;
ILOAD_2 extends InstructionNoOperands;
ILOAD_3 extends InstructionNoOperands;
下面是ILOAD的代码实现，iload指令的索引来自操作数：
public class ILOAD extends InstructionIndex8 {
@Override
public void execute(Frame frame) {
int val = frame.localVars().getInt(this.idx);
frame.operandStack().pushInt(val);
}
}
然后是ILOAD_0等4条指令，其索引隐含在操作码中：
public class ILOAD_0 extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
int val = frame.localVars().getInt(0);
frame.operandStack().pushInt(val);
}
}
3、存储指令
和加载指令刚好相反，存储指令把变量从操作数栈顶弹出，然后存入局部变量表。和加载指令一样，存储指令也可以分为6类。以lstore系列指令为例进行介绍。
ASTORE extends InstructionIndex8;
ASTORE_0 extends InstructionNoOperands;
ASTORE_1 extends InstructionNoOperands;
ASTORE_2 extends InstructionNoOperands;
ASTORE_3 extends InstructionNoOperands;
下面是LSTORE的代码实现，lstore指令的索引来自操作数：
public class LSTORE extends InstructionIndex8 {
@Override
public void execute(Frame frame) {
_lstore(frame, this.idx);
}
}
然后是LSTORE_2等4条指令，其索引隐含在操作码中：
public class LSTORE_2 extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
_lstore(frame, 2);
}
}
4、栈指令
栈指令直接对操作数栈进行操作，共9条：pop和pop2指令将栈顶变量弹出，dup系列指令复制栈顶变量，swap指令交换栈顶的两个变量。
和其他类型的指令不同，栈指令并不关心变量类型。为了实现栈指令，需要给OperandStack结构体添加两个方法：pushSlot和popSlot，其实现如下：
public void pushSlot(Slot slot) {
this.slots[this.size] = slot;
this.size++;
}
public Slot popSlot(){
this.size --;
return this.slots[this.size];
}
①pop和pop2指令：
pop指令把栈顶变量弹出，代码如下：
public class POP extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
stack.popSlot();
}
}
pop指令只能用于弹出int、float等占用一个操作数栈位置的变量。double和long变量在操作数栈中占据两个位置，需要使用pop2指令弹出，代码如下：
public class POP2 extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
stack.popSlot();
stack.popSlot();
}
}
②dup指令：
其中定义了6条指令，它们都继承自InstructionNoOperands，如下：
DUP
DUP2
DUP2_X1
DUP2_X2
DUP_X1
DUP_X2
以两条指令为例进行说明：
DUP：复制栈顶的单个变量
public class DUP extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
Slot slot = stack.popSlot();
stack.pushSlot(slot);
stack.pushSlot(slot);
}
}
DUP2则就是复制栈顶的两个变量。
DUP2_X1：复制顶部的一个或两个操作数堆栈值，向下插入两个或三个值。
public class DUP2_X1 extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
Slot slot1 = stack.popSlot();
Slot slot2 = stack.popSlot();
Slot slot3 = stack.popSlot();
stack.pushSlot(slot2);
stack.pushSlot(slot1);
stack.pushSlot(slot3);
stack.pushSlot(slot2);
stack.pushSlot(slot1);
}
}
DUP2_X2则就是复制顶部的一个或两个操作数堆栈值，向下插入两个、三个或四个值。
③swap指令：
SWAP指令交换栈顶的两个变量，代码如下：
public class SWAP extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
Slot slot1 = stack.popSlot();
Slot slot2 = stack.popSlot();
stack.pushSlot(slot1);
stack.pushSlot(slot2);
}
}
5、数字指令
数学指令大致对应Java语言中的加、减、乘、除等数学运算符。数学指令包括算术指令、位移指
令和布尔运算指令等，共37条，将全部在本节实现。
①算术指令：
算术指令又可以进一步分为加法（add）指令、减法（sub）指令、乘法（mul）指令、除法（div）指令、求余（rem）指令和取反（neg）指令6种。加、减、乘、除和取反指令都比较简单，我们以稍微复杂一些的求余指令为例进行讨论。
IREM和LREM
IREM和LREM差不多，以IREM为例，代码如下：
/*先从操作数栈中弹出两个int变量，求余，然后把结果推入操作数栈。
这里注意一点，对int或long变量做除法和求余运算时，是有可能抛出ArithmeticException异常的。
*/
public class IREM extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
int v2 = stack.popInt();
int v1 = stack.popInt();
if (v2 == 0) {
throw new ArithmeticException("/ by zero");
}
int res = v1 % v2;
stack.pushInt(res);
}
}
DREM和FREM
DREM和FREM差不多，以DREM为例，代码如下：
public class DREM extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
double v2 = stack.popDouble();
double v1 = stack.popDouble();
double res = v1 % v2;
stack.pushDouble(res);
}
}
②位移指令：
位移指令可以分为左移和右移两种，右移指令又可以分为算术右移（有符号右移）和逻辑右移（无符号右移）两种。算术右移和逻辑位移的区别仅在于符号位的扩展（>>：带符号右移。正数右移高位补0，负数右移高位补1；>>>：无符号右移。无论是正数还是负数，高位通通补0。）。其中定义了6条位移指令，都继承自InstructionNoOperands：
ISHL //int左位移
ISHR //int算术右移
IUSHR //int逻辑右移
LSHL //long左位移
LSHR //long算术右移
LUSHR //long逻辑右移
左位移指令以ISHL为例：
/*先从操作数栈中弹出两个int变量v2和v1。
v1是要进行位移操作的变量，v2指出要移位多少比特。位移之后，把结果推入操作数栈。
这里注意，int变量只有32位，所以只取v2的前5个比特就足够表示位移位数了。
*/
public class ISHL extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
int v2 = stack.popInt();
int v1 = stack.popInt();
int s = v2 & 0x1f;
int res = v1 << s;
stack.pushInt(res);
}
}
算术右移指令以LSHR为例：
/*算术右移指令需要扩展符号位，代码和左移指令基本上差不多。
long变量有64位，所以取v2的前6个比特。
*/
public class LSHR extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
int v2 = stack.popInt();
long v1 = stack.popLong();
long s = v2 & 0x3f;
long res = v1 >> s;
stack.pushLong(res);
}
}
逻辑右移指令以IUSHR为例：
public class IUSHR extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
int v2 = stack.popInt();
int v1 = stack.popInt();
int s = v2 & 0x1f;
int res = v1 >>> s;
stack.pushInt(res);
}
}
③布尔运算指令：
布尔运算指令只能操作int和long变量，分为按位与（and）、按位或（or）、按位异或（xor）3种。以按位与为例介绍布尔运算指令。
IAND和LAND，代码如下：
public class IAND extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
int v2 = stack.popInt();
int v1 = stack.popInt();
int res = v1 & v2;
stack.pushInt(res);
}
}
public class LAND extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
long v2 = stack.popLong();
long v1 = stack.popLong();
long res = v1 & v2;
stack.pushLong(res);
}
}
④iinc指令：
iinc指令给局部变量表中的int变量增加常量值，局部变量表索引和常量值都由指令的操作数提供，代码如下：
public class IINC implements Instruction {
public int idx;
public int constVal;
//从字节码里读取操作数；
@Override
public void fetchOperands(BytecodeReader reader) {
this.idx = reader.readByte();
this.constVal = reader.readByte();
}
//从局部变量表中读取变量，给它加上常量值，再把结果写回局部变量表；
@Override
public void execute(Frame frame) {
LocalVars vars = frame.localVars();
int val = vars.getInt(this.idx);
val += this.constVal;
vars.setInt(this.idx, val);
}
}
6、类型转换指令
类型转换指令大致对应Java语言中的基本类型强制转换操作。类型转换指令有共15条，将全部在
本节实现。引用类型转换对应的是checkcast指令，将在第6章介绍。
按照被转换变量的类型，类型转换指令可以分为3种：i2x系列指令把int变量强制转换成其他类型；12x系列指令把long变量强制转换成其他类型；f2x系列指令把float变量强制转换成其他类型；d2x系列指令把double变量强制转换成其他类型。以d2x系列指令为例进行讨论。
id2x中可以定义d2f、d2i和d2l指令：
d2f extends InstructionNoOperands
d2i ……
d2l ……
以d2i为例，代码如下：
public class D2I extends InstructionNoOperands {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
double d = stack.popDouble();
int i = (int) d;
stack.pushInt(i);
}
}
7、比较指令
比较指令可以分为两类：一类将比较结果推入操作数栈顶，一类根据比较结果跳转。比较指令是编译器实现if-else、for、while等语句的基石，共有19条，将全部在本节实现。
①lcmp指令：
lcmp指令用于比较long变量，代码如下：
public class LCMP extends InstructionNoOperands {
//Execute（）方法把栈顶的两个long变量弹出，进行比较，然后把比较结果（int型0、1或-1）推入栈顶；
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
long v2 = stack.popLong();
long v1 = stack.popLong();
if (v1 > v2) {
stack.pushInt(1);
return;
}
if (v1 == v2) {
stack.pushInt(0);
return;
}
stack.pushInt(-1);
}
}
②fcmp和dcmp指令：
fcmp：用于比较float变量。在fcmp中定义了fcmpg和fcmpl指令。这两条指令和lcmp指令很像，但是除了比较的变量类型不同以外，还有一个重要的区别。由于浮点数计算有可能产生NaN（Not a Number）值，所以比较两个浮点数时，除了大于、等于、小于之外，还有第4种结果：无法比较。fcmpg和fcmpl指令的区别就在于对第4种结果的定义。也就是说，当两个float变量中至少有一个是NaN时，用fcmpg指令比较的结果是1，而用fcmpl指
令比较的结果是-1。这里就不贴代码了。
dcmp：用于比较double变量，其余跟fcmp一样，这里就不详细介绍了。
③ifcond指令：
其中定义6条指令如下：
IFEQ extends InstructionBranch
IFGE ……
IFGT ……
IFLE ……
IFLT ……
IFNE ……
ifcond指令把操作数栈顶的int变量弹出，然后跟0进行比较，满足条件则跳转。假设从栈顶弹出的变量是x，则指令执行跳转操作的条件如下：
·ifeq：x==0
·ifne：x！=0
·iflt：x<0
·ifle：x<=0
·ifgt：x>0
·ifge：x>=0
以ifeq指令为例，代码如下：
public class IFEQ extends InstructionBranch {
@Override
public void execute(Frame frame) {
int val = frame.operandStack().popInt();
if (0 == val) {
Instruction.branch(frame, this.offset);
}
}
}
真正的跳转逻辑在Branch（）函数中。因为这个函数在很多指令中都会用到，所以把它定义在instruction.base.Instruction接口中，代码如下：
static void branch(Frame frame, int offset) {
int pc = frame.thread().pc();
int nextPC = pc + offset;
frame.setNextPC(nextPC);
}
Frame结构体的SetNextPC（）方法将在五.四.小节解释器中介绍。
④if_icmp指令：
其中定义6条指令如下：
IF_ICMPEQ extends InstructionBranch
IF_ICMPGE……
IF_ICMPGT……
IF_ICMPLE……
IF_ICMPLT……
IF_ICMPNE……
if_icmp指令把栈顶的两个int变量弹出，然后进行比较，满足条件则跳转。跳转条件和if指令类似。以if_icmpne指令为例，代码如下：
public class IF_ICMPNE extends InstructionBranch {
@Override
public void execute(Frame frame) {
OperandStack stack = frame.operandStack();
int val2 = stack.popInt();
int val1 = stack.popInt();
if (val1 != val2) {
Instruction.branch(frame, this.offset);
}
}
}
⑤if_acmp指令：
在其中定义两条if_acmp指令，if_acmpeq和if_acmpne，把栈顶的两个引用弹出，根据引用是否相同进行跳转。
IF_ACMPEQ extends InstructionBranch
IF_ACMPNE extends InstructionBranch
以if_acmpeq指令为例，代码如下：
public class IF_ACMPEQ extends InstructionBranch {
@Override
public void execute(Frame frame) {
if (_acmp(frame)) {
Instruction.branch(frame, this.offset);
}
}
}
8、控制指令
①goto指令：
goto指令进行无条件跳转，代码如下：
public class GOTO extends InstructionBranch {
@Override
public void execute(Frame frame) {
Instruction.branch(frame, this.offset);
}
}
②tableswitch指令：
Java语言中的switch-case语句有两种实现方式：如果case值可以编码成一个索引表，则实现成tableswitch指令；否则实现成lookupswitch指令。
下面这个Java方法中的switch-case可以编译成tableswitch指令，代码如下：
int chooseNear(int i) {
switch (i) {
case 0: return 0;
case 1: return 1;
case 2: return 2;
default: return -1;
}
}
下面这个Java方法中的switch-case则需要编译成lookupswitch指令：
int chooseFar(int i) {
switch (i) {
case -100: return -1;
case 0: return 0;
case 100: return 1;
default: return -1;
}
}
③lookupswitch指令：
9、扩展指令
扩展指令共有6条。和jsr指令一样，我们不讨论jsr_w指令。multianewarray指令用于创建多维数组，在第8章讨论数组时实现该指令。本节实现剩下的4条指令。
①WIDE指令：
加载类指令、存储类指令、ret指令和iinc指令需要按索引访问局部变量表，索引以uint8的形式存在字节码中。对于大部分方法来说，局部变量表大小都不会超过256，所以用一字节来表示索引就够了。但是如果有方法的局部变量表超过这限制呢？Java虚拟机规范定义了wide 指令来扩展前述指令。
wide指令改变其他指令的行为，modifiedInstruction字段存放被改变的指令。wide指令需要自己解码出modifiedInstruction，fetchOperands（）方法的伪代码实现如下：
switch opcode {
case 0x15: ... // iload
case 0x16: ... // lload
case 0x17: ... // fload
case 0x18: ... // dload
case 0x19: ... // aload
case 0x36: ... // istore
case 0x37: ... // lstore
case 0x38: ... // fstore
case 0x39: ... // dstore
case 0x3a: ... // astore
case 0x84: ... // iinc
case 0xa9: // ret
throw new RuntimeException("Unsupported opcode: 0xa9!")
}
②IFNULL和IFNONNULL指令：
根据引用是否是null进行跳转，wideifnull和ifnonnull指令把栈顶的引用弹出。以ifnull指令为例，代码如下：
public class IFNULL extends InstructionBranch {
@Override
public void execute(Frame frame) {
Object ref = frame.operandStack().popRef();
if (null == ref) {
Instruction.branch(frame, this.offset);
}
}
}
③GOTO_W指令：
goto_w指令和goto指令的唯一区别就是索引从2字节变成了4字节。
public class GOTO_W implements Instruction {
private int offset;
@Override
public void fetchOperands(BytecodeReader reader) {
this.offset = reader.readInt();
}
@Override
public void execute(Frame frame) {
Instruction.branch(frame, this.offset);
}
}
四、解释器
指令集已经实现得差不多了，本节编写一个简单的解释器。这个解释器目前只能执行一个Java方法，但是在后面的章节中，会不断完善它，让它变得越来越强大。
我们创建一个Interpret类，在其中定义interpret（）函数，代码如下：
//interpret（）方法的参数是MemberInfo指针；
Interpret(MemberInfo m) {
CodeAttribute codeAttr = m.codeAttribute(); //调用MemberInfo结构体的CodeAttribute（）方法可以获取它的Code属性；
//获得执行方法所需的局部变量表和操作数栈空间，以及方法的字节码；
int maxLocals = codeAttr.maxLocals();
int maxStack = codeAttr.maxStack();
byte[] byteCode = codeAttr.data();
//先创建一个Thread实例，然后创建一个帧并把它推入Java虚拟机栈顶，最后执行方法loop（）；
Thread thread = new Thread();
Frame frame = thread.newFrame(maxLocals, maxStack);
thread.pushFrame(frame);
loop(thread, byteCode);
}
CodeAttribute（）方法是新增的，代码写在classfile.MemberInfo接口中，代码如下：
public CodeAttribute codeAttribute() {
for (AttributeInfo attrInfo : attributes) {
if (attrInfo instanceof CodeAttribute) return (CodeAttribute) attrInfo;
}
return null;
}
Thread类的NewFrame（）方法是新增加的，代码如下：
public Frame newFrame(int maxLocals, int maxStack) {
return new Frame(this, maxLocals, maxStack);
}
Frame类也有变化，增加了两个属性，这两个字段主要是为了实现跳转指令而添加的：
public class Frame {
//stack is implemented as linked list
Frame lower;
//局部变量表
private LocalVars localVars;
//操作数栈
private OperandStack operandStack;
private Thread thread;
private int nextPC;
这里我们回顾一下Instruction接口里的branch()方法：
static void branch(Frame frame, int offset) {
int pc = frame.thread().pc();
int nextPC = pc + offset;
frame.setNextPC(nextPC);
}
Frame类的Frame()方法也对应修改:
public Frame(Thread thread, int maxLocals, int maxStack) {
this.thread = thread;
this.localVars = new LocalVars(maxLocals);
this.operandStack = new OperandStack(maxStack);
}
再来看loop()方法：
private void loop(Thread thread, byte[] byteCode) {
Frame frame = thread.popFrame();
BytecodeReader reader = new BytecodeReader();
while (true) {
//循环
int pc = frame.nextPC();
thread.setPC(pc);
//decode
reader.reset(byteCode, pc);
byte opcode = reader.readByte();
Instruction inst = Factory.newInstruction(opcode);//newInstruction()方法在Factory类中；
if (null == inst) {
System.out.println("寄存器(指令)尚未实现 " + byteToHexString(new byte[]{opcode}));
break;
}
inst.fetchOperands(reader);
frame.setNextPC(reader.pc());
//打印出局部变量表和操作数栈的内容；
System.out.println("寄存器(指令)：" + byteToHexString(new byte[]{opcode}) + " -> " + inst.getClass().getSimpleName() + " => 局部变量表：" + JSON.toJSONString(frame.operandStack().getSlots()) + " 操作数栈：" + JSON.toJSONString(frame.operandStack().getSlots())); //exec
inst.execute(frame);
}
}
最后是我们的Factory类，它根据操作码创建具体的指令，是一大堆switch-case语句。代码过长，只贴一小段，具体的可以进我的源码去看：
public static Instruction newInstruction(byte opcode) {
switch (opcode) {
case 0x00:
return new NOP();
case 0x01:
return new ACONST_NULL();
case 0x02:
return new ICONST_M1();
case 0x03:
return new ICONST_0();
......
五、测试
我们用德国大数学家高斯的一个广为流传的小故事。有一天，数学老师布置了一道题：问1+2+3……这样从1一直加到100等于多少。小高斯很快就给出了答案。高斯不是从1一直加到100，而是用更聪明的办法计算的：1+100=101，2+99=101……1加到100有50组这样的数，所以50*101=5050。
我们将测试代码里的HelloWorld更改为：
public class HelloWorld {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println(sum);
}
}
main类中修改startJVM（）函数，改动如下：
private static void startJVM(Cmd cmd) {
Classpath classpath = new Classpath(cmd.jre, cmd.classpath);
System.out.printf("classpath:%s class:%s args:%s\n", classpath, cmd.getMainClass(), cmd.getAppArgs());
String className = cmd.getMainClass().replace(".", "/");
ClassFile classFile = loadClass(className, classpath);
MemberInfo mainMethod = getMainMethod(classFile);
if (null == mainMethod) {
System.out.println("Main method not found in class " + cmd.classpath);
return;
}
new Interpret(mainMethod);
}
startJVM（）首先调用loadClass（）方法读取并解析class文件，然后调用getMainMethod（）函数查找类的main（）方法，最后调用interpret（）函数解释执行main（）方法。loadClass（）函数的代码如下：
private static ClassFile loadClass(String className, Classpath cp) {
try {
byte[] classData = cp.readClass(className);
return new ClassFile(classData);
} catch (Exception e) {
System.out.println("Could not find or load main class " + className);
e.printStackTrace();
}
return null;
}
getMainMethod（）函数的代码如下：
//找到主函数入口；
private static MemberInfo getMainMethod(ClassFile cf) {
if (null == cf) return null;
MemberInfo[] methods = cf.methods();
for (MemberInfo m : methods) {
if ("main".equals(m.name()) && "([Ljava/lang/String;)V".equals(m.descriptor())) {
return m;
}
}
return null;
然后我们编译，将它通过 javac 命令编译成 class 文件，再把class文件放置到resources下。
启动参数也需要对应修改为，-Xjre “C:\Program Files\Java\jdk1.8.0_281\jre” “D:\JavaProject\Idea-project\ZYX-demo-jvm\ZYX-demo-jvm-05\src\main\resources\HelloWorld”。
输出结果如下，太长了贴一小段：
classpath:org.ZYX.demo.jvm.classpath.Classpath@7591083d class:D:\JavaProject\Idea-project\ZYX-demo-jvm\ZYX-demo-jvm-05\src\main\resources\HelloWorld args:null
寄存器(指令)：0x03 -> ICONST_0 => 局部变量表：[{"num":0},{"num":0}] 操作数栈：[{"num":0},{"num":0}]
寄存器(指令)：0x3c -> ISTORE_1 => 局部变量表：[{"num":0},{"num":0}] 操作数栈：[{"num":0},{"num":0}]
寄存器(指令)：0x04 -> ICONST_1 => 局部变量表：[{"num":0},{"num":0}] 操作数栈：[{"num":0},{"num":0}]
......
寄存器(指令)：0x84 -> IINC => 局部变量表：[{"num":5050},{"num":100}] 操作数栈：[{"num":5050},{"num":100}]
寄存器(指令)：0xa7 -> GOTO => 局部变量表：[{"num":5050},{"num":100}] 操作数栈：[{"num":5050},{"num":100}]
寄存器(指令)：0x1c -> ILOAD_2 => 局部变量表：[{"num":5050},{"num":100}] 操作数栈：[{"num":5050},{"num":100}]
寄存器(指令)：0x10 -> BIPUSH => 局部变量表：[{"num":101},{"num":100}] 操作数栈：[{"num":101},{"num":100}]
寄存器(指令)：0xa3 -> IF_ICMPGT => 局部变量表：[{"num":101},{"num":100}] 操作数栈：[{"num":101},{"num":100}]
寄存器(指令)尚未实现 0xb2
仔细观察局部变量表可以看到5050这个数字，这正是我们的计算结果！完工！