承接上篇虚拟机概述,解析函数执行流程。

数据结构与栈:

每个Lua 虚拟机对应一个 lua_State 结构体,它使用 TValue 数组来模拟栈,其中包括几个与栈相关的成员:

  • stack:栈数组的起始位置
  • base:当前函数栈的基地址
  • top:当前栈的下一个可用位置

这些成员的初始化操作在 stack_init 函数中完成。

然而 lua_State 里面存放的是一个 lua 虚拟机的全局状态,当执行到一个函数时,需要有对应的数据结构来表示函数相关的信息,这个数据结构就是 CallInfo,这个结构体中同样有 top、base这两个与栈相关的成员。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
** Information about a call.
** When a thread yields, 'func' is adjusted to pretend that the
** top function has only the yielded values in its stack; in that
** case, the actual 'func' value is saved in field 'extra'.
** When a function calls another with a continuation, 'extra' keeps
** the function index so that, in case of errors, the continuation
** function can be called with the correct top.
*/
typedef struct CallInfo {
StkId func; /* function index in the stack */
StkId top; /* top for this function */
struct CallInfo *previous, *next; /* dynamic call link */
union {
struct { /* only for Lua functions */
StkId base; /* base for this function */
const Instruction *savedpc;
} l;
struct { /* only for C functions */
lua_KFunction k; /* continuation in case of yields */
ptrdiff_t old_errfunc;
lua_KContext ctx; /* context info. in case of yields */
} c;
} u;
ptrdiff_t extra;
short nresults; /* expected number of results from this function */
lu_byte callstatus;
} CallInfo;

在 lua_State 中,有一个 base_ci 的 CallInfo 数组,存储的就是 CallInfo 的信息,而另一个 ci 成员,指向的就是当前函数的 CallInfo 指针。

在调用函数之前,一般会调用 luaD_precall 函数:

  1. 保存当前虚拟机执行的指令 savedpc 到当前 CallInfo 的 savedpc 中。此处保存下来是为了后面调用完毕之后恢复执行。
  2. 分别计算出待调用函数的 base、top 值,这些值的计算依赖于函数的参数数量。
  3. 从 lua_State 的 base_ci 数组中分配一个新的 CallInfo 指针,存储前面两步计算出来的信息,切换到这个函数准备调用。

指令的解析:

首先,分析阶段要用到的数据结构是 FuncState。这个结构体用于在语法分析时保存解析函数之后相关的信息,根据其中的 prev 指针成员来串联起来。对于下面的 Lua 代码:

1
2
3
4
5
-- 最外层 FuncState fs1
local function a() -- 函数 a 的 FuncState fsa
local function b() -- 函数 b 的 FuncState fsb
end
end

涉及到三个 FuncState 指针,一层一层嵌套包围,其中fs1是 fsa 的父指针:

在 FuncState 结构体中,有一个成员 Proto *f,它用来保存这个 FuncState 解析指令后生成的指令,其中除了自己的,还包括内部嵌套的子函数的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/* state needed to generate code for a given function */
typedef struct FuncState {
Proto *f; /* current function header */
struct FuncState *prev; /* enclosing function */
struct LexState *ls; /* lexical state */
struct BlockCnt *bl; /* chain of current blocks */
int pc; /* next position to code (equivalent to 'ncode') */
int lasttarget; /* 'label' of last 'jump label' */
int jpc; /* list of pending jumps to 'pc' */
int nk; /* number of elements in 'k' */
int np; /* number of elements in 'p' */
int firstlocal; /* index of first local var (in Dyndata array) */
short nlocvars; /* number of elements in 'f->locvars' */
lu_byte nactvar; /* number of active local variables */
lu_byte nups; /* number of upvalues */
lu_byte freereg; /* first free register */
} FuncState;

各个层次的 Proto 数据是逐层包含的,因此最外层的全局 FuncState 结构体中的 Proto 数组一定有这个全局结构中所有 Proto 的信息,也就是解析完毕之后的指令信息。

而 luaY_parser 这个函数,它是分析阶段的唯一入口函数,这个函数的返回值就是 Proto 指针,而 FuncState 等数据结构仅是用于分析过程中的临时数据结构,它们最终都是为了解析代码生成指令到 Proto 结构体服务的。

Proto 结构体:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
** Function Prototypes
*/
typedef struct Proto {
CommonHeader;
lu_byte numparams; /* number of fixed parameters */
lu_byte is_vararg;
lu_byte maxstacksize; /* maximum stack used by this function */
int sizeupvalues; /* size of 'upvalues' */
int sizek; /* size of 'k' */
int sizecode;
int sizelineinfo;
int sizep; /* size of 'p' */
int sizelocvars;
int linedefined;
int lastlinedefined;
TValue *k; /* constants used by the function 函数使用的常量(数组) */
Instruction *code; /* 保存分析之后生成的 OpCode 数组 */
struct Proto **p; /* functions defined inside the function 函数内定义的函数 */
int *lineinfo; /* map from opcodes to source lines (debug information) */
LocVar *locvars; /* information about local variables (debug information) 局部变量的数组(调试信息) */
Upvaldesc *upvalues; /* upvalue information 保存 upvalue 的数组 */
struct LClosure *cache; /* last created closure with this prototype */
TString *source; /* used for debug information */
GCObject *gclist;
} Proto;

指令格式:

lua 虚拟机的指令格式:

operation.png
operation.png

首先,Lua 的指令是 32 位的:

  • Opcode:操作数
  • A、B、C:参数

不同操作数的指令格式不同、含义不同。操作数是 6 位的,所以 Lua 最多支持 2^6-1 = 31 个指令。Lua 代码中,将每个操作数及其对应的指令格式都在 lopcodes.h 中的 OpCode 枚举类型中定义。

Lua 虚拟机指令中有着不同的参数:

格式 说明
R(A) A参数作为寄存器索引,R(B)、R(C)依此类推
pc 程序计数器,这个数据用于指示当前指令的地址
Kst(n) 常量数组中的第n个数据
Upvalue(n) upvalue 数组中的第 n 个数据
Gbl[sym] 全局符号表中取名为 sym 的数据
RK(B) B 可能是寄存器索引,也可能是常量数组索引,RK(C)类似
sBx 有符号整数,用于表示跳转偏移量

在lopcodes.h 文件中还定义了每个指令的格式,以及相关的宏;这里定义了在一个指令中每个参数对应的大小和位置。

RK(B)的意思有两层,一是这个指令格式只可能作用在 OpCode 的 B、C 参数上,不会作用在参数 A 上;二是这个数据除了从函数栈获取之外,还有可能从常量数组中获取,关键在于宏 ISK 的判断。

1
2
/* test whether value is a constant */
#define ISK(x) ((x) & BITRK)

判断这个数据的第 8 位是不是 1,如果是,则认为应该从 K 数组获取数据,否则就是从函数栈寄存器中获取数据。

从寄存器中取指令是在以 R 开头的宏中,实际代码中会使用一个 base 再加上对应的地址,base 值保存的是函数栈基址:

1
2
3
4
#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))

指令的执行:

指令执行的入口函数是 luaV_execute:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void luaV_execute (lua_State *L) {
CallInfo *ci = L->ci;
LClosure *cl;
TValue *k;
StkId base;
newframe: /* reentry point when frame changes (call/return) */
lua_assert(ci == L->ci);
cl = clLvalue(ci->func);
k = cl->p->k;
base = ci->u.l.base;
/* main loop of interpreter */
for (;;) {
Instruction i = *(ci->u.l.savedpc++);
StkId ra;
if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
(--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
Protect(luaG_traceexec(L));
}
/* WARNING: several calls may realloc the stack and invalidate 'ra' */
ra = RA(i);
lua_assert(base == ci->u.l.base);
lua_assert(base <= L->top && L->top < L->stack + L->stacksize);
  • ci:用于保存当前指令的执行位置(以及一些其他信息,包括动态调用链的双向链表)
  • cl:当前所在的函数环境
  • base:当前函数环境的栈 base 地址
  • k:当前函数环境的常量数组

总结:

  1. 分析阶段最后的结果就是Proto结构体。在这个结构体中,code成员用于存储指令,f数组用于保存里面嵌套的函数的Proto结构体。
  2. 每个环境都有自己对应的栈,base指向这个栈的基地址,top指向这个栈的栈顶地址。取函数栈内的数据,都是以base基地址为基础地址的操作。
  3. 在虚拟机开始执行指令之前,需要把对应的指令和栈地址切换到所要执行的函数的数据上。

参考:

  1. 《Lua设计与实现》(codedump 著)
  2. Lua 源码解析