• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

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;
}






鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
Centos7环境下搭建Nginx+Lua+Redis进行数据存取发布时间:2022-07-22
下一篇:
Openrestry+Lua之静态文件鉴权发布时间:2022-07-22
热门推荐
热门话题
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap