【Lua 5.3源码】虚拟机指令分析(一)

1. Lua虚拟机简介

Lua VM 使用的是 基于寄存器的虚拟机(Register-based)。 指令都是在已经分配好的寄存器中存取操作数。
add a b c 将 寄存器 b 与 寄存器 c 中的值相加，结果存在 寄存器 a 中。 标准的三地址指令，每条指令的表达能力很强，并有效的减少了内存赋值操作。

ADD C,A,B  //将A,B寄存器里面的值相加后赋值给C寄存器

除此之外还有一种虚拟机是基于堆栈的虚拟机(Stack-based)。指令都是通过在栈中取数据，所以这类虚拟机在执行指令的时候都会伴随着数据的入栈和出栈。

ILOAD A    //将A入栈
ILOAD B    //将B入栈
IADD       //将栈顶两个元素弹出并相加，结果入栈
ISTORE C   //将栈顶弹出赋值给C

由此可见

• 基于堆栈的虚拟机的指令比基于寄存器的指令要小，因为在指令中不需要指定操作数。基于堆栈的虚拟机使用堆栈来保存中间结果、变量等。
• 基于寄存器的虚拟机则支持寄存器的指令操作。基于堆栈的虚拟机需要用Push 、Pop 来传送数据，通常，完成同样的工作，基于寄存器的虚拟机所采用的指令数比基于堆栈的虚拟机采用的指令数目少，可以提高执行效率。
• 堆栈虚拟机指令很低级，基于寄存器的处理器有更强大的指令功能，而且易于调试。 基于堆栈的处理器在处理函数调用、解决递归问题和切换上下文时简单明快。
• 采用寄存器架构时，虚拟机需要经常保存和恢复寄存器中的内容，还要考虑对操作数的寻址问题等，因此，基于堆栈的虚拟机实现起来更简单，基于寄存器的虚拟机能提供更强大的指令集。

下面是Lua虚拟机的一个体系结构简图：

如图所示，实际上虚拟机在执行某个函数原型Proto的时候使用的寄存器R[0]~R[n]对应的还是编译阶段预先分配好的栈空间。只是虚拟机在解释过程中当做了寄存器使用。除了寄存器每个Proto还对应有其解析的instruct指令、constan常量、以及外部的upvalue。

2. Lua虚拟机指令简介

在lua中，用32位的unsigned int类型来表示一条指令操作码，32位值包含了6位的操作码和26位的指令字段两部分内容。

26(高位)	6(低位)
Instructions	Opcode

2.1 指令操作码

6位的操作码，所以最多支持 $2^6$ 条指令，在Lua5.3中指令数量为47。我们可以在lopcodes.h文件中可以找到指令的定义：

/*
** R(x) - register
** Kst(x) - constant (in constant table)
** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
*/

typedef enum {
   

/*----------------------------------------------------------------------
name		args	description
------------------------------------------------------------------------*/
OP_MOVE,/*	A B	R(A) := R(B)					*/
OP_LOADK,/*	A Bx	R(A) := Kst(Bx)					*/
OP_LOADKX,/*	A 	R(A) := Kst(extra arg)				*/
OP_LOADBOOL,/*	A B C	R(A) := (Bool)B; if (C) pc++			*/
OP_LOADNIL,/*	A B	R(A), R(A+1), ..., R(A+B) := nil		*/
OP_GETUPVAL,/*	A B	R(A) := UpValue[B]				*/
OP_GETTABUP,/*	A B C	R(A) := UpValue[B][RK(C)]			*/
OP_GETTABLE,/*	A B C	R(A) := R(B)[RK(C)]				*/
OP_SETTABUP,/*	A B C	UpValue[A][RK(B)] := RK(C)			*/
OP_SETUPVAL,/*	A B	UpValue[B] := R(A)				*/
OP_SETTABLE,/*	A B C	R(A)[RK(B)] := RK(C)				*/
OP_NEWTABLE,/*	A B C	R(A) := {} (size = B,C)				*/
OP_SELF,/*	A B C	R(A+1) := R(B); R(A) := R(B)[RK(C)]		*/
OP_ADD,/*	A B C	R(A) := RK(B) + RK(C)				*/
OP_SUB,/*	A B C	R(A) := RK(B) - RK(C)				*/
OP_MUL,/*	A B C	R(A) := RK(B) * RK(C)				*/
OP_MOD,/*	A B C	R(A) := RK(B) % RK(C)				*/
OP_POW,/*	A B C	R(A) := RK(B) ^ RK(C)				*/
OP_DIV,/*	A B C	R(A) := RK(B) / RK(C)				*/
OP_IDIV,/*	A B C	R(A) := RK(B) // RK(C)				*/
OP_BAND,/*	A B C	R(A) := RK(B) & RK(C)				*/
OP_BOR,/*	A B C	R(A) := RK(B) | RK(C)				*/
OP_BXOR,/*	A B C	R(A) := RK(B) ~ RK(C)				*/
OP_SHL,/*	A B C	R(A) := RK(B) << RK(C)				*/
OP_SHR,/*	A B C	R(A) := RK(B) >> RK(C)				*/
OP_UNM,/*	A B	R(A) := -R(B)					*/
OP_BNOT,/*	A B	R(A) := ~R(B)					*/
OP_NOT,/*	A B	R(A) := not R(B)				*/
OP_LEN,/*	A B	R(A) := length of R(B)				*/
OP_CONCAT,/*	A B C	R(A) := R(B).. ... ..R(C)			*/
OP_JMP,/*	A sBx	pc+=sBx; if (A) close all upvalues >= R(A - 1)	*/
OP_EQ,/*	A B C	if ((RK(B) == RK(C)) ~= A) then pc++		*/
OP_LT,/*	A B C	if ((RK(B) <  RK(C)) ~= A) then pc++		*/
OP_LE,/*	A B C	if ((RK(B) <= RK(C)) ~= A) then pc++		*/
OP_TEST,/*	A C	if not (R(A) <=> C) then pc++			*/
OP_TESTSET,/*	A B C	if (R(B) <=> C) then R(A) := R(B) else pc++	*/
OP_CALL,/*	A B C	R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
OP_TAILCALL,/*	A B C	return R(A)(R(A+1), ... ,R(A+B-1))		*/
OP_RETURN,/*	A B	return R(A), ... ,R(A+B-2)	(see note)	*/
OP_FORLOOP