指令	含义
iconst_1	将int型1推送至栈顶
istore_1	将栈顶int型数值存入第二个本地变量
iconst_2	将int型2推送至栈顶
istore_2	将栈顶int型数值存入第三个本地变量
iload_1	将第二个int型本地变量推送至栈顶
iload_2	将第三个int型本地变量推送至栈顶
iadd	将栈顶两int型数值相加并将结果压入栈顶
istore_3	将栈顶int型数值存入第四个本地变量
getstatic	获取指定类的静态域, 并将其压入栈顶
iload_3	将第四个int型本地变量推送至栈顶
invokevirtual	调用实例方法
return	从当前方法返回void

运行过程分析实战

根据我们上面的分析，我们尝试手工模拟下指令对于运行区数据的影响。

从上面的分析中，每一个方法都会创建一个栈帧。在栈帧中，定义一个长度为4的数组来表示局部变量表，用一个长度为2的栈表示操作数栈。

下面尝试分析下方法的执行步骤：

iconst _1 将int型1推送至栈顶
istore_1 把栈顶的值赋给第二变量
iconst_2 同iconst_1
istore_2
iload_1
Iload_2
iadd 将栈顶两int型数值相加并将结果压入栈顶
istore_3 将栈顶int型数值存入第四个本地变量
getstatic 获取指定类的静态域, 并将其压入栈顶
Iload_3

invokevirtual 调用实例方法

代码实现

找到main方法

static Method getMainMethod(ClassParseInfo classParseInfo){
		Method[] methods = classParseInfo.methods;
		for (int i = 0; i < methods.length; i++) {
			int name_index = methods[i].getName_index();
			CONSTANT_Utf8_info utf8Constant = classParseInfo.constant_pool.getUtf8Constant(name_index);
			if(utf8Constant.getText().equalsIgnoreCase("main")){
				return methods[i];
			}
		}
		return null;
	}

创建Frame

Frame 是代表栈帧，在创建方法的时候都需要创建一个栈帧。在Frame中，使用List表示本地变量表，Stack代表操作数栈。


public class Frame {
	
	private List<Slot> localVars;
	private Stack<Slot> operateStack;
	private int maxLocalVars;
	private int maxStack;
	
	public Frame(int maxLocalVars, int maxStack) {
		this.maxLocalVars = maxLocalVars;
		this.maxStack = maxStack;
		localVars = new ArrayList<>(maxLocalVars);
		operateStack = new Stack<>();
	}
	
	public void setVars(int index,Slot slot) {
		this.localVars.add(slot);
	}
	public Slot getVar(int index) {
		return localVars.get(index - 1);
	}
	
	public void pushVar(Slot slot) {
		operateStack.push(slot);
	}
	
	public Slot pop() {
		if (this.operateStack.isEmpty())
			return null;
		return this.operateStack.pop();
	}
	
}

创建指令Instruction接口

在上面的分析过程中，每一个指令都会对Frame进行操作，我们定义一个接口Instruction.
```
public interface Instruction {
	void execute(Frame frame);
}
```
指令的实现

Const指令的实现：


public class IConst implements Instruction {
	private int value;
	
	public IConst(int value) {
		this.value = value;
	}
	
	@Override
	public void execute(Frame frame) {
		pushValue(frame,value);
	}
	
	public void pushValue(Frame frame, int value) {
		frame.pushVar(new Slot(value));
	}
	
}

ILoad的实现

public class Load implements Instruction {
    public Load(int index) {
    this.index = index;
}

private final int index;

@Override
public void execute(Frame frame) {
    Slot var = frame.getVar(index);
    frame.pushVar(var);
}

}

Store指令实现：


public class Store implements Instruction {
    final int index;
    
    public Store(int index) {
        this.index = index;
    }
    
    @Override
    public void execute(Frame frame) {
        setVar(frame,this.index);
    }
    
    public void setVar(Frame frame, int index) {
        Slot pop = frame.pop();
        frame.setVars(index, pop);
    }
}

GetStatic和InvokeVirtual的mock:

为了降低代码的复杂度，我们对GetStatic和InvokVirtual方法进行Mock。

在GetStatic是获得一个静态变量入栈。在当前的代码中，静态变量就是`System.out。在GetStatic实现的时候，我们直接采用System.out的静态变量入栈。

    public class GetStatic implements Instruction {
        @Override
        public void execute(Frame frame) {
            frame.pushVar(new Slot(System.out));
        }
    }

在InvokeVirtual的方法中，直接转换成对应的方法调用：


public class InvokeVirtual implements Instruction {
    //mock
    @Override
    public void execute(Frame frame) {
        Slot pop = frame.pop();
        Slot out = frame.pop();
        PrintStream sysOut = (PrintStream) out.getRef();
        sysOut.println(pop.getValue());
    }
}

InstructionFactory 工厂实现

public class InstructionFactory {
    public static Instruction getInstruction(Opcode opcode, Object... obj) {
        switch (opcode) {
            case iconst_1:
                return new IConst(1);
            case iconst_2:
                return new IConst(2);
            case iload_1:
                return new Load(1);
            case iload_2:
                return new Load(2);
            case iload_3:
                return new Load(3);
            case istore_1:
                return new Store(1);
            case istore_2:
                return new Store(2);
            case istore_3:
                return new Store(3);
            case iadd:
                return new Add();
            case _return:
                return new Return();
            case getstatic:
                return new GetStatic();
            case invokevirtual:
                return new InvokeVirtual();
            default: {
                System.out.println(opcode + "未实现");
                return null;
            }
        }
    }
}

主方法实现：

Code_attribute code = (Code_attribute) Arrays.stream(mainMethod.getAttributes()).filter(x -> x.tagName.equalsIgnoreCase("code")).findFirst().orElse(null);

Frame frame = new Frame(code.getMax_locals(), code.getMax_stack());
byte[] paraCodeArr = code.getParaCode();
for (Opcode op : code.getOpcodeArr()) {
  if (op == null)
    continue;
  byte[] bytes = new byte[0];
  if (op.operandCount > 0) {
    bytes = Arrays.copyOf(paraCodeArr, op.operandCount);
    paraCodeArr = Arrays.copyOfRange(paraCodeArr, op.operandCount - 1, paraCodeArr.length - 1);
  }
  Instruction instruction = InstructionFactory.getInstruction(op);
  instruction.execute(frame);
}

最终执行结果：3