當(dāng)前位置：首頁(yè) > 运维知识 > windows >内容正文

windows

Golang实现JAVA虚拟机-指令集和解释器

發(fā)布時(shí)間：2024/1/11 windows 52 coder

生活随笔收集整理的這篇文章主要介紹了 Golang实现JAVA虚拟机-指令集和解释器小編覺(jué)得挺不錯(cuò)的,現(xiàn)在分享給大家,幫大家做個(gè)參考.

原文鏈接：https://gaoyubo.cn/blogs/f57f32cf.html

前置

Golang實(shí)現(xiàn)JAVA虛擬機(jī)-解析class文件

Golang實(shí)現(xiàn)JAVA虛擬機(jī)-運(yùn)行時(shí)數(shù)據(jù)區(qū)

一、字節(jié)碼、class文件、指令集的關(guān)系

class文件（二進(jìn)制）和字節(jié)碼（十六進(jìn)制）的關(guān)系

class文件

經(jīng)過(guò)編譯器編譯后的文件（如javac），一個(gè)class文件代表一個(gè)類(lèi)或者接口；
是由字節(jié)碼組成的，主要存儲(chǔ)的是字節(jié)碼，字節(jié)碼是訪問(wèn)jvm的重要指令
文件本身是2進(jìn)制，對(duì)應(yīng)的是16進(jìn)制的數(shù)。

字節(jié)碼

包括操作碼（Opcode）和操作數(shù)：操作碼是一個(gè)字節(jié)
如果方法不是抽象的，也不是本地方法，方法的Java代碼就會(huì)被編譯器編譯成字節(jié)碼，存放在method_info結(jié)構(gòu)的Code屬性中

如圖：操作碼為B2，助記符為助記符是getstatic。它的操作數(shù)是0x0002，代表常量池里的第二個(gè)常量。

操作數(shù)棧和局部變量表只存放數(shù)據(jù)的值，并不記錄數(shù)據(jù)類(lèi)型。結(jié)果就是：指令必須知道自己在操作什么類(lèi)型的數(shù)據(jù)。

這一點(diǎn)也直接反映在了操作碼的助記符上。

例如，iadd指令：對(duì)int值進(jìn)行加法操作；
dstore指令：把操作數(shù)棧頂?shù)膁ouble值彈出，存儲(chǔ)到局部變量表中；
areturn：從方法中返回引用值。

助記符

如果某類(lèi)指令可以操作不同類(lèi)型的變量，則助記符的第一個(gè)字母表示變量類(lèi)型。助記符首字母和變量類(lèi)型的對(duì)應(yīng)關(guān)系如下：

指令分類(lèi)

Java虛擬機(jī)規(guī)范把已經(jīng)定義的205條指令按用途分成了11類(lèi)，分別是：

常量（constants）指令
加載（loads）指令
存儲(chǔ)（stores）指令
操作數(shù)棧（stack）指令
數(shù)學(xué)（math）指令
轉(zhuǎn)換（conversions）指令
比較（comparisons）指令
控制（control）指令
引用（references）指令
擴(kuò)展（extended）指令
保留（reserved）指令：
- 操作碼：202（0xCA），助記符：breakpoint，用于調(diào)試器的斷點(diǎn)調(diào)試
- 254（0xFE），助記符：impdep1
- 266（0xFF），助記符：impdep2
- 這三條指令不允許出現(xiàn)在class文件中

本章將要實(shí)現(xiàn)的指令涉及11類(lèi)中的9類(lèi)

二、JVM執(zhí)行引擎

執(zhí)行引擎是Java虛擬機(jī)四大組成部分中一個(gè)核心組成（另外三個(gè)分別是類(lèi)加載器子系統(tǒng)、運(yùn)行時(shí)數(shù)據(jù)區(qū)、垃圾回收器），

Java虛擬機(jī)的執(zhí)行引擎主要是用來(lái)執(zhí)行Java字節(jié)碼。

它有兩種主要執(zhí)行方式：通過(guò)字節(jié)碼解釋器執(zhí)行，通過(guò)即時(shí)編譯器執(zhí)行

解釋和編譯

在了解字節(jié)碼解釋器和即使編譯器之前，需要先了解解釋和編譯

解釋是將代碼逐行或逐條指令地轉(zhuǎn)換為機(jī)器代碼并立即執(zhí)行的方式，適合實(shí)現(xiàn)跨平臺(tái)性。
編譯是將整個(gè)程序或代碼塊翻譯成機(jī)器代碼的方式，生成的機(jī)器代碼可反復(fù)執(zhí)行，通常更快，但不具備跨平臺(tái)性。

字節(jié)碼解釋器

字節(jié)碼解釋器將逐條解釋執(zhí)行Java字節(jié)碼指令。這意味著它會(huì)逐個(gè)讀取字節(jié)碼文件中的指令，并根據(jù)每個(gè)指令執(zhí)行相應(yīng)的操作。雖然解釋執(zhí)行相對(duì)較慢。

逐行解釋和執(zhí)行代碼。它會(huì)逐行讀取源代碼或字節(jié)碼，將每一行翻譯成計(jì)算機(jī)指令，然后立即執(zhí)行該指令。

因此具有平臺(tái)無(wú)關(guān)性，因?yàn)樽止?jié)碼可以在不同的平臺(tái)上運(yùn)行。

即時(shí)編譯器（Just-In-Time Compiler，JIT）

即時(shí)編譯器將字節(jié)碼編譯成本地機(jī)器代碼，然后執(zhí)行本地代碼。

這種方式更快，因?yàn)樗苊饬俗止?jié)碼解釋的過(guò)程，但編譯需要一些時(shí)間。

即時(shí)編譯器通常會(huì)選擇性地編譯某些熱點(diǎn)代碼路徑，以提高性能。

解釋器規(guī)范

Java虛擬機(jī)規(guī)范的2.11節(jié)介紹了Java虛擬機(jī)解釋器的大致邏輯，如下所示：

do {
    atomically calculate pc and fetch opcode at pc;
    if (operands) fetch operands;
    execute the action for the opcode;
} while (there is more to do);

從當(dāng)前程序計(jì)數(shù)器（Program Counter，通常簡(jiǎn)稱(chēng)為 PC）中獲取當(dāng)前要執(zhí)行的字節(jié)碼指令的地址。
從該地址獲取字節(jié)碼指令的操作碼（opcode），并執(zhí)行該操作碼對(duì)應(yīng)的操作。
如果指令需要操作數(shù)（operands），則獲取操作數(shù)。
執(zhí)行指令對(duì)應(yīng)的操作。
更新 PC，以便繼續(xù)執(zhí)行下一條字節(jié)碼指令。
循環(huán)執(zhí)行上述步驟，直到?jīng)]有更多的指令需要執(zhí)行。

每次循環(huán)都包含三個(gè)部分：計(jì)算pc、指令解碼、指令執(zhí)行

可以把這個(gè)邏輯用Go語(yǔ)言寫(xiě)成一個(gè)for循環(huán)，里面是個(gè)大大的switch-case語(yǔ)句。但這樣的話，代碼的可讀性將非常差。

所以采用另外一種方式：把指令抽象成接口，解碼和執(zhí)行邏輯寫(xiě)在具體的指令實(shí)現(xiàn)中。

這樣編寫(xiě)出的解釋器就和Java虛擬機(jī)規(guī)范里的偽代碼一樣簡(jiǎn)單，偽代碼如下：

for {
    pc := calculatePC()
    opcode := bytecode[pc]
    inst := createInst(opcode)
    inst.fetchOperands(bytecode)
    inst.execute()
}

三、指令和指令解碼

本節(jié)先定義指令接口，然后定義一個(gè)結(jié)構(gòu)體用來(lái)輔助指令解碼

Instruction接口

為了便于管理，把每種指令的源文件都放在各自的包里，所有指令都共用的代碼則放在base包里。

因此instructions目錄下會(huì)有如下10個(gè)子目錄：

base目錄下創(chuàng)建instruction.go文件，在其中定義Instruction接口，代碼如下：

type Instruction interface {
    FetchOperands(reader *BytecodeReader)
    Execute(frame *rtda.Frame)
}

FetchOperands（）方法從字節(jié)碼中提取操作數(shù)，Execute（）方法執(zhí)行指令邏輯。

有很多指令的操作數(shù)都是類(lèi)似的。為了避免重復(fù)代碼，按照操作數(shù)類(lèi)型定義一些結(jié)構(gòu)體，并實(shí)現(xiàn)FetchOperands（）方法。

無(wú)操作數(shù)指令

在instruction.go文件中定義NoOperandsInstruction結(jié)構(gòu)體，代碼如下:

type NoOperandsInstruction struct {}

NoOperandsInstruction表示沒(méi)有操作數(shù)的指令，所以沒(méi)有定義任何字段。FetchOperands（）方法自然也是空空如也，什么也不用讀，代碼如下:

func (self *NoOperandsInstruction) FetchOperands(reader *BytecodeReader) {
	// nothing to do
}

跳轉(zhuǎn)指令

定義BranchInstruction結(jié)構(gòu)體，代碼如下：

type BranchInstruction struct {
    //偏移量
	Offset int
}

BranchInstruction表示跳轉(zhuǎn)指令，Offset字段存放跳轉(zhuǎn)偏移量。

FetchOperands（）方法從字節(jié)碼中讀取一個(gè)uint16整數(shù)，轉(zhuǎn)成int后賦給Offset字段。代碼如下：

func (self *BranchInstruction) FetchOperands(reader *BytecodeReader) {
	self.Offset = int(reader.ReadInt16())
}

存儲(chǔ)和加載指令

存儲(chǔ)和加載類(lèi)指令需要根據(jù)索引存取局部變量表，索引由單字節(jié)操作數(shù)給出。把這類(lèi)指令抽象成Index8Instruction結(jié)構(gòu)體，定義Index8Instruction結(jié)構(gòu)體，代碼如下:

type Index8Instruction struct {
    //索引
    Index uint
}

FetchOperands（）方法從字節(jié)碼中讀取一個(gè)int8整數(shù)，轉(zhuǎn)成uint后賦給Index字段。代碼如下：

func (self *Index8Instruction) FetchOperands(reader *BytecodeReader) {
	self.Index = uint(reader.ReadUint8())
}

訪問(wèn)常量池的指令

有一些指令需要訪問(wèn)運(yùn)行時(shí)常量池，常量池索引由兩字節(jié)操作數(shù)給出，用Index字段表示常量池索引。定義Index16Instruction結(jié)構(gòu)體，代碼如下：

type Index16Instruction struct {
	Index uint
}

FetchOperands（）方法從字節(jié)碼中讀取一個(gè) uint16整數(shù)，轉(zhuǎn)成uint后賦給Index字段。代碼如下

func (self *Index16Instruction) FetchOperands(reader *BytecodeReader) {
    self.Index = uint(reader.ReadUint16())
}

指令接口和“抽象”指令定義好了，下面來(lái)看BytecodeReader結(jié)構(gòu)體

BytecodeReader結(jié)構(gòu)體

base目錄下創(chuàng)建bytecode_reader.go文件，在其中定義BytecodeReader結(jié)構(gòu)體

type BytecodeReader struct {
    code []byte // bytecodes
    pc   int
}

code字段存放字節(jié)碼，pc字段記錄讀取到了哪個(gè)字節(jié)。

為了避免每次解碼指令都新創(chuàng)建一個(gè)BytecodeReader實(shí)例，給它定義一個(gè) Reset（）方法，代碼如下:

func (self *BytecodeReader) Reset(code []byte, pc int) {
    self.code = code
    self.pc = pc
}

面實(shí)現(xiàn)一系列的Read（）方法。首先是最簡(jiǎn)單的ReadUint8（）方法，代碼如下：

func (self *BytecodeReader) ReadUint8() uint8 {
    i := self.code[self.pc]
    self.pc++
    return i
}

從 self.code 字節(jié)切片中的 self.pc 位置讀取一個(gè)字節(jié)（8 位）的整數(shù)值。
然后將 self.pc 的值增加1，以便下次讀取下一個(gè)字節(jié)。
最后，返回讀取的字節(jié)作為無(wú)符號(hào) 8 位整數(shù)

ReadInt8（）方法調(diào)用ReadUint8（），然后把讀取到的值轉(zhuǎn)成int8 返回，代碼如下：

func (self *BytecodeReader) ReadInt8() int8 {
	return int8(self.ReadUint8())
}

ReadUint16（）連續(xù)讀取兩字節(jié)

func (self *BytecodeReader) ReadUint16() uint16 {
    byte1 := uint16(self.ReadUint8())
    byte2 := uint16(self.ReadUint8())
    return (byte1 << 8) | byte2
}

ReadInt16（）方法調(diào)用ReadUint16（），然后把讀取到的值轉(zhuǎn)成 int16返回，代碼如下：

func (self *BytecodeReader) ReadInt16() int16 {
	return int16(self.ReadUint16())
}

ReadInt32（）方法連續(xù)讀取4字節(jié)，代碼如下：

func (self *BytecodeReader) ReadInt32() int32 {
    byte1 := int32(self.ReadUint8())
    byte2 := int32(self.ReadUint8())
    byte3 := int32(self.ReadUint8())
    byte4 := int32(self.ReadUint8())
    return (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4
}

在接下來(lái)的小節(jié)中，將按照分類(lèi)依次實(shí)現(xiàn)約150條指令，占整個(gè)指令集的3/4

四、常量指令

常量指令把常量推入操作數(shù)棧頂。

常量可以來(lái)自三個(gè)地方：隱含在操作碼里、操作數(shù)和運(yùn)行時(shí)常量池。

常量指令共有21條，本節(jié)實(shí)現(xiàn)其中的18條。另外3條是ldc系列指令，用于從運(yùn)行時(shí)常量池中加載常量，將在后續(xù)實(shí)現(xiàn)。

nop指令

nop指令是最簡(jiǎn)單的一條指令，因?yàn)樗裁匆膊蛔觥?br> 在\instructions\constants目錄下創(chuàng)建nop.go文件，在其中實(shí)現(xiàn)nop指令，代碼如下：

type NOP struct{ base.NoOperandsInstruction }

func (self *NOP) Execute(frame *rtda.Frame) {
// 什么也不用做
}

const系列指令

這一系列指令把隱含在操作碼中的常量值推入操作數(shù)棧頂。

constants目錄下創(chuàng)建const.go文件，在其中定義15條指令，代碼如下

type ACONST_NULL struct{ base.NoOperandsInstruction }
type DCONST_0 struct{ base.NoOperandsInstruction }
type DCONST_1 struct{ base.NoOperandsInstruction }
type FCONST_0 struct{ base.NoOperandsInstruction }
type FCONST_1 struct{ base.NoOperandsInstruction }
type FCONST_2 struct{ base.NoOperandsInstruction }
type ICONST_M1 struct{ base.NoOperandsInstruction }
type ICONST_0 struct{ base.NoOperandsInstruction }
type ICONST_1 struct{ base.NoOperandsInstruction }
type ICONST_2 struct{ base.NoOperandsInstruction }
type ICONST_3 struct{ base.NoOperandsInstruction }
type ICONST_4 struct{ base.NoOperandsInstruction }
type ICONST_5 struct{ base.NoOperandsInstruction }
type LCONST_0 struct{ base.NoOperandsInstruction }
type LCONST_1 struct{ base.NoOperandsInstruction }

以3條指令為例進(jìn)行說(shuō)明。aconst_null指令把null引用推入操作數(shù)棧頂，代碼如下

func (self *ACONST_NULL) Execute(frame *rtda.Frame) {
	frame.OperandStack().PushRef(nil)
}

dconst_0指令把double型0推入操作數(shù)棧頂，代碼如下

func (self *DCONST_0) Execute(frame *rtda.Frame) {
	frame.OperandStack().PushDouble(0.0)
}

iconst_m1指令把int型-1推入操作數(shù)棧頂，代碼如下：

func (self *ICONST_M1) Execute(frame *rtda.Frame) {
	frame.OperandStack().PushInt(-1)
}

bipush和sipush指令

bipush指令從操作數(shù)中獲取一個(gè)byte型整數(shù)，擴(kuò)展成int型，然后推入棧頂。
sipush指令從操作數(shù)中獲取一個(gè)short型整數(shù)，擴(kuò)展成int型，然后推入棧頂。

constants目錄下創(chuàng)建 ipush.go文件，在其中定義bipush和sipush指令，代碼如下：

type BIPUSH struct { val int8 } // Push byte
type SIPUSH struct { val int16 } // Push short

BIPUSH結(jié)構(gòu)體實(shí)現(xiàn)方法如下：

type BIPUSH struct {
    val int8
}

func (self *BIPUSH) FetchOperands(reader *base.BytecodeReader) {
    self.val = reader.ReadInt8()
}
func (self *BIPUSH) Execute(frame *rtda.Frame) {
    i := int32(self.val)
    frame.OperandStack().PushInt(i)
}

五、加載指令

加載指令用于從局部變量表獲取變量，并將其推入操作數(shù)棧頂。總共有 33 條加載指令，它們按照所操作的變量類(lèi)型可以分為 6 類(lèi)：

aload 系列指令：用于操作引用類(lèi)型變量。

dload 系列指令：用于操作 double 類(lèi)型變量。

fload 系列指令：用于操作 float 變量。

iload 系列指令：用于操作 int 變量。

lload 系列指令：用于操作 long 變量。

xaload 指令：用于操作數(shù)組。

本節(jié)將實(shí)現(xiàn)其中的 25 條加載指令。數(shù)組和xaload系列指令先不實(shí)現(xiàn)。

loads目錄下創(chuàng)建iload.go文件，在其中定義5 條指令，代碼如下：完整代碼移步：jvmgo

// 從局部變量表加載int類(lèi)型
type ILOAD struct{ base.Index8Instruction }
type ILOAD_0 struct{ base.NoOperandsInstruction }
type ILOAD_1 struct{ base.NoOperandsInstruction }
type ILOAD_2 struct{ base.NoOperandsInstruction }
type ILOAD_3 struct{ base.NoOperandsInstruction }

為了避免重復(fù)代碼，定義一個(gè)函數(shù)供iload系列指令使用，代碼如下：

func _iload(frame *rtda.Frame, index uint) {
    val := frame.LocalVars().GetInt(index)
    frame.OperandStack().PushInt(val)
}

iload指令的索引來(lái)自操作數(shù)，其Execute（）方法如下：

func (self *ILOAD) Execute(frame *rtda.Frame) {
	_iload(frame, uint(self.Index))
}

其余4條指令的索引隱含在操作碼中，以iload_1為例，其 Execute（）方法如下：

func (self *ILOAD_1) Execute(frame *rtda.Frame) {
	_iload(frame, 1)
}

六、存儲(chǔ)指令

和加載指令剛好相反，存儲(chǔ)指令把變量從操作數(shù)棧頂彈出，然后存入局部變量表。

和加載指令一樣，存儲(chǔ)指令也可以分為6類(lèi)。以 lstore系列指令為例進(jìn)行介紹。完整代碼移步：jvmgo

instructions\stores目錄下創(chuàng)建 lstore.go文件，在其中定義5條指令，代碼如下:

type LSTORE struct{ base.Index8Instruction }
type LSTORE_0 struct{ base.NoOperandsInstruction }
type LSTORE_1 struct{ base.NoOperandsInstruction }
type LSTORE_2 struct{ base.NoOperandsInstruction }
type LSTORE_3 struct{ base.NoOperandsInstruction }

同樣定義一個(gè)函數(shù)供5條指令使用，代碼如下：

func _lstore(frame *rtda.Frame, index uint) {
    val := frame.OperandStack().PopLong()
    frame.LocalVars().SetLong(index, val)
}

lstore指令的索引來(lái)自操作數(shù)，其Execute（）方法如下：

func (self *LSTORE) Execute(frame *rtda.Frame) {
	_lstore(frame, uint(self.Index))
}

其余4條指令的索引隱含在操作碼中，以lstore_2為例，其 Execute（）方法如下

func (self *LSTORE_2) Execute(frame *rtda.Frame) {
	_lstore(frame, 2)
}

七、棧指令

棧指令直接對(duì)操作數(shù)棧進(jìn)行操作，共9條：

pop和pop2指令將棧頂變量彈出

dup系列指令復(fù)制棧頂變量

swap指令交換棧頂?shù)膬蓚€(gè)變量

和其他類(lèi)型的指令不同，棧指令并不關(guān)心變量類(lèi)型。為了實(shí)現(xiàn)棧指令，需要給OperandStack結(jié)構(gòu)體添加兩個(gè)方法。操作數(shù)棧實(shí)現(xiàn)
rtda\operand_stack.go文件中，在其中定義PushSlot（）和PopSlot（） 方法，代碼如下：

func (self *OperandStack) PushSlot(slot Slot) {
    self.slots[self.size] = slot
    self.size++
}
func (self *OperandStack) PopSlot() Slot {
    self.size--
    return self.slots[self.size]
}

pop和pop2指令

stack目錄下創(chuàng)建pop.go文件，在其中定義 pop和pop2指令，代碼如下:

type POP struct{ base.NoOperandsInstruction }
type POP2 struct{ base.NoOperandsInstruction }

pop指令把棧頂變量彈出，代碼如下：

func (self *POP) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    stack.PopSlot()
}

pop指令只能用于彈出int、float等占用一個(gè)操作數(shù)棧位置的變量。

double和long變量在操作數(shù)棧中占據(jù)兩個(gè)位置，需要使用pop2指令彈出，代碼如下：

func (self *POP2) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    stack.PopSlot()
    stack.PopSlot()
}

dup指令

創(chuàng)建dup.go文件，在其中定義6 條指令，代碼如下：完整代碼移步：jvmgo

type DUP struct{ base.NoOperandsInstruction }
type DUP_X1 struct{ base.NoOperandsInstruction }
type DUP_X2 struct{ base.NoOperandsInstruction }
type DUP2 struct{ base.NoOperandsInstruction }
type DUP2_X1 struct{ base.NoOperandsInstruction }
type DUP2_X2 struct{ base.NoOperandsInstruction }

dup指令復(fù)制棧頂?shù)膯蝹€(gè)變量，代碼如下：

func (self *DUP) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    slot := stack.PopSlot()
    stack.PushSlot(slot)
    stack.PushSlot(slot)
}

DUP_X1 ：復(fù)制棧頂操作數(shù)一份放在第二個(gè)操作數(shù)的下方。Execute代碼如下：

/*
bottom -> top
[...][c][b][a]
          __/
         |
         V
[...][c][a][b][a]
*/
func (self *DUP_X1) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    slot1 := stack.PopSlot()
    slot2 := stack.PopSlot()
    stack.PushSlot(slot1)
    stack.PushSlot(slot2)
    stack.PushSlot(slot1)
}

DUP_X2 ：復(fù)制棧頂操作數(shù)棧的一個(gè)或兩個(gè)值，并將它們插入到操作數(shù)棧中的第三個(gè)值的下面。

/*
bottom -> top
[...][c][b][a]
       _____/
      |
      V
[...][a][c][b][a]
*/
func (self *DUP_X2) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    slot1 := stack.PopSlot()
    slot2 := stack.PopSlot()
    slot3 := stack.PopSlot()
    stack.PushSlot(slot1)
    stack.PushSlot(slot3)
    stack.PushSlot(slot2)
    stack.PushSlot(slot1)
}

swap指令

swap指令作用是交換棧頂?shù)膬蓚€(gè)操作數(shù)

下創(chuàng)建swap.go文件，在其中定義swap指令，代碼如下:

type SWAP struct{ base.NoOperandsInstruction }

Execute（）方法如下

func (self *SWAP) Execute(frame *rtda.Frame) {
stack := frame.OperandStack()
slot1 := stack.PopSlot()
slot2 := stack.PopSlot()
stack.PushSlot(slot1)
stack.PushSlot(slot2)
}

八、數(shù)學(xué)指令

數(shù)學(xué)指令大致對(duì)應(yīng)Java語(yǔ)言中的加、減、乘、除等數(shù)學(xué)運(yùn)算符。

數(shù)學(xué)指令包括算術(shù)指令、位移指令和布爾運(yùn)算指令等，共37條，將全部在本節(jié)實(shí)現(xiàn)。

算術(shù)指令

算術(shù)指令又可以進(jìn)一步分為:

加法（add）指令
減法（sub）指令
乘法（mul）指令
除法（div）指令
求余（rem）指令
取反（neg）指令

加、減、乘、除和取反指令都比較簡(jiǎn)單，本節(jié)以復(fù)雜的求余指令介紹。

math目錄下創(chuàng)建rem.go文件，在其中定義4條求余指令，代碼如下:

type DREM struct{ base.NoOperandsInstruction }
type FREM struct{ base.NoOperandsInstruction }
type IREM struct{ base.NoOperandsInstruction }
type LREM struct{ base.NoOperandsInstruction }

DREM 結(jié)構(gòu)體：表示對(duì)雙精度浮點(diǎn)數(shù) (double) 執(zhí)行取余操作。
FREM 結(jié)構(gòu)體：表示對(duì)單精度浮點(diǎn)數(shù) (float) 執(zhí)行取余操作
IREM 結(jié)構(gòu)體：表示對(duì)整數(shù) (int) 執(zhí)行取余操作。
LREM 結(jié)構(gòu)體：表示對(duì)長(zhǎng)整數(shù) (long) 執(zhí)行取余操作。

irem和lrem代碼差不多，以irem為例，其Execute（）方法如下：

func (self *IREM) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    v2 := stack.PopInt()
    v1 := stack.PopInt()
    if v2 == 0 {
    	panic("java.lang.ArithmeticException: / by zero")
    }
    result := v1 % v2
    stack.PushInt(result)
}

先從操作數(shù)棧中彈出兩個(gè)int變量，求余，然后把結(jié)果推入操作數(shù)棧。

注意！對(duì)int或long變量做除法和求余運(yùn)算時(shí)，是有可能拋出ArithmeticException異常的。

frem和drem指令差不多，以 drem為例，其Execute（）方法如下：

func (self *DREM) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    v2 := stack.PopDouble()
    v1 := stack.PopDouble()
    result := math.Mod(v1, v2)
    stack.PushDouble(result)
}

Go語(yǔ)言沒(méi)有給浮點(diǎn)數(shù)類(lèi)型定義求余操作符，所以需要使用 math包的Mod（）函數(shù)。

浮點(diǎn)數(shù)類(lèi)型因?yàn)橛蠭nfinity（無(wú)窮大）值，所以即使是除零，也不會(huì)導(dǎo)致ArithmeticException異常拋出

位移指令

分為左移和右移

左移
右移
- 算術(shù)右移（有符號(hào)右移）
- 邏輯右移（無(wú)符號(hào)右移）兩種。

算術(shù)右移和邏輯位移的區(qū)別僅在于符號(hào)位的擴(kuò)展，如下面的Java代碼所示。

int x = -1;
println(Integer.toBinaryString(x)); // 11111111111111111111111111111111
println(Integer.toBinaryString(x >> 8)); // 11111111111111111111111111111111
println(Integer.toBinaryString(x >>> 8)); // 00000000111111111111111111111111

math目錄下創(chuàng)建sh.go文件，在其中定義6條位移指令，代碼如下

type ISHL struct{ base.NoOperandsInstruction } // int左位移
type ISHR struct{ base.NoOperandsInstruction } // int算術(shù)右位移
type IUSHR struct{ base.NoOperandsInstruction } // int邏輯右位移(無(wú)符號(hào)右移位)
type LSHL struct{ base.NoOperandsInstruction } // long左位移
type LSHR struct{ base.NoOperandsInstruction } // long算術(shù)右位移
type LUSHR struct{ base.NoOperandsInstruction } // long邏輯右移位（無(wú)符號(hào)右移位）

左移

左移指令比較簡(jiǎn)單，以ishl指令為例，其Execute（）方法如下：

func (self *ISHL) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    v2 := stack.PopInt()
    v1 := stack.PopInt()
    s := uint32(v2) & 0x1f
    result := v1 << s
    stack.PushInt(result)
}

先從操作數(shù)棧中彈出兩個(gè)int變量v2和v1。v1是要進(jìn)行位移操作的變量，v2指出要移位多少比特。位移之后，把結(jié)果推入操作數(shù)棧。

s := uint32(v2) & 0x1f：這行代碼將被左移的位數(shù) v2 強(qiáng)制轉(zhuǎn)換為 uint32 類(lèi)型，然后執(zhí)行按位與操作（&）與常數(shù) 0x1f。
這是為了確保左移的位數(shù)在范圍 0 到 31 內(nèi)，因?yàn)樵?Java 中，左移操作最多只能左移 31 位，超出這個(gè)范圍的位數(shù)將被忽略。

這里注意兩點(diǎn)：

int變量只有32位，所以只取v2的前5個(gè)比特就足夠表示位移位數(shù)了

Go語(yǔ)言位移操作符右側(cè)必須是無(wú)符號(hào) 整數(shù)，所以需要對(duì)v2進(jìn)行類(lèi)型轉(zhuǎn)換

右移

算數(shù)右移

算術(shù)右移指令需要擴(kuò)展符號(hào)位，代碼和左移指令基本上差不多。以lshr指令為例，其Execute（）方法如下：

func (self *LSHR) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    v2 := stack.PopInt()
    //long變量有64位，所以取v2的前6個(gè)比特。
    v1 := stack.PopLong()
    s := uint32(v2) & 0x3f
    result := v1 >> s
    stack.PushLong(result)
}

s := uint32(v2) & 0x1f：

提取 v2 變量的最低的 6 位，將其他位設(shè)置為 0，并將結(jié)果存儲(chǔ)在 s 變量中。這是為了限制右移的位數(shù)在 0 到 63 之間，因?yàn)樵?Java 中，long類(lèi)型右移操作最多只能右移 63 位

邏輯右移

無(wú)符號(hào)右移位，以iushr為例，在移位前，先將v2轉(zhuǎn)化為正數(shù)，再進(jìn)行移位，最后轉(zhuǎn)化為int32類(lèi)型，如下代碼所示：

func (self *IUSHR) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    v2 := stack.PopInt()
    v1 := stack.PopInt()
    s := uint32(v2) & 0x1f
    result := int32(uint32(v1) >> s)
    stack.PushInt(result)
}

布爾運(yùn)算指令

布爾運(yùn)算指令只能操作int和long變量，分為：

按位與（and）
按位或（or）
按位異或（xor）

math目錄下創(chuàng)建and.go文件，在其中定義iand和 land指令，代碼如下：

type IAND struct{ base.NoOperandsInstruction }
type LAND struct{ base.NoOperandsInstruction }

以iand指令為例，其Execute（）方法如下：

func (self *IAND) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    v2 := stack.PopInt()
    v1 := stack.PopInt()
    result := v1 & v2
    stack.PushInt(result)
}

iinc指令

iinc指令給局部變量表中的int變量增加常量值，局部變量表索引和常量值都由指令的操作數(shù)提供。

math目錄下創(chuàng)建iinc.go文件，在其中定義iinc指令，代碼如下：

type IINC struct {
    //索引
	Index uint
    //常量值
	Const int32
}

index：一個(gè)字節(jié)，表示局部變量表中要增加值的變量的索引。這個(gè)索引指定了要修改的局部變量。

const：一個(gè)有符號(hào)字節(jié)，表示要增加的常數(shù)值。這個(gè)常數(shù)值將與局部變量的當(dāng)前值相加，并將結(jié)果存儲(chǔ)回同一個(gè)局部變量。

FetchOperands（）函數(shù)從字節(jié)碼里讀取操作數(shù)，代碼如下：

func (self *IINC) FetchOperands(reader *base.BytecodeReader) {
    self.Index = uint(reader.ReadUint8())
    self.Const = int32(reader.ReadInt8())
}

Execute（）方法從局部變量表中讀取變量，給它加上常量值，再把結(jié)果寫(xiě)回局部變量表，代碼如下

func (self *IINC) Execute(frame *rtda.Frame) {
    localVars := frame.LocalVars()
    val := localVars.GetInt(self.Index)
    val += self.Const
    localVars.SetInt(self.Index, val)
}

九、類(lèi)型轉(zhuǎn)換指令

類(lèi)型轉(zhuǎn)換指令大致對(duì)應(yīng)Java語(yǔ)言中的基本類(lèi)型強(qiáng)制轉(zhuǎn)換操作。類(lèi)型轉(zhuǎn)換指令有共15條，將全部在本節(jié)實(shí)現(xiàn)。

引用類(lèi)型轉(zhuǎn)換對(duì)應(yīng)的是checkcast指令，將在后續(xù)完成。

類(lèi)型轉(zhuǎn)換指令根據(jù)被轉(zhuǎn)換變量的類(lèi)型分為四種系列：

i2x 系列指令：這些指令將整數(shù)（int）變量強(qiáng)制轉(zhuǎn)換為其他類(lèi)型。

l2x 系列指令：這些指令將長(zhǎng)整數(shù)（long）變量強(qiáng)制轉(zhuǎn)換為其他類(lèi)型。

f2x 系列指令：這些指令將浮點(diǎn)數(shù)（float）變量強(qiáng)制轉(zhuǎn)換為其他類(lèi)型。

d2x 系列指令：這些指令將雙精度浮點(diǎn)數(shù)（double）變量強(qiáng)制轉(zhuǎn)換為其他類(lèi)型。

這些類(lèi)型轉(zhuǎn)換指令允許將不同類(lèi)型的數(shù)據(jù)進(jìn)行強(qiáng)制類(lèi)型轉(zhuǎn)換，以滿足特定的計(jì)算或操作需求。

以d2x系列指令為例進(jìn)行討論。

conversions目錄下創(chuàng)建d2x.go文件，在其中定義d2f、d2i和d2l指令，代碼如下

type D2F struct{ base.NoOperandsInstruction }
type D2I struct{ base.NoOperandsInstruction }
type D2L struct{ base.NoOperandsInstruction }

以d2i指令為例，它的Execute（）方法如下：

func (self *D2I) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    d := stack.PopDouble()
    i := int32(d)
    stack.PushInt(i)
}

因?yàn)镚o語(yǔ)言可以很方便地轉(zhuǎn)換各種基本類(lèi)型的變量，所以類(lèi)型轉(zhuǎn)換指令實(shí)現(xiàn)起來(lái)還是比較容易的。

十、比較指令

比較指令可以分為兩類(lèi)：

將比較結(jié)果推入操作數(shù)棧頂
根據(jù)比較結(jié)果跳轉(zhuǎn)

比較指令是編譯器實(shí)現(xiàn)if-else、for、while等語(yǔ)句的基石，共有19條

lcmp指令

lcmp指令用于比較long變量。

comparisons目錄下創(chuàng)建lcmp.go文件，在其中定義lcmp指令，代碼如下：

type LCMP struct{ base.NoOperandsInstruction }

Execute（）方法把棧頂?shù)膬蓚€(gè)long變量彈出，進(jìn)行比較，然后把比較結(jié)果（int型0、1或-1）推入棧頂，代碼如下：

func (self *LCMP) Execute(frame *rtda.Frame) {
	stack := frame.OperandStack()
	v2 := stack.PopLong()
	v1 := stack.PopLong()
	if v1 > v2 {
		stack.PushInt(1)
	} else if v1 == v2 {
		stack.PushInt(0)
	} else {
		stack.PushInt(-1)
	}
}

fcmp和dcmp指令

fcmpg和fcmpl指令用于比較float變量，它們的區(qū)別是對(duì)于非數(shù)字參與，fcmpg會(huì)默認(rèn)為其大于任何非NaN值，fcmpl則相反。

comparisons目錄下創(chuàng)建fcmp.go文件，在其中定義 fcmpg和fcmpl指令，代碼如下：

type FCMPG struct{ base.NoOperandsInstruction }
type FCMPL struct{ base.NoOperandsInstruction }

由于浮點(diǎn)數(shù)計(jì)算有可能產(chǎn)生NaN（Not a Number）值，所以比較兩個(gè)浮點(diǎn)數(shù)時(shí)，除了大于、等于、小于之外，
還有第4種結(jié)果：無(wú)法比較。

編寫(xiě)一個(gè)函數(shù)來(lái)統(tǒng)一比較float變量,如下：

func _fcmp(frame *rtda.Frame, gFlag bool) {
	stack := frame.OperandStack()
	v2 := stack.PopFloat()
	v1 := stack.PopFloat()
	if v1 > v2 {
		stack.PushInt(1)
	} else if v1 == v2 {
		stack.PushInt(0)
	} else if v1 < v2 {
		stack.PushInt(-1)
	} else if gFlag {
		stack.PushInt(1)
	} else {
		stack.PushInt(-1)
	}
}

Java虛擬機(jī)規(guī)范：浮點(diǎn)數(shù)比較指令 fcmpl 和 fcmpg 的規(guī)范要求首先彈出 v2，然后是 v1，以便進(jìn)行浮點(diǎn)數(shù)比較。

Execute()如下：

func (self *FCMPG) Execute(frame *rtda.Frame) {
    _fcmp(frame, true)
}
func (self *FCMPL) Execute(frame *rtda.Frame) {
    _fcmp(frame, false)
}

if<cond>指令

if<cond> 指令是 Java 字節(jié)碼中的條件分支指令，它根據(jù)條件 <cond> 來(lái)執(zhí)行不同的分支。
條件 <cond> 可以是各種比較操作，比如等于、不等于、大于、小于等等。

常見(jiàn)的 if<cond> 指令包括：

ifeq: 如果棧頂?shù)闹档扔?，則跳轉(zhuǎn)。

ifne: 如果棧頂?shù)闹挡坏扔?，則跳轉(zhuǎn)。

iflt: 如果棧頂?shù)闹敌∮?，則跳轉(zhuǎn)。

ifge: 如果棧頂?shù)闹荡笥诨虻扔?，則跳轉(zhuǎn)。

ifgt: 如果棧頂?shù)闹荡笥?，則跳轉(zhuǎn)。

ifle: 如果棧頂?shù)闹敌∮诨虻扔?，則跳轉(zhuǎn)。

創(chuàng)建ifcond.go文件，在其中定義6條if指令，代碼如下：

type IFEQ struct{ base.BranchInstruction }
type IFNE struct{ base.BranchInstruction }
type IFLT struct{ base.BranchInstruction }
type IFLE struct{ base.BranchInstruction }
type IFGT struct{ base.BranchInstruction }
type IFGE struct{ base.BranchInstruction }

以ifeq指令為例，其Execute（）方法如下：

func (self *IFEQ) Execute(frame *rtda.Frame) {
    val := frame.OperandStack().PopInt()
    if val == 0 {
    	base.Branch(frame, self.Offset)
	}
}

真正的跳轉(zhuǎn)邏輯在Branch（）函數(shù)中。因?yàn)檫@個(gè)函數(shù)在很多指令中都會(huì)用到，所以定義在base\branch_logic.go 文件中，代碼如下：

func Branch(frame *rtda.Frame, offset int) {
	pc := frame.Thread().PC()
	nextPC := pc + offset
	frame.SetNextPC(nextPC)
}

if_icmp<cond>指令

if_icmp<cond> 指令是 Java 字節(jié)碼中的一類(lèi)條件分支指令，它用于對(duì)比兩個(gè)整數(shù)值，根據(jù)比較的結(jié)果來(lái)執(zhí)行條件分支。這些指令的操作數(shù)棧上通常有兩個(gè)整數(shù)值，它們分別用于比較。

這類(lèi)指令包括：

if_icmpeq: 如果兩個(gè)整數(shù)相等，則跳轉(zhuǎn)。

if_icmpne: 如果兩個(gè)整數(shù)不相等，則跳轉(zhuǎn)。

if_icmplt: 如果第一個(gè)整數(shù)小于第二個(gè)整數(shù)，則跳轉(zhuǎn)。

if_icmpge: 如果第一個(gè)整數(shù)大于等于第二個(gè)整數(shù)，則跳轉(zhuǎn)。

if_icmpgt: 如果第一個(gè)整數(shù)大于第二個(gè)整數(shù)，則跳轉(zhuǎn)。

if_icmple: 如果第一個(gè)整數(shù)小于等于第二個(gè)整數(shù)，則跳轉(zhuǎn)。

創(chuàng)建if_icmp.go文件，在其中定義6條if_icmp指令，代碼如下：

type IF_ICMPEQ struct{ base.BranchInstruction }
type IF_ICMPNE struct{ base.BranchInstruction }
type IF_ICMPLT struct{ base.BranchInstruction }
type IF_ICMPLE struct{ base.BranchInstruction }
type IF_ICMPGT struct{ base.BranchInstruction }
type IF_ICMPGE struct{ base.BranchInstruction }

以if_icmpne指令為例，其Execute（）方法如下：

func (self *IF_ICMPNE) Execute(frame *rtda.Frame) {
    if val1, val2 := _icmpPop(frame); val1 != val2 {
       base.Branch(frame, self.Offset)
    }
}
func _icmpPop(frame *rtda.Frame) (val1, val2 int32) {
	stack := frame.OperandStack()
	val2 = stack.PopInt()
	val1 = stack.PopInt()
	return
}

if_acmp<cond>指令

if_acmp<cond> 指令是 Java 字節(jié)碼中的一類(lèi)條件分支指令，用于比較兩個(gè)引用類(lèi)型的對(duì)象引用，根據(jù)比較的結(jié)果來(lái)執(zhí)行條件分支。這些指令的操作數(shù)棧上通常有兩個(gè)對(duì)象引用，它們分別用于比較。

這類(lèi)指令包括：

if_acmpeq: 如果兩個(gè)引用相等，則跳轉(zhuǎn)。

if_acmpne: 如果兩個(gè)引用不相等，則跳轉(zhuǎn)。

創(chuàng)建if_acmp.go文件，在其中定義兩條if_acmp指令，代碼如下：

type IF_ACMPEQ struct{ base.BranchInstruction }
type IF_ACMPNE struct{ base.BranchInstruction }

以if_acmpeq指令為例，其Execute（）方法如下：

func (self *IF_ACMPEQ) Execute(frame *rtda.Frame) {
    stack := frame.OperandStack()
    ref2 := stack.PopRef()
    ref1 := stack.PopRef()
    if ref1 == ref2 {
    	base.Branch(frame, self.Offset)
    }
}

十一、控制指令

控制指令共有 11 條。
在 Java 6 之前，~~jsr 和 ret 指令用于實(shí)現(xiàn) finally 子句~~。從 Java 6 開(kāi)始，Oracle 的 Java 編譯器不再使用這兩條指令。
return 系列指令有 6 條，用于從方法調(diào)用中返回，將在后續(xù)實(shí)現(xiàn)。
本節(jié)將實(shí)現(xiàn)剩下的 3 條指令：goto、tableswitch 和 lookupswitch。

這些指令用于控制程序執(zhí)行流，包括條件分支和無(wú)條件跳轉(zhuǎn)等操作。其中，goto 用于無(wú)條件跳轉(zhuǎn)到指定的目標(biāo)位置，而 tableswitch 和 lookupswitch 用于根據(jù)條件跳轉(zhuǎn)到不同的目標(biāo)位置。

control目錄下創(chuàng)建goto.go文件，在其中定義 goto指令，代碼如下：

總結(jié)

以上是生活随笔為你收集整理的Golang实现JAVA虚拟机-指令集和解释器的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。

上一篇：一文了解Vprix容器流媒体平台和传统云
下一篇： Prometheus 监控告警系统搭建（