Lua源码分析(原创)[持续更新中]

关于Lua源码的基础型别、内存分配、字符串存储、垃圾回收机制、table原理等部分讲解，我发现有位仁兄写得相当之好，强烈推荐大家先认真阅读下面这篇文章，链接如下：

http://simohayha.iteye.com/blog/517748

本文将只对Lua的字节码和虚拟机的运行相关内容做重点分析

LUA OPCODE格式分析：

Lopcodes.c

Lua Opcode的格式关键在下面这个宏:

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

如图，第0~1bit为m位, 2~3bit 为c位,4~5 bit为b位，6bit为a位，7bit为t位

t,a,b,c,m四部分，一起组成1 byte的opcode。下面依次分析下t,a,b,c,m各自扮演什么角色。

lua所有指令编码都在下面这个结构中 ：

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 */

 ......(此处略去78行，有需要请参考附录A LUA OPCODE一览)

 ,opmode(0, 1, OpArgU, OpArgN, iABC)        /* OP_VARARG */

};

enum OpArgMask {

  OpArgN,  /* 参数未被使用 */

  OpArgU,  /* 已使用参数 */

  OpArgR,  /* 该参数是寄存器或跳转偏移 */

  OpArgK   /* 该参数是个常量或寄存器常量， K乃const之意 */

};

结合上面定义以及源码注释，不难分析出如下结论:

LUA 指令格式分析：

任意一条指令由操作码(opcode)和操作数组成。

上一章主要对操作码的格式进行了分析，下面来整体分析下Lua中单条指令的格式。

Lua中单条指令为32位，依参数的类型和个数不同，有三种模式:

高    ------------------------->  低

iABC:

iABx:

iAsBx:

三种模式中i表示6位的opcode，iABC表示三个参数的指令，iABx将iABC中的B和C合并为18位的无符号数，

iAsBx将iABC中的B和C合并为18位的有符号数。

相关元素SIZE和POS定义如下：

#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

附录A

LUA OPCODE一览：

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 */

 ,opmode(0, 1, OpArgU, OpArgU, iABC)        /* OP_LOADBOOL */

 ,opmode(0, 1, OpArgR, OpArgN, iABC)        /* OP_LOADNIL */

 ,opmode(0, 1, OpArgU, OpArgN, iABC)        /* OP_GETUPVAL */

 ,opmode(0, 1, OpArgK, OpArgN, iABx)        /* OP_GETGLOBAL */

 ,opmode(0, 1, OpArgR, OpArgK, iABC)        /* OP_GETTABLE */

 ,opmode(0, 0, OpArgK, OpArgN, iABx)        /* OP_SETGLOBAL */

 ,opmode(0, 0, OpArgU, OpArgN, iABC)        /* OP_SETUPVAL */

 ,opmode(0, 0, OpArgK, OpArgK, iABC)        /* OP_SETTABLE */

 ,opmode(0, 1, OpArgU, OpArgU, iABC)        /* OP_NEWTABLE */

 ,opmode(0, 1, OpArgR, OpArgK, iABC)        /* OP_SELF */

 ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_ADD */

 ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_SUB */

 ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_MUL */

 ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_DIV */

 ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_MOD */

 ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_POW */

 ,opmode(0, 1, OpArgR, OpArgN, iABC)        /* OP_UNM */

 ,opmode(0, 1, OpArgR, OpArgN, iABC)        /* OP_NOT */

 ,opmode(0, 1, OpArgR, OpArgN, iABC)        /* OP_LEN */

 ,opmode(0, 1, OpArgR, OpArgR, iABC)        /* OP_CONCAT */

 ,opmode(0, 0, OpArgR, OpArgN, iAsBx)       /* OP_JMP */

 ,opmode(1, 0, OpArgK, OpArgK, iABC)        /* OP_EQ */

 ,opmode(1, 0, OpArgK, OpArgK, iABC)        /* OP_LT */

 ,opmode(1, 0, OpArgK, OpArgK, iABC)        /* OP_LE */

 ,opmode(1, 1, OpArgR, OpArgU, iABC)        /* OP_TEST */

 ,opmode(1, 1, OpArgR, OpArgU, iABC)        /* OP_TESTSET */

 ,opmode(0, 1, OpArgU, OpArgU, iABC)        /* OP_CALL */

 ,opmode(0, 1, OpArgU, OpArgU, iABC)        /* OP_TAILCALL */

 ,opmode(0, 0, OpArgU, OpArgN, iABC)        /* OP_RETURN */

 ,opmode(0, 1, OpArgR, OpArgN, iAsBx)       /* OP_FORLOOP */

 ,opmode(0, 1, OpArgR, OpArgN, iAsBx)       /* OP_FORPREP */

 ,opmode(1, 0, OpArgN, OpArgU, iABC)        /* OP_TFORLOOP */

 ,opmode(0, 0, OpArgU, OpArgU, iABC)        /* OP_SETLIST */

 ,opmode(0, 0, OpArgN, OpArgN, iABC)        /* OP_CLOSE */

 ,opmode(0, 1, OpArgU, OpArgN, iABx)        /* OP_CLOSURE */

 ,opmode(0, 1, OpArgU, OpArgN, iABC)        /* OP_VARARG */

};

typedef enum {

/*----------------------------------------------------------------------

name        args    description

------------------------------------------------------------------------*/

OP_MOVE,/*  A B R(A) := R(B)                    */

OP_LOADK,/* A Bx    R(A) := Kst(Bx)                 */

OP_LOADBOOL,/*  A B C   R(A) := (Bool)B; if (C) pc++            */

OP_LOADNIL,/*   A B R(A) := ... := R(B) := nil          */

OP_GETUPVAL,/*  A B R(A) := UpValue[B]              */

OP_GETGLOBAL,/* A Bx    R(A) := Gbl[Kst(Bx)]                */

OP_GETTABLE,/*  A B C   R(A) := R(B)[RK(C)]             */

OP_SETGLOBAL,/* A Bx    Gbl[Kst(Bx)] := R(A)                */

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_DIV,/*   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_UNM,/*   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,/*   sBx pc+=sBx                 */

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,/*   A sBx   R(A)+=R(A+2);

            if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/

OP_FORPREP,/*   A sBx   R(A)-=R(A+2); pc+=sBx               */

OP_TFORLOOP,/*  A C R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));

                        if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++   */

OP_SETLIST,/*   A B C   R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B    */

OP_CLOSE,/* A   close all variables in the stack up to (>=) R(A)*/

OP_CLOSURE,/*   A Bx    R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))  */

OP_VARARG/* A B R(A), R(A+1), ..., R(A+B-1) = vararg        */

} OpCode;