mruby-mruby/doc/opcode.md

The new bytecode

We will reimplement VM to use 8bit instruction code. By bytecode, we mean real byte code. The whole purpose is reducing the memory consumption of mruby VM.

Instructions

Instructions are bytes. There can be 256 instructions. Currently we have 94 instructions. Instructions can take 0 to 3 operands.

operands

The size of operands can be either 8bits, 16bits or 24bits. In the table.1 below, the second field describes the size (and sign) of operands.

• B: 8bit
• sB: signed 8bit
• S: 16bit
• sS: signed 16bit
• W: 24bit

First two byte operands may be extended to 16bit. When those byte operands are bigger than 256, the instruction will be prefixed by OP_EXT1 (means 1st operand is 16bit) or OP_EXT2 (means 2nd operand is 16bit) or OP_EXT3 (means 1st and 2nd operands are 16bit).

For instructions marked by ', OP_EXT1 can be prefixed. For those with ", either OP_EXT1 or OP_EXT2 or OP_EXT2 can be prefixed.

table.1 Instruction Table

Instruction Name	Operand type	Semantics
OP_NOP	-
OP_MOVE"	BB	R(a) = R(b)
OP_LOADL"	BB	R(a) = Pool(b)
OP_LOADI"	BsB	R(a) = mrb_int(b)
OP_LOADI_0'	B	R(a) = 0
OP_LOADI_1'	B	R(a) = 1
OP_LOADI_2'	B	R(a) = 2
OP_LOADI_3'	B	R(a) = 3
OP_LOADSYM"	BB	R(a) = Syms(b)
OP_LOADNIL'	B	R(a) = nil
OP_LOADSELF'	B	R(a) = self
OP_LOADT'	B	R(a) = true
OP_LOADF'	B	R(a) = false
OP_GETGV"	BB	R(a) = getglobal(Syms(b))
OP_SETGV"	BB	setglobal(Syms(b), R(a))
OP_GETSV"	BB	R(a) = Special[b]
OP_SETSV"	BB	Special[b] = R(a)
OP_GETIV"	BB	R(a) = ivget(Syms(b))
OP_SETIV"	BB	ivset(Syms(b),R(a))
OP_GETCV"	BB	R(a) = cvget(Syms(b))
OP_SETCV"	BB	cvset(Syms(b),R(a))
OP_GETCONST"	BB	R(a) = constget(Syms(b))
OP_SETCONST"	BB	constset(Syms(b),R(a))
OP_GETMCNST"	BB	R(a) = R(a)::Syms(b)
OP_SETMCNST"	BB	R(a+1)::Syms(b) = R(a)
OP_GETUPVAR'	BBB	R(a) = uvget(b,c)
OP_SETUPVAR'	BBB	uvset(b,c,R(a))
OP_JMP	S	pc+=a
OP_JMPIF'	SB	if R(b) pc+=a
OP_JMPNOT'	SB	if !R(b) pc+=a
OP_ONERR	sS	rescue_push(pc+a)
OP_EXCEPT'	B	R(a) = exc
OP_RESCUE"	BB	R(b) = R(a).isa?(R(b))
OP_POPERR	B	a.times{rescue_pop()}
OP_RAISE'	B	raise(R(a))
OP_EPUSH'	B	ensure_push(SEQ[a])
OP_EPOP	B	A.times{ensure_pop().call}
OP_SENDV"	BB	R(a) = call(R(a),Syms(b),*R(a+1))
OP_SENDVB"	BB	R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2))
OP_SEND"	BBB	R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))
OP_SENDB"	BBB	R(a) = call(R(a),Syms(Bx),R(a+1),...,R(a+c),&R(a+c+1))
OP_CALL'	B	R(a) = self.call(frame.argc, frame.argv)
OP_SUPER'	BB	R(a) = super(R(a+1),... ,R(a+b+1))
OP_ARGARY'	BS	R(a) = argument array (16=5:1:5:1:4)
OP_ENTER	W	arg setup according to flags (23=5:5:1:5:5:1:1)
OP_KARG"	BB	R(a) = kdict[Syms(Bx)] # todo
OP_KARG2"	BB	R(a) = kdict[Syms(Bx)]; kdict.rm(Syms(b)) # todo
OP_RETURN'	B	return R(a) (normal)
OP_RETURN_BLK'	B	return R(a) (in-block return)
OP_BREAK'	B	break R(a)
OP_BLKPUSH'	BS	R(a) = block (16=5:1:5:1:4)
OP_ADD"	BB	R(a) = R(a)+R(a+1)
OP_ADDI"	BBB	R(a) = R(a)+mrb_int(c)
OP_SUB"	BB	R(a) = R(a)-R(a+1)
OP_SUBI"	BB	R(a) = R(a)-C
OP_MUL"	BB	R(a) = R(a)*R(a+1)
OP_DIV"	BB	R(a) = R(a)/R(a+1)
OP_EQ"	BB	R(a) = R(a)==R(a+1)
OP_LT"	BB	R(a) = R(a)<R(a+1)
OP_LE"	BB	R(a) = R(a)<=R(a+1)
OP_GT"	BB	R(a) = R(a)>R(a+1)
OP_GE"	BB	R(a) = R(a)>=R(a+1)
OP_ARRAY'	BB	R(a) = ary_new(R(a),R(a+1)..R(a+b))
OP_ARRAY2"	BB	R(a) = ary_new(R(b),R(b+1)..R(b+c))
OP_ARYCAT'	B	ary_cat(R(a),R(a+1))
OP_ARYPUSH'	B	ary_push(R(a),R(a+1))
OP_AREF'	BB	R(a) = R(a)[b]
OP_ASET'	BB	R(a)[b] = R(a+1)
OP_APOST'	BB	*R(a),R(A+1)..R(A+C) = R(a)[B..]
OP_STRING"	BB	R(a) = str_dup(Lit(b))
OP_STRCAT'	B	str_cat(R(a),R(a+1))
OP_HASH'	BB	R(a) = hash_new(R(a),R(a+1)..R(a+b))
OP_HASHADD'	BB	R(a) = hash_push(R(a),R(a+1)..R(a+b))
OP_LAMBDA"	BB	R(a) = lambda(SEQ[b],OP_L_LAMBDA)
OP_BLOCK"	BB	R(a) = lambda(SEQ[b],OP_L_BLOCK)
OP_METHOD"	BB	R(a) = lambda(SEQ[b],OP_L_METHOD)
OP_RANGE_INC'	B	R(a) = range_new(R(a),R(a+1),FALSE)
OP_RANGE_EXC'	B	R(a) = range_new(R(a),R(a+1),TRUE)
OP_OCLASS'	B	R(a) = ::Object
OP_CLASS"	BB	R(a) = newclass(R(a),Syms(b),R(a+1))
OP_MODULE"	BB	R(a) = newmodule(R(a),Syms(b))
OP_EXEC"	BB	R(a) = blockexec(R(a),SEQ[b])
OP_DEF"	BB	R(a).newmethod(Syms(b),R(a+1))
OP_ALIAS'	B	alias_method(R(a),R(a+1),R(a+2))
OP_UNDEF"	BB	undef_method(R(a),Syms(b))
OP_SCLASS'	B	R(a) = R(a).singleton_class
OP_TCLASS'	B	R(a) = target_class
OP_ERR'	B	raise(RuntimeError, Lit(Bx))
OP_EXT1	-	make 1st operand 16bit
OP_EXT2	-	make 2nd operand 16bit
OP_EXT3	-	make 1st and 2nd operands 16bit
OP_STOP	-	stop VM