Example #1
0
func free(address int64) {
	if _, ok := _allocated[address]; ok {
		delete(_allocated, address)
	} else {
		jutil.Panicf("memory was not allocated: %v", address)
	}
}
Example #2
0
// todo ugly code
func newConstantInfo(tag uint8, cp *ConstantPool) ConstantInfo {
	switch tag {
	case CONSTANT_Integer:
		return &ConstantIntegerInfo{}
	case CONSTANT_Float:
		return &ConstantFloatInfo{}
	case CONSTANT_Long:
		return &ConstantLongInfo{}
	case CONSTANT_Double:
		return &ConstantDoubleInfo{}
	case CONSTANT_Utf8:
		return &ConstantUtf8Info{}
	case CONSTANT_String:
		return &ConstantStringInfo{cp: cp}
	case CONSTANT_Class:
		return &ConstantClassInfo{cp: cp}
	case CONSTANT_Fieldref:
		return &ConstantFieldrefInfo{ConstantMemberrefInfo{cp: cp}}
	case CONSTANT_Methodref:
		return &ConstantMethodrefInfo{ConstantMemberrefInfo{cp: cp}}
	case CONSTANT_InterfaceMethodref:
		return &ConstantInterfaceMethodrefInfo{ConstantMemberrefInfo{cp: cp}}
	case CONSTANT_NameAndType:
		return &ConstantNameAndTypeInfo{}
	case CONSTANT_MethodType:
		return &ConstantMethodTypeInfo{}
	case CONSTANT_MethodHandle:
		return &ConstantMethodHandleInfo{}
	case CONSTANT_InvokeDynamic:
		return &ConstantInvokeDynamicInfo{cp: cp}
	default: // todo
		jutil.Panicf("BAD constant pool tag: %v", tag)
		return nil
	}
}
Example #3
0
func memoryAt(address int64) []byte {
	for startAddress, mem := range _allocated {
		endAddress := startAddress + int64(len(mem))
		if address >= startAddress && address < endAddress {
			offset := address - startAddress
			return mem[offset:]
		}
	}
	jutil.Panicf("invalid address: %v", address)
	return nil
}
Example #4
0
func _getEntryBytes(jzentry int64, _type int32) []byte {
	entry := getEntryFile(jzentry)
	switch _type {
	case JZENTRY_NAME:
		return []byte(entry.Name)
	case JZENTRY_EXTRA:
		return entry.Extra
	case JZENTRY_COMMENT:
		return []byte(entry.Comment)
	}
	jutil.Panicf("BAD type: %v", _type)
	return nil
}
Example #5
0
func (self *LDC2_W) Execute(frame *rtda.Frame) {
	stack := frame.OperandStack()
	cp := frame.ConstantPool()
	c := cp.GetConstant(self.Index)

	switch c.(type) {
	case int64:
		stack.PushLong(c.(int64))
	case float64:
		stack.PushDouble(c.(float64))
	default:
		jutil.Panicf("ldc2_w! %v", c)
	}
}
Example #6
0
func (self *ConstantFieldref) resolveInstanceField() {
	fromClass := bootLoader.LoadClass(self.className)

	for class := fromClass; class != nil; class = class.superClass {
		field := class.getField(self.name, self.descriptor, false)
		if field != nil {
			self.field = field
			return
		}
	}

	// todo
	jutil.Panicf("instance field not found! %v", self)
}
Example #7
0
func (self *ConstantFieldref) resolveStaticField() {
	fromClass := bootLoader.LoadClass(self.className)

	for class := fromClass; class != nil; class = class.superClass {
		field := class.getField(self.name, self.descriptor, true)
		if field != nil {
			self.field = field
			return
		}
		if self._findInterfaceField(class) {
			return
		}
	}

	// todo
	jutil.Panicf("static field not found! %v", self)
}
Example #8
0
// boxing primitive types
// primitive value must be on the top of operand stack
func Box(frame *rtda.Frame, primitiveDescriptor byte) {
	switch primitiveDescriptor {
	case 'Z':
		_callValueOf(frame, "Z", "java/lang/Boolean")
	case 'B':
		_callValueOf(frame, "B", "java/lang/Byte")
	case 'C':
		_callValueOf(frame, "C", "java/lang/Character")
	case 'S':
		_callValueOf(frame, "S", "java/lang/Short")
	case 'I':
		_callValueOf(frame, "I", "java/lang/Integer")
	case 'J':
		_callValueOf(frame, "J", "java/lang/Long")
	case 'F':
		_callValueOf(frame, "F", "java/lang/Float")
	case 'D':
		_callValueOf(frame, "D", "java/lang/Double")
	default:
		jutil.Panicf("Not primitive type: %v", primitiveDescriptor)
	}
}
Example #9
0
func ArrayCopy(src, dst *Obj, srcPos, dstPos, length int32) {
	switch src.fields.(type) {
	case []int8:
		_src := src.fields.([]int8)[srcPos : srcPos+length]
		_dst := dst.fields.([]int8)[dstPos : dstPos+length]
		copy(_dst, _src)
	case []int16:
		_src := src.fields.([]int16)[srcPos : srcPos+length]
		_dst := dst.fields.([]int16)[dstPos : dstPos+length]
		copy(_dst, _src)
	case []int32:
		_src := src.fields.([]int32)[srcPos : srcPos+length]
		_dst := dst.fields.([]int32)[dstPos : dstPos+length]
		copy(_dst, _src)
	case []int64:
		_src := src.fields.([]int64)[srcPos : srcPos+length]
		_dst := dst.fields.([]int64)[dstPos : dstPos+length]
		copy(_dst, _src)
	case []uint16:
		_src := src.fields.([]uint16)[srcPos : srcPos+length]
		_dst := dst.fields.([]uint16)[dstPos : dstPos+length]
		copy(_dst, _src)
	case []float32:
		_src := src.fields.([]float32)[srcPos : srcPos+length]
		_dst := dst.fields.([]float32)[dstPos : dstPos+length]
		copy(_dst, _src)
	case []float64:
		_src := src.fields.([]float64)[srcPos : srcPos+length]
		_dst := dst.fields.([]float64)[dstPos : dstPos+length]
		copy(_dst, _src)
	case []*Obj:
		_src := src.fields.([]*Obj)[srcPos : srcPos+length]
		_dst := dst.fields.([]*Obj)[dstPos : dstPos+length]
		copy(_dst, _src)
	default:
		jutil.Panicf("Not array: %v!", src)
	}
}
Example #10
0
func ArrayLength(arr *Obj) int32 {
	switch arr.fields.(type) {
	case []int8:
		return int32(len(arr.fields.([]int8)))
	case []int16:
		return int32(len(arr.fields.([]int16)))
	case []int32:
		return int32(len(arr.fields.([]int32)))
	case []int64:
		return int32(len(arr.fields.([]int64)))
	case []uint16:
		return int32(len(arr.fields.([]uint16)))
	case []float32:
		return int32(len(arr.fields.([]float32)))
	case []float64:
		return int32(len(arr.fields.([]float64)))
	case []*Obj:
		return int32(len(arr.fields.([]*Obj)))
	default:
		jutil.Panicf("Not array: %v!", arr)
		return -1
	}
}
Example #11
0
func NewPrimitiveArray(atype uint8, count uint) *Obj {
	switch atype {
	case AT_BOOLEAN:
		return newObj(bootLoader.getClass("[Z"), make([]int8, count), nil)
	case AT_BYTE:
		return newObj(bootLoader.getClass("[B"), make([]int8, count), nil)
	case AT_CHAR:
		return newObj(bootLoader.getClass("[C"), make([]uint16, count), nil)
	case AT_SHORT:
		return newObj(bootLoader.getClass("[S"), make([]int16, count), nil)
	case AT_INT:
		return newObj(bootLoader.getClass("[I"), make([]int32, count), nil)
	case AT_LONG:
		return newObj(bootLoader.getClass("[J"), make([]int64, count), nil)
	case AT_FLOAT:
		return newObj(bootLoader.getClass("[F"), make([]float32, count), nil)
	case AT_DOUBLE:
		return newObj(bootLoader.getClass("[D"), make([]float64, count), nil)
	default:
		jutil.Panicf("BAD atype: %v!", atype)
		return nil
	}
}
Example #12
0
func _newPrimitiveArray(arrClass *Class, count uint) *Obj {
	switch arrClass.Name() {
	case "[Z":
		return newObj(arrClass, make([]int8, count), nil)
	case "[B":
		return newObj(arrClass, make([]int8, count), nil)
	case "[C":
		return newObj(arrClass, make([]uint16, count), nil)
	case "[S":
		return newObj(arrClass, make([]int16, count), nil)
	case "[I":
		return newObj(arrClass, make([]int32, count), nil)
	case "[L":
		return newObj(arrClass, make([]int64, count), nil)
	case "[F":
		return newObj(arrClass, make([]float32, count), nil)
	case "[D":
		return newObj(arrClass, make([]float64, count), nil)
	default:
		jutil.Panicf("Not primitive array: %v!", arrClass)
		return nil
	}
}
Example #13
0
func _ldc(frame *rtda.Frame, index uint) {
	stack := frame.OperandStack()
	cp := frame.ConstantPool()
	c := cp.GetConstant(index)

	switch c.(type) {
	case int32:
		stack.PushInt(c.(int32))
	case float32:
		stack.PushFloat(c.(float32))
	case string:
		internedStr := rtda.JString(c.(string))
		stack.PushRef(internedStr)
	case *heap.ConstantClass:
		kClass := c.(*heap.ConstantClass)
		classObj := kClass.Class().JClass()
		stack.PushRef(classObj)
	default:
		// todo
		// ref to MethodType or MethodHandle
		jutil.Panicf("todo: ldc! %v", c)
	}
}
Example #14
0
func newInstruction(opcode byte) Instruction {
	switch opcode {
	case 0x00:
		return _nop
	case 0x01:
		return _aconst_null
	case 0x02:
		return _iconst_m1
	case 0x03:
		return _iconst_0
	case 0x04:
		return _iconst_1
	case 0x05:
		return _iconst_2
	case 0x06:
		return _iconst_3
	case 0x07:
		return _iconst_4
	case 0x08:
		return _iconst_5
	case 0x09:
		return _lconst_0
	case 0x0a:
		return _lconst_1
	case 0x0b:
		return _fconst_0
	case 0x0c:
		return _fconst_1
	case 0x0d:
		return _fconst_2
	case 0x0e:
		return _dconst_0
	case 0x0f:
		return _dconst_1
	case 0x10:
		return &bipush{}
	case 0x11:
		return &sipush{}
	case 0x12:
		return &ldc{}
	case 0x13:
		return &ldc_w{}
	case 0x14:
		return &ldc2_w{}
	case 0x15:
		return &iload{}
	case 0x16:
		return &lload{}
	case 0x17:
		return &fload{}
	case 0x18:
		return &dload{}
	case 0x19:
		return &aload{}
	case 0x1a:
		return _iload_0
	case 0x1b:
		return _iload_1
	case 0x1c:
		return _iload_2
	case 0x1d:
		return _iload_3
	case 0x1e:
		return _lload_0
	case 0x1f:
		return _lload_1
	case 0x20:
		return _lload_2
	case 0x21:
		return _lload_3
	case 0x22:
		return _fload_0
	case 0x23:
		return _fload_1
	case 0x24:
		return _fload_2
	case 0x25:
		return _fload_3
	case 0x26:
		return _dload_0
	case 0x27:
		return _dload_1
	case 0x28:
		return _dload_2
	case 0x29:
		return _dload_3
	case 0x2a:
		return _aload_0
	case 0x2b:
		return _aload_1
	case 0x2c:
		return _aload_2
	case 0x2d:
		return _aload_3
	case 0x2e:
		return _iaload
	case 0x2f:
		return _laload
	case 0x30:
		return _faload
	case 0x31:
		return _daload
	case 0x32:
		return _aaload
	case 0x33:
		return _baload
	case 0x34:
		return _caload
	case 0x35:
		return _saload
	case 0x36:
		return &istore{}
	case 0x37:
		return &lstore{}
	case 0x38:
		return &fstore{}
	case 0x39:
		return &dstore{}
	case 0x3a:
		return &astore{}
	case 0x3b:
		return _istore_0
	case 0x3c:
		return _istore_1
	case 0x3d:
		return _istore_2
	case 0x3e:
		return _istore_3
	case 0x3f:
		return _lstore_0
	case 0x40:
		return _lstore_1
	case 0x41:
		return _lstore_2
	case 0x42:
		return _lstore_3
	case 0x43:
		return _fstore_0
	case 0x44:
		return _fstore_1
	case 0x45:
		return _fstore_2
	case 0x46:
		return _fstore_3
	case 0x47:
		return _dstore_0
	case 0x48:
		return _dstore_1
	case 0x49:
		return _dstore_2
	case 0x4a:
		return _dstore_3
	case 0x4b:
		return _astore_0
	case 0x4c:
		return _astore_1
	case 0x4d:
		return _astore_2
	case 0x4e:
		return _astore_3
	case 0x4f:
		return _iastore
	case 0x50:
		return _lastore
	case 0x51:
		return _fastore
	case 0x52:
		return _dastore
	case 0x53:
		return _aastore
	case 0x54:
		return _bastore
	case 0x55:
		return _castore
	case 0x56:
		return _sastore
	case 0x57:
		return _pop
	case 0x58:
		return _pop2
	case 0x59:
		return _dup
	case 0x5a:
		return _dup_x1
	case 0x5b:
		return _dup_x2
	case 0x5c:
		return _dup2
	case 0x5d:
		return _dup2_x1
	case 0x5e:
		return _dup2_x2
	case 0x5f:
		return _swap
	case 0x60:
		return _iadd
	case 0x61:
		return _ladd
	case 0x62:
		return _fadd
	case 0x63:
		return _dadd
	case 0x64:
		return _isub
	case 0x65:
		return _lsub
	case 0x66:
		return _fsub
	case 0x67:
		return _dsub
	case 0x68:
		return _imul
	case 0x69:
		return _lmul
	case 0x6a:
		return _fmul
	case 0x6b:
		return _dmul
	case 0x6c:
		return _idiv
	case 0x6d:
		return _ldiv
	case 0x6e:
		return _fdiv
	case 0x6f:
		return _ddiv
	case 0x70:
		return _irem
	case 0x71:
		return _lrem
	case 0x72:
		return _frem
	case 0x73:
		return _drem
	case 0x74:
		return _ineg
	case 0x75:
		return _lneg
	case 0x76:
		return _fneg
	case 0x77:
		return _dneg
	case 0x78:
		return _ishl
	case 0x79:
		return _lshl
	case 0x7a:
		return _ishr
	case 0x7b:
		return _lshr
	case 0x7c:
		return _iushr
	case 0x7d:
		return _lushr
	case 0x7e:
		return _iand
	case 0x7f:
		return _land
	case 0x80:
		return _ior
	case 0x81:
		return _lor
	case 0x82:
		return _ixor
	case 0x83:
		return _lxor
	case 0x84:
		return &iinc{}
	case 0x85:
		return _i2l
	case 0x86:
		return _i2f
	case 0x87:
		return _i2d
	case 0x88:
		return _l2i
	case 0x89:
		return _l2f
	case 0x8a:
		return _l2d
	case 0x8b:
		return _f2i
	case 0x8c:
		return _f2l
	case 0x8d:
		return _f2d
	case 0x8e:
		return _d2i
	case 0x8f:
		return _d2l
	case 0x90:
		return _d2f
	case 0x91:
		return _i2b
	case 0x92:
		return _i2c
	case 0x93:
		return _i2s
	case 0x94:
		return _lcmp
	case 0x95:
		return _fcmpl
	case 0x96:
		return _fcmpg
	case 0x97:
		return _dcmpl
	case 0x98:
		return _dcmpg
	case 0x99:
		return &ifeq{}
	case 0x9a:
		return &ifne{}
	case 0x9b:
		return &iflt{}
	case 0x9c:
		return &ifge{}
	case 0x9d:
		return &ifgt{}
	case 0x9e:
		return &ifle{}
	case 0x9f:
		return &if_icmpeq{}
	case 0xa0:
		return &if_icmpne{}
	case 0xa1:
		return &if_icmplt{}
	case 0xa2:
		return &if_icmpge{}
	case 0xa3:
		return &if_icmpgt{}
	case 0xa4:
		return &if_icmple{}
	case 0xa5:
		return &if_acmpeq{}
	case 0xa6:
		return &if_acmpne{}
	case 0xa7:
		return &goto_{}
	case 0xa8:
		return &jsr{}
	case 0xa9:
		return &ret{}
	case 0xaa:
		return &tableswitch{}
	case 0xab:
		return &lookupswitch{}
	case 0xac:
		return _ireturn
	case 0xad:
		return _lreturn
	case 0xae:
		return _freturn
	case 0xaf:
		return _dreturn
	case 0xb0:
		return _areturn
	case 0xb1:
		return _return_
	case 0xb2:
		return &getstatic{}
	case 0xb3:
		return &putstatic{}
	case 0xb4:
		return &getfield{}
	case 0xb5:
		return &putfield{}
	case 0xb6:
		return &invokevirtual{}
	case 0xb7:
		return &invokespecial{}
	case 0xb8:
		return &invokestatic{}
	case 0xb9:
		return &invokeinterface{}
	case 0xba:
		return &invokedynamic{}
	case 0xbb:
		return &new_{}
	case 0xbc:
		return &newarray{}
	case 0xbd:
		return &anewarray{}
	case 0xbe:
		return _arraylength
	case 0xbf:
		return _athrow
	case 0xc0:
		return &checkcast{}
	case 0xc1:
		return &instanceof{}
	case 0xc2:
		return _monitorenter
	case 0xc3:
		return _monitorexit
	case 0xc4:
		return &wide{}
	case 0xc5:
		return &multianewarray{}
	case 0xc6:
		return &ifnull{}
	case 0xc7:
		return &ifnonnull{}
	case 0xc8:
		return &goto_w{}
	case 0xc9:
		return &jsr_w{}
	//case 0xca: todo breakpoint
	case 0xfe:
		return _invoke_native // impdep1
	case 0xff:
		return &bootstrap{} // impdep2
	default:
		jutil.Panicf("BAD opcode: %v!", opcode)
		return nil
	}
}
Example #15
0
func newInstruction(opcode byte) base.Instruction {
	switch opcode {
	case 0x00:
		return nop
	case 0x01:
		return aconst_null
	case 0x02:
		return iconst_m1
	case 0x03:
		return iconst_0
	case 0x04:
		return iconst_1
	case 0x05:
		return iconst_2
	case 0x06:
		return iconst_3
	case 0x07:
		return iconst_4
	case 0x08:
		return iconst_5
	case 0x09:
		return lconst_0
	case 0x0a:
		return lconst_1
	case 0x0b:
		return fconst_0
	case 0x0c:
		return fconst_1
	case 0x0d:
		return fconst_2
	case 0x0e:
		return dconst_0
	case 0x0f:
		return dconst_1
	case 0x10:
		return &BIPUSH{}
	case 0x11:
		return &SIPUSH{}
	case 0x12:
		return &LDC{}
	case 0x13:
		return &LDC_W{}
	case 0x14:
		return &LDC2_W{}
	case 0x15:
		return &ILOAD{}
	case 0x16:
		return &LLOAD{}
	case 0x17:
		return &FLOAD{}
	case 0x18:
		return &DLOAD{}
	case 0x19:
		return &ALOAD{}
	case 0x1a:
		return iload_0
	case 0x1b:
		return iload_1
	case 0x1c:
		return iload_2
	case 0x1d:
		return iload_3
	case 0x1e:
		return lload_0
	case 0x1f:
		return lload_1
	case 0x20:
		return lload_2
	case 0x21:
		return lload_3
	case 0x22:
		return fload_0
	case 0x23:
		return fload_1
	case 0x24:
		return fload_2
	case 0x25:
		return fload_3
	case 0x26:
		return dload_0
	case 0x27:
		return dload_1
	case 0x28:
		return dload_2
	case 0x29:
		return dload_3
	case 0x2a:
		return aload_0
	case 0x2b:
		return aload_1
	case 0x2c:
		return aload_2
	case 0x2d:
		return aload_3
	case 0x2e:
		return iaload
	case 0x2f:
		return laload
	case 0x30:
		return faload
	case 0x31:
		return daload
	case 0x32:
		return aaload
	case 0x33:
		return baload
	case 0x34:
		return caload
	case 0x35:
		return saload
	case 0x36:
		return &ISTORE{}
	case 0x37:
		return &LSTORE{}
	case 0x38:
		return &FSTORE{}
	case 0x39:
		return &DSTORE{}
	case 0x3a:
		return &ASTORE{}
	case 0x3b:
		return istore_0
	case 0x3c:
		return istore_1
	case 0x3d:
		return istore_2
	case 0x3e:
		return istore_3
	case 0x3f:
		return lstore_0
	case 0x40:
		return lstore_1
	case 0x41:
		return lstore_2
	case 0x42:
		return lstore_3
	case 0x43:
		return fstore_0
	case 0x44:
		return fstore_1
	case 0x45:
		return fstore_2
	case 0x46:
		return fstore_3
	case 0x47:
		return dstore_0
	case 0x48:
		return dstore_1
	case 0x49:
		return dstore_2
	case 0x4a:
		return dstore_3
	case 0x4b:
		return astore_0
	case 0x4c:
		return astore_1
	case 0x4d:
		return astore_2
	case 0x4e:
		return astore_3
	case 0x4f:
		return iastore
	case 0x50:
		return lastore
	case 0x51:
		return fastore
	case 0x52:
		return dastore
	case 0x53:
		return aastore
	case 0x54:
		return bastore
	case 0x55:
		return castore
	case 0x56:
		return sastore
	case 0x57:
		return pop
	case 0x58:
		return pop2
	case 0x59:
		return dup
	case 0x5a:
		return dup_x1
	case 0x5b:
		return dup_x2
	case 0x5c:
		return dup2
	case 0x5d:
		return dup2_x1
	case 0x5e:
		return dup2_x2
	case 0x5f:
		return swap
	case 0x60:
		return iadd
	case 0x61:
		return ladd
	case 0x62:
		return fadd
	case 0x63:
		return dadd
	case 0x64:
		return isub
	case 0x65:
		return lsub
	case 0x66:
		return fsub
	case 0x67:
		return dsub
	case 0x68:
		return imul
	case 0x69:
		return lmul
	case 0x6a:
		return fmul
	case 0x6b:
		return dmul
	case 0x6c:
		return idiv
	case 0x6d:
		return ldiv
	case 0x6e:
		return fdiv
	case 0x6f:
		return ddiv
	case 0x70:
		return irem
	case 0x71:
		return lrem
	case 0x72:
		return frem
	case 0x73:
		return drem
	case 0x74:
		return ineg
	case 0x75:
		return lneg
	case 0x76:
		return fneg
	case 0x77:
		return dneg
	case 0x78:
		return ishl
	case 0x79:
		return lshl
	case 0x7a:
		return ishr
	case 0x7b:
		return lshr
	case 0x7c:
		return iushr
	case 0x7d:
		return lushr
	case 0x7e:
		return iand
	case 0x7f:
		return land
	case 0x80:
		return ior
	case 0x81:
		return lor
	case 0x82:
		return ixor
	case 0x83:
		return lxor
	case 0x84:
		return &IINC{}
	case 0x85:
		return i2l
	case 0x86:
		return i2f
	case 0x87:
		return i2d
	case 0x88:
		return l2i
	case 0x89:
		return l2f
	case 0x8a:
		return l2d
	case 0x8b:
		return f2i
	case 0x8c:
		return f2l
	case 0x8d:
		return f2d
	case 0x8e:
		return d2i
	case 0x8f:
		return d2l
	case 0x90:
		return d2f
	case 0x91:
		return i2b
	case 0x92:
		return i2c
	case 0x93:
		return i2s
	case 0x94:
		return lcmp
	case 0x95:
		return fcmpl
	case 0x96:
		return fcmpg
	case 0x97:
		return dcmpl
	case 0x98:
		return dcmpg
	case 0x99:
		return &IFEQ{}
	case 0x9a:
		return &IFNE{}
	case 0x9b:
		return &IFLT{}
	case 0x9c:
		return &IFGE{}
	case 0x9d:
		return &IFGT{}
	case 0x9e:
		return &IFLE{}
	case 0x9f:
		return &IF_ICMPEQ{}
	case 0xa0:
		return &IF_ICMPNE{}
	case 0xa1:
		return &IF_ICMPLT{}
	case 0xa2:
		return &IF_ICMPGE{}
	case 0xa3:
		return &IF_ICMPGT{}
	case 0xa4:
		return &IF_ICMPLE{}
	case 0xa5:
		return &IF_ACMPEQ{}
	case 0xa6:
		return &IF_ACMPNE{}
	case 0xa7:
		return &GOTO{}
	case 0xa8:
		return &JSR{}
	case 0xa9:
		return &RET{}
	case 0xaa:
		return &TABLE_SWITCH{}
	case 0xab:
		return &LOOKUP_SWITCH{}
	case 0xac:
		return ireturn
	case 0xad:
		return lreturn
	case 0xae:
		return freturn
	case 0xaf:
		return dreturn
	case 0xb0:
		return areturn
	case 0xb1:
		return _return
	case 0xb2:
		return &GET_STATIC{}
	case 0xb3:
		return &PUT_STATIC{}
	case 0xb4:
		return &GET_FIELD{}
	case 0xb5:
		return &PUT_FIELD{}
	case 0xb6:
		return &INVOKE_VIRTUAL{}
	case 0xb7:
		return &INVOKE_SPECIAL{}
	case 0xb8:
		return &INVOKE_STATIC{}
	case 0xb9:
		return &INVOKE_INTERFACE{}
	case 0xba:
		return &INVOKE_DYNAMIC{}
	case 0xbb:
		return &NEW{}
	case 0xbc:
		return &NEW_ARRAY{}
	case 0xbd:
		return &ANEW_ARRAY{}
	case 0xbe:
		return arraylength
	case 0xbf:
		return athrow
	case 0xc0:
		return &CHECK_CAST{}
	case 0xc1:
		return &INSTANCE_OF{}
	case 0xc2:
		return monitorenter
	case 0xc3:
		return monitorexit
	case 0xc4:
		return &WIDE{}
	case 0xc5:
		return &MULTI_ANEW_ARRAY{}
	case 0xc6:
		return &IFNULL{}
	case 0xc7:
		return &IFNONNULL{}
	case 0xc8:
		return &GOTO_W{}
	case 0xc9:
		return &JSR_W{}
	//case 0xca: todo breakpoint
	case 0xfe:
		return invoke_native // impdep1
	case 0xff:
		return &BOOTSTRAP{} // impdep2
	default:
		jutil.Panicf("BAD opcode: %v!", opcode)
		return nil
	}
}