misc: add lconst & dconst opcode

Author: tinycedar

instructions/constants/constants.go

@@ -1,6 +1,7 @@
 package constants
 
 import (
+	"fmt"
 	"github.com/tinycedar/vanilla/instructions"
 	"github.com/tinycedar/vanilla/runtime/thread"
 )
@@ -31,12 +32,31 @@ func FetchInstruction(opCode uint8, reader *instructions.CodeReader) instruction
 		return &iconst_x{opCode, 4}
 	case 0x08:
 		return &iconst_x{opCode, 5}
-		//TODO
+	case 0x09:
+		return &lconst_x{opCode, 0}
+	case 0x0a:
+		return &lconst_x{opCode, 1}
+	case 0x0b:
+		return &fconst_x{opCode, 0.0}
+	case 0x0c:
+		return &fconst_x{opCode, 1.0}
+	case 0x0d:
+		return &fconst_x{opCode, 2.0}
+	case 0x0e:
+		return &dconst_x{opCode, 0.0}
+	case 0x0f:
+		return &dconst_x{opCode, 1.0}
 	case 0x10:
 		return &bipush{opCode, reader.ReadInt8()}
+	case 0x11:
+		return &sipush{opCode, reader.ReadInt16()}
 	case 0x12:
-		return &ldc{opCode, reader.ReadUint8()}
+		return &ldc_x{opCode, uint16(reader.ReadUint8())}
+	case 0x13:
+		fallthrough
+	case 0x14:
+		return &ldc_x{opCode, reader.ReadUint16()}
 	default:
-		return instructions.NewNotImplemented(opCode)
+		panic(fmt.Sprintf("invalid opCode: %d", opCode))
 	}
 }

instructions/constants/dconst_x.go

@@ -0,0 +1,14 @@
+package constants
+
+import (
+	"github.com/tinycedar/vanilla/runtime/thread"
+)
+
+type dconst_x struct {
+	opCode   uint8
+	constVal float64
+}
+
+func (l *dconst_x) Execute(f *thread.Frame) {
+	f.OperandStack().PushDouble(l.constVal)
+}

instructions/constants/fconst_x.go

@@ -0,0 +1,12 @@
+package constants
+
+import "github.com/tinycedar/vanilla/runtime/thread"
+
+type fconst_x struct {
+	opCode   uint8
+	constVal float32
+}
+
+func (l *fconst_x) Execute(f *thread.Frame) {
+	f.OperandStack().PushFloat(l.constVal)
+}

instructions/constants/iconst_x.go

@@ -17,16 +17,3 @@ func (i *iconst_x) Execute(f *thread.Frame) {
 func (i *iconst_x) String() string {
 	return fmt.Sprintf("{opcode: 0x%x, iconst_%d}", i.opCode, i.constVal)
 }
-
-type bipush struct {
-	opCode uint8
-	value  int8
-}
-
-func (i *bipush) Execute(f *thread.Frame) {
-	f.OperandStack().PushInt(int32(i.value))
-}
-
-func (i *bipush) String() string {
-	return fmt.Sprintf("{opcode: 0x%x, bipush}", i.opCode)
-}

instructions/constants/lconst_x.go

@@ -0,0 +1,14 @@
+package constants
+
+import (
+	"github.com/tinycedar/vanilla/runtime/thread"
+)
+
+type lconst_x struct {
+	opCode   uint8
+	constVal int64
+}
+
+func (l *lconst_x) Execute(f *thread.Frame) {
+	f.OperandStack().PushLong(l.constVal)
+}

instructions/constants/ldc.go

@@ -0,0 +1,23 @@
+package constants
+
+import (
+	"fmt"
+	"github.com/tinycedar/classp/classfile"
+	"github.com/tinycedar/vanilla/runtime/thread"
+)
+
+type ldc_x struct {
+	opCode uint8
+	index  uint16
+}
+
+func (i *ldc_x) Execute(f *thread.Frame) {
+	if cp, ok := f.Method().Cp[i.index].(*classfile.ConstantStringInfo); ok {
+		f.OperandStack().PushString(cp.String(f.Method().Cp))
+	}
+	//TODO
+}
+
+func (i *ldc_x) String() string {
+	return fmt.Sprintf("{opcode: 0x%x, ldc_x}", i.opCode)
+}

instructions/constants/ldc_x.go

@@ -0,0 +1,32 @@
+package constants
+
+import (
+	"fmt"
+	"github.com/tinycedar/vanilla/runtime/thread"
+)
+
+type bipush struct {
+	opCode uint8
+	value  int8
+}
+
+type sipush struct {
+	opCode uint8
+	value  int16
+}
+
+func (i *bipush) Execute(f *thread.Frame) {
+	f.OperandStack().PushInt(int32(i.value))
+}
+
+func (i *sipush) Execute(f *thread.Frame) {
+	f.OperandStack().PushInt(int32(i.value))
+}
+
+func (i *bipush) String() string {
+	return fmt.Sprintf("{opcode: 0x%x, bipush}", i.opCode)
+}
+
+func (i *sipush) String() string {
+	return fmt.Sprintf("{opcode: 0x%x, sipush}", i.opCode)
+}

instructions/constants/xipush.go

@@ -1,6 +1,9 @@
 package thread
 
-import "fmt"
+import (
+	"fmt"
+	"math"
+)
 
 type OperandStack struct {
 	size  int
@@ -13,8 +16,8 @@ func newOperandStack(maxStack uint) *OperandStack {
 	}
 }
 
-func (s *OperandStack) PushInt(num int32) {
-	s.slots[s.size].num = num
+func (s *OperandStack) PushInt(val int32) {
+	s.slots[s.size].num = val
 	s.size++
 }
 
@@ -23,6 +26,39 @@ func (s *OperandStack) PopInt() int32 {
 	return s.slots[s.size].num
 }
 
+func (s *OperandStack) PushLong(val int64) {
+	s.slots[s.size].num = int32(val >> 32) // high
+	s.slots[s.size+1].num = int32(val)     // low
+	s.size += 2
+}
+
+func (s *OperandStack) PopLong() int64 {
+	s.size -= 2
+	high := s.slots[s.size].num
+	low := s.slots[s.size+1].num
+	return int64(high)<<32 | int64(low)
+}
+
+func (s *OperandStack) PushFloat(val float32) {
+	s.slots[s.size].num = int32(math.Float32bits(val))
+	s.size++
+}
+
+func (s *OperandStack) PopFloat() float32 {
+	s.size--
+	return math.Float32frombits(uint32(s.slots[s.size].num))
+}
+
+func (s *OperandStack) PushDouble(val float64) {
+	s.slots[s.size].num = int32(math.Float64bits(val))
+	s.size++
+}
+
+func (s *OperandStack) PopDouble() float64 {
+	s.size--
+	return math.Float64frombits(uint64(s.slots[s.size].num))
+}
+
 func (s *OperandStack) PushString(str string) {
 	s.slots[s.size] = Slot{ref: &Object{str}}
 	s.size++