lua虚拟机笔记

OGeek|极客世界-中国程序员成长平台 › 门户 › 编程› LUA›LUA教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

1.opcode

lua代码执行过程是：源代码先被编译成为字节码，然后虚拟机解释执行。相关模块是lopcode.c,lvm.c。lua的字节码类似汇编，也有pc寄存器这个概念，指向下一条要执行的指令，lua里面每一条指令由无符号数表示，低六位代表opcode，指示这是条什么指令（例如OP_MOVE, OP_ADD,...）。剩下的位主要是给操作数用的，像汇编中一样，lua指令的操作数也可以有不同的寻址方式，但是lua简单很多，主要是根据不同的操作指令变化，分三种模式：

| 31 ~ 23 bit | 22 ~ 14 bit | 13 ~ 6 bit | 5 ~ 0 bit |

| C | B | A | OPCODE |

| Bx | A | OPCODE |

| sBx | A | OPCODE |

三种模式分别叫 iABC, iABx, iAsBx。

lopcode.c中只有两个数组定义，数组luaP_opnames是opcode数值对应opcode名字的一个映射表，luaP_opmodes是opcode对应相应操作模式的一个映射表，虚拟机肯定会先取出当前指令的opcode，再在luaP_opmodes找到对应操作模式，根据模式去不同地方取操作数。

看下每一个模式是怎么定义的：

#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))

const lu_byte luaP_opmodes[NUM_OPCODES] = {
/*       T A    B       C     mode             opcode     */
opmode(0, 1, OpArgR, OpArgN, iABC)           /* OP_MOVE */
,opmode(0, 1, OpArgK, OpArgN, iABx)          /* OP_LOADK */
...

}

每一个操作模式都是一个字节表示,各位表示的意思lopcodes.h有说明：

/*
** masks for instruction properties. The format is:
** bits 0-1: op mode
** bits 2-3: C arg mode
** bits 4-5: B arg mode
** bit 6: instruction set register A
** bit 7: operator is a test
*/

enum OpArgMask {
OpArgN, /* argument is not used */
OpArgU, /* argument is used */
OpArgR, /* argument is a register or a jump offset */
OpArgK /* argument is a constant or register/constant */
};

简单解释如下：

0~1：这个操作本身对应模式的枚举值，上面说了只有三个枚举值；

2~3：操作数C的模式，主要有四种模式，OpArgN，OpArgU，OpArgR，OpArgK

4~5: 操作数B的模式

6: 操作数A是否被使用，1被使用，0没有

7：这条指令是否是判定指令，为什么要这一位，因为跳转时，跳转地址已经无法在一条指令里装下，所以lua里面就用两条指令来表示了，第一条判断指令，第二条无条件跳转指令，比如OP_EQ，如果判断成功，PC加1，否则跳转。

lopcodes.h里面定义了一系列的宏操作，方便取指令中的opcode，操作数，代码如下：

...

...
/*
** size and position of opcode arguments.
*/
#define SIZE_C          9
#define SIZE_B          9
#define SIZE_Bx          (SIZE_C + SIZE_B)
#define SIZE_A          8

#define SIZE_OP          6

#define POS_OP          0
#define POS_A          (POS_OP + SIZE_OP)
#define POS_C          (POS_A + SIZE_A)
#define POS_B          (POS_C + SIZE_C)
#define POS_Bx          POS_C

...

/* creates a mask with `n' 1 bits at position `p' */
#define MASK1(n,p) ((~((~(Instruction)0)<<n))<<p)

/* creates a mask with `n' 0 bits at position `p' */
#define MASK0(n,p) (~MASK1(n,p))

...

...

/*
** the following macros help to manipulate instructions
*/

#define GET_OPCODE(i)     (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
#define SET_OPCODE(i,o)     ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
          ((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))

#define GETARG_A(i)     (cast(int, ((i)>>POS_A) & MASK1(SIZE_A,0)))
#define SETARG_A(i,u)     ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
          ((cast(Instruction, u)<<POS_A)&MASK1(SIZE_A,POS_A))))

#define GETARG_B(i)     (cast(int, ((i)>>POS_B) & MASK1(SIZE_B,0)))
#define SETARG_B(i,b)     ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
          ((cast(Instruction, b)<<POS_B)&MASK1(SIZE_B,POS_B))))

#define GETARG_C(i)     (cast(int, ((i)>>POS_C) & MASK1(SIZE_C,0)))
#define SETARG_C(i,b)     ((i) = (((i)&MASK0(SIZE_C,POS_C)) | \
          ((cast(Instruction, b)<<POS_C)&MASK1(SIZE_C,POS_C))))

#define GETARG_Bx(i)     (cast(int, ((i)>>POS_Bx) & MASK1(SIZE_Bx,0)))
#define SETARG_Bx(i,b)     ((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \
          ((cast(Instruction, b)<<POS_Bx)&MASK1(SIZE_Bx,POS_Bx))))

#define GETARG_sBx(i)     (GETARG_Bx(i)-MAXARG_sBx)
#define SETARG_sBx(i,b)     SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))

...

这里说下为什么 GETARG_sBx(i) (GETARG_Bx(i)-MAXARG_sBx)？其实lopcodes.h里面有说

/*===========================================================================
We assume that instructions are unsigned numbers.
All instructions have an opcode in the first 6 bits.
Instructions can have the following fields:
     `A' : 8 bits
     `B' : 9 bits
     `C' : 9 bits
     `Bx' : 18 bits (`B' and `C' together)
     `sBx' : signed Bx

A signed argument is represented in excess K; that is, the number
value is the unsigned value minus K. K is exactly the maximum value
for that argument (so that -max is represented by 0, and +max is
represented by 2*max), which is half the maximum for the corresponding
unsigned argument.
===========================================================================*/

MAXARG_sBx正好是18bits的Bx能表示的最大数的一半，可以去看代码。

还有取对应opcode的mode的宏定义：

#define getOpMode(m)     (cast(enum OpMode, luaP_opmodes[m] & 3))
#define getBMode(m)     (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
#define getCMode(m)     (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
#define testAMode(m)     (luaP_opmodes[m] & (1 << 6))
#define testTMode(m)     (luaP_opmodes[m] & (1 << 7))

这些宏定义在lvm.c里面用了很多，看下在lvm.c里面定义的取操作数的值：

#define RA(i)     (base+GETARG_A(i))
/* to be used after possible stack reallocation */
#define RB(i)     check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
#define RC(i)     check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))
#define RKB(i)     check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \
     ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))
#define RKC(i)     check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \
     ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
#define KBx(i)     check_exp(getBMode(GET_OPCODE(i)) == OpArgK, k+GETARG_Bx(i))

RA,RB,RC，是在寄存器取相应操作数，但是这里的寄存器其实就是lua的栈，指令保存的其实操作数相对函数栈base上的偏移，所以取出来都是这样 base + GETARG_X;

RKB,RKC, 是操作数或者在寄存器中，或者就是一个常数。例如对于操作数B，当B的最高位是1，代表其是一个常数，否则代表其是寄存器变量；

KBx，操作数Bx就是常数；

总的来说，一条指令包含操作数（A,B,C)和操作符(opcode), 每一个opcode预定义了mode，mode包含操作数的取值fan

2.虚拟机是如何解释指令的

*例如简单的OP_ADD:

虚拟机解释指令的过程主要在lvm.c函数luaC_execute中,先略去次要的内容

void luaV_execute(lua_State *L, int nexeccalls) {

...

for (;;) {

const Instruction i = *pc++; // 取下一条指令到i中

...

swith (GET_OPCODE(i)) {

...

case OP_ADD: { arith_op(luai_numadd, TM_ADD);

continue;

...

}

#define arith_op(op,tm) { \
        TValue *rb = RKB(i); \ \\ 取操作数B
        TValue *rc = RKC(i); \ \\ 取操作数C
        if (ttisnumber(rb) && ttisnumber(rc)) { \
          lua_Number nb = nvalue(rb), nc = nvalue(rc); \
          setnvalue(ra, op(nb, nc)); \ \\相加赋给操作数A
        } \
        else \
          Protect(Arith(L, ra, rb, rc, tm)); \
      }

*稍微复杂点的是跳转指令，例如OP_EQ

case OP_EQ: {
        TValue *rb = RKB(i);
        TValue *rc = RKC(i);
        Protect(
          if (equalobj(L, rb, rc) == GETARG_A(i))
            dojump(L, pc, GETARG_sBx(*pc)); // pc += GETARG_sBx(*pc)

        )
        pc++;
        continue;

正如之前所说，跳转指令涉及到两条指令，下一条指令代表跳转的偏移值（GETARG_sBx(*pc) 可正可负), 如果满足判定条件，则跳转，不满足则继续执行（只是跳过下一条指令）。

3.栈结构

....

top

...

base

func

....

lua_State这个结构中保存了一些函数调用栈的信息，每次一个函数被调用执行前，都会去初始化lua_State的一些成员，比如C调用lua函数的API : lua_call,

整个流程是lua_call -----> luaD_call --------> luaV_execute, 就是在luaD_call的luaD_precall初始化lua_State的.

void luaD_call (lua_State *L, StkId func, int nResults) {
if (++L->nCcalls >= LUAI_MAXCCALLS) {
    if (L->nCcalls == LUAI_MAXCCALLS)
      luaG_runerror(L, "C stack overflow");
    else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
      luaD_throw(L, LUA_ERRERR); /* error while handing stack error */
}
if (luaD_precall(L, func, nResults) == PCRLUA) /* is a Lua function? */
    luaV_execute(L, 1); /* call it */
L->nCcalls--;
luaC_checkGC(L);
}

总的来说指令都是在操作该函数栈上的操作数。

4.指令数据从何而来

指令当然是编译出来的，看下luaL_dofile的调用栈就能了解这个流程了：

luaL_dofile ---->luaL_loadfile ----> lua_load -----> luaY_parser

编译的过程是先读源码文件, 然后解析创建一个函数原型(Proto),函数原型就是包含了所有指令,编译工作主要在

luaY_parser中：

Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
struct LexState lexstate;
struct FuncState funcstate;
lexstate.buff = buff;
luaX_setinput(L, &lexstate, z, luaS_new(L, name));
open_func(&lexstate, &funcstate); // 创建Proto，并作初始化工作
funcstate.f->is_vararg = VARARG_ISVARARG; /* main func. is always vararg */
luaX_next(&lexstate); /* read first token */
chunk(&lexstate); // 词法,语法分析，如果有词法语法错误，这里会报错
check(&lexstate, TK_EOS);
close_func(&lexstate);
lua_assert(funcstate.prev == NULL);
lua_assert(funcstate.f->nups == 0);
lua_assert(lexstate.fs == NULL);
return funcstate.f;
}