四、运行时数据区

 一、运行时数据区

https://blog.csdn.net/u011464536/article/details/78235438

 

二、实现

在jvmgo文件夹下面创建rtda文件夹，并在里面创建object.go文件

package rtda

type Object struct {
    // todo
}

 

1、线程

创建thread.go文件

package rtda

/*
JVM
  Thread
    pc
    Stack
      Frame
        LocalVars
        OperandStack
*/
type Thread struct {
    pc    int // the address of the instruction currently being executed
    stack *Stack
    // todo
}

func NewThread() *Thread {
    return &Thread{
        stack: newStack(1024),
    }
}

func (self *Thread) PC() int {
    return self.pc
}
func (self *Thread) SetPC(pc int) {
    self.pc = pc
}

func (self *Thread) PushFrame(frame *Frame) {
    self.stack.push(frame)
}
func (self *Thread) PopFrame() *Frame {
    return self.stack.pop()
}

func (self *Thread) CurrentFrame() *Frame {
    return self.stack.top()
}

定义了pc和stack字段，stack是Stack结构体的指针。NewThread（）创建Thread实例，newStack（）创建Stack结构体实例，参数表示要创建的Stack最多容纳多少帧，PushFrame（）和PopFrame（）方法调用Stack结构体的相应方法。CurrentFrame（）方法返回当前帧。

2、java虚拟机栈

创建jvm_stack.go文件

package rtda

// jvm stack
type Stack struct {
    maxSize uint
    size    uint
    _top    *Frame // stack is implemented as linked list
}

func newStack(maxSize uint) *Stack {
    return &Stack{
        maxSize: maxSize,
    }
}

func (self *Stack) push(frame *Frame) {
    if self.size >= self.maxSize {
        panic("java.lang.StackOverflowError")
    }

    if self._top != nil {
        frame.lower = self._top
    }

    self._top = frame
    self.size++
}

func (self *Stack) pop() *Frame {
    if self._top == nil {
        panic("jvm stack is empty!")
    }

    top := self._top
    self._top = top.lower
    top.lower = nil
    self.size--

    return top
}

func (self *Stack) top() *Frame {
    if self._top == nil {
        panic("jvm stack is empty!")
    }

    return self._top
}

maxSize保存栈的容量，size是当前大小，_top字段保存栈顶指针。其他函数不做解释。

 

3、帧

建立frame.go文件

package rtda

// stack frame
type Frame struct {
    lower        *Frame // stack is implemented as linked list
    localVars    LocalVars
    operandStack *OperandStack
    // todo
}

func NewFrame(maxLocals, maxStack uint) *Frame {
    return &Frame{
        localVars:    newLocalVars(maxLocals),
        operandStack: newOperandStack(maxStack),
    }
}

// getters
func (self *Frame) LocalVars() LocalVars {
    return self.localVars
}
func (self *Frame) OperandStack() *OperandStack {
    return self.operandStack
}

lower用来实现链表数据结构，localVars字段保存局部变量表指针，operandStack字段保存操作数栈指针。

4、局部变量表

创建slot.go文件。

package rtda

type Slot struct {
    num int32
    ref *Object
}

num字段存放整数，ref存放引用。

创建local_vars.go文件

package rtda

import "math"

type LocalVars []Slot

func newLocalVars(maxLocals uint) LocalVars {
    if maxLocals > 0 {
        return make([]Slot, maxLocals)
    }
    return nil
}

func (self LocalVars) SetInt(index uint, val int32) {
    self[index].num = val
}
func (self LocalVars) GetInt(index uint) int32 {
    return self[index].num
}

func (self LocalVars) SetFloat(index uint, val float32) {
    bits := math.Float32bits(val)
    self[index].num = int32(bits)
}
func (self LocalVars) GetFloat(index uint) float32 {
    bits := uint32(self[index].num)
    return math.Float32frombits(bits)
}

// long consumes two slots
func (self LocalVars) SetLong(index uint, val int64) {
    self[index].num = int32(val)
    self[index+1].num = int32(val >> 32)
}
func (self LocalVars) GetLong(index uint) int64 {
    low := uint32(self[index].num)
    high := uint32(self[index+1].num)
    return int64(high)<<32 | int64(low)
}

// double consumes two slots
func (self LocalVars) SetDouble(index uint, val float64) {
    bits := math.Float64bits(val)
    self.SetLong(index, int64(bits))
}
func (self LocalVars) GetDouble(index uint) float64 {
    bits := uint64(self.GetLong(index))
    return math.Float64frombits(bits)
}

func (self LocalVars) SetRef(index uint, ref *Object) {
    self[index].ref = ref
}
func (self LocalVars) GetRef(index uint) *Object {
    return self[index].ref
}

对不同的变量有不同的存取方法。

5、操作数栈

与局部变量表的实现方法类似。创建operand_stack.go文件

package rtda

import "math"

type OperandStack struct {
    size  uint
    slots []Slot
}

func newOperandStack(maxStack uint) *OperandStack {
    if maxStack > 0 {
        return &OperandStack{
            slots: make([]Slot, maxStack),
        }
    }
    return nil
}

func (self *OperandStack) PushInt(val int32) {
    self.slots[self.size].num = val
    self.size++
}
func (self *OperandStack) PopInt() int32 {
    self.size--
    return self.slots[self.size].num
}

func (self *OperandStack) PushFloat(val float32) {
    bits := math.Float32bits(val)
    self.slots[self.size].num = int32(bits)
    self.size++
}
func (self *OperandStack) PopFloat() float32 {
    self.size--
    bits := uint32(self.slots[self.size].num)
    return math.Float32frombits(bits)
}

// long consumes two slots
func (self *OperandStack) PushLong(val int64) {
    self.slots[self.size].num = int32(val)
    self.slots[self.size+1].num = int32(val >> 32)
    self.size += 2
}
func (self *OperandStack) PopLong() int64 {
    self.size -= 2
    low := uint32(self.slots[self.size].num)
    high := uint32(self.slots[self.size+1].num)
    return int64(high)<<32 | int64(low)
}

// double consumes two slots
func (self *OperandStack) PushDouble(val float64) {
    bits := math.Float64bits(val)
    self.PushLong(int64(bits))
}
func (self *OperandStack) PopDouble() float64 {
    bits := uint64(self.PopLong())
    return math.Float64frombits(bits)
}

func (self *OperandStack) PushRef(ref *Object) {
    self.slots[self.size].ref = ref
    self.size++
}
func (self *OperandStack) PopRef() *Object {
    self.size--
    ref := self.slots[self.size].ref
    self.slots[self.size].ref = nil
    return ref
}

三、测试

在main.go中加入import “jvmgo/rtda"

修改startJVM（）方法

func startJVM(cmd *Cmd) {
    frame := rtda.NewFrame(100, 100)
    testLocalVars(frame.LocalVars())
    testOperandStack(frame.OperandStack())
}

func testLocalVars(vars rtda.LocalVars) {
    vars.SetInt(0, 100)
    vars.SetInt(1, -100)
    vars.SetLong(2, 2997924580)
    vars.SetLong(4, -2997924580)
    vars.SetFloat(6, 3.1415926)
    vars.SetDouble(7, 2.71828182845)
    vars.SetRef(9, nil)
    println(vars.GetInt(0))
    println(vars.GetInt(1))
    println(vars.GetLong(2))
    println(vars.GetLong(4))
    println(vars.GetFloat(6))
    println(vars.GetDouble(7))
    println(vars.GetRef(9))
}

func testOperandStack(ops *rtda.OperandStack) {
    ops.PushInt(100)
    ops.PushInt(-100)
    ops.PushLong(2997924580)
    ops.PushLong(-2997924580)
    ops.PushFloat(3.1415926)
    ops.PushDouble(2.71828182845)
    ops.PushRef(nil)
    println(ops.PopRef())
    println(ops.PopDouble())
    println(ops.PopFloat())
    println(ops.PopLong())
    println(ops.PopLong())
    println(ops.PopInt())
    println(ops.PopInt())
}

在命令行窗口执行 go install jvmgo，编译成功后对jvmgo.exe进行测试

PS D:\Program_Files\go\bin> .\jvmgo.exe test
100
-100
2997924580
-2997924580
+3.141593e+000
+2.718282e+000
0x0
0x0
+2.718282e+000
+3.141593e+000
-2997924580
2997924580
-100
100