深入理解 Lua 虚拟机

语言: CN / TW / HK

作者:nicochen,腾讯 IEG 游戏开发工程师

本文从一个简单示例入手,详细讲解 Lua 字节码文件的存储结构及各字段含义,进而引出 Lua 虚拟机指令集和运行时的核心数据结构 Lua State,最后解释 Lua 虚拟机的 47 条指令如何在 Lua State 上运作的。

为了达到较高的执行效率,lua 代码并不是直接被 Lua 解释器解释执行,而是会先编译为字节码,然后再交给 lua 虚拟机去执行。lua 代码称为 chunk,编译成的字节码则称为二进制 chunk(Binary chunk)。lua.exe、wlua.exe 解释器可直接执行 lua 代码(解释器内部会先将其编译成字节码),也可执行使用 luac.exe 将 lua 代码预编译(Precompiled)为字节码。使用预编译的字节码并不会加快脚本执行的速度,但可以加快脚本加载的速度,并在一定程度上保护源代码。luac.exe 可作为编译器,把 lua 代码编译成字节码,同时可作为反编译器,分析字节码的内容。

luac.exe -v  // 显示luac的版本号
luac.exe Hello.lua  //
在当前目录下,编译得到Hello.lua的二进制chunk文件luac.out(默认含调试符号)

luac.exe -o Hello.out Hello1.lua Hello2.lua //
在当前目录下,编译得到Hello1.lua和Hello2.lua的二进制chunk文件Hello.out(默认含调试符号)

luac.exe -s -o d:\\Hello.out Hello.lua  //
编译得到Hello.lua的二进制chunk文件d:\\Hello.out(去掉调试符号)

luac.exe -p Hello1.lua Hello2.lua  //
对Hello1.lua和Hello2.lua只进行语法检测(注:只会检查语法规则,不会检查变量、函数等是否定义和实现,函数参数返回值是否合法)

lua 编译器以函数为单位对源代码进行编译,每个函数会被编译成一个称之为原型(Prototype)的结构,原型主要包含 6 部分内容:函数基本信息(basic info,含参数数量、局部变量数量等信息)、字节码(bytecodes)、常量(constants)表、upvalue(闭包捕获的非局部变量)表、调试信息(debug info)、子函数原型列表(sub functions)。

原型结构使用这种嵌套递归结构,来描述函数中定义的子函数:

注:lua 允许开发者可将语句写到文件的全局范围中,这是因为 lua 在编译时会将整个文件放到一个称之为 main 函数中,并以它为起点进行编译。

Hello.lua 源代码如下:

print ("hello")
function add(a, b)
    return a+b
end

编译得到的 Hello.out 的二进制为:

二进制 chunk(Binary chunk)的格式并没有标准化,也没有任何官方文档对其进行说明,一切以 lua 官方实现的源代码为准。其设计并没有考虑跨平台,对于需要超过一个字节表示的数据,必须要考虑大小端(Endianness)问题。

lua 官方实现的做法比较简单:编译 lua 脚本时,直接按照本机的大小端方式生成二进制 chunk 文件,当加载二进制 chunk 文件时,会探测被加载文件的大小端方式,如果和本机不匹配,就拒绝加载。二进制 chunk 格式设计也没有考虑不同 lua 版本之间的兼容问题,当加载二进制 chunk 文件时,会检测其版本号,如果和当前 lua 版本不匹配,就拒绝加载。另外,二进制 chunk 格式设计也没有被刻意设计得很紧凑。在某些情况下,一段 lua 代码编译成二进制 chunk 后,甚至会被文本形式的源代码还要大。预编译成二进制 chunk 主要是为了提升加载速度,因此这也不是很大的问题。

头部字段:

嵌套的函数原型:

注 1:二进制 chunk 中的字符串分为三种情况:

①NULL 字符串用 0x00 表示;

② 长度小于等于 253(0xFD)的字符串,先用 1 个 byte 存储字符串长度+1 的数值,然后是字节数组;

③ 长度大于等于 254(0xFE)的字符串,第一个字节是 0xFF,后面跟一个 8 字节 size_t 类型存储字符串长度+1 的数值,然后是字节数组。

注 2:常量 tag 对应表

查看二进制 chunk 中的所有函数(精简模式):

luac.exe -l Hello.lua
luac.exe -l Hello.out

注 1:每个函数信息包括两个部分:前面两行是函数的基本信息,后面是函数的指令列表。

注 2:函数的基本信息包括:函数名称、函数的起始行列号、函数包含的指令数量、函数地址。函数的参数 params 个数(0+表示函数为不固定参数)、寄存器 slots 数量、upvalue 数量、局部变量 locals 数量、常量 constants 数量、子函数 functions 数量。

注 3:指令列表里的每一条指令包含指令序号、对应代码行号、操作码和操作数。分号后为 luac 生成的注释,以便于我们理解指令。

注 4:整个文件内容被放置到了 main 函数中,并以它作为嵌套起点。

查看二进制 chunk 中的所有函数(详细模式):

luac.exe -l -l Hello.lua   注:参数为 2 个-l
luac.exe -l -l Hello.out   注:详细模式下,luac 会把常量表、局部变量表和 upvalue 表的信息也打印出来
main <Test2.lua:0,0> (6 instructions at 0046e528)
0+ params, 2 slots, 1 upvalue, 0 locals, 3 constants, 1 function
        序号    代码行    指令
        1       [1]     GETTABUP        0 0 -1  ; _ENV "print"   //GETTABUP A B C  //将upvalues表索引为B:0的upvalue(即:_ENV)中key为常量表索引为C:-1的(即print),放到寄存器索引为A:0的地方
        2       [1]     LOADK           1 -2    ; "hello"  //LOADK A Bx  //将常量表索引为Bx:-2的hello加载到寄存器索引为A:1的地方
        3       [1]     CALL            0 2 1    ; //CALL A B C  //调用寄存器索引为A:0的函数,参数个数为B:2减1(即1个),C:1表示无返回值
        4       [5]     CLOSURE         0 0     ; 0046e728      //CLOSURE A Bx  //将子函数原型列表索引为Bx:0的函数地址,放到寄存器索引为A:0的地方
        5       [3]     SETTABUP        0 -3 0  ; _ENV "add"   //SETTABUP A B C  //将upvalues表索引为A:0的upvalue(即:_ENV)中key为常量表索引为B:-3(即add),设置为寄存器索引为C:0指向的值
        6       [5]     RETURN          0 1        ; //RETURN A B   //B:1表示无返回值
constants (3) for 0046e528:
        序号    常量名
        1       "print"
        2       "hello"
        3       "add"
locals (0) for 0046e528:
upvalues (1) for 0046e528:
        序号    upvalue名    是否为直接外围函数的局部变量    在外围函数调用帧的索引
        0       _ENV        1                               0

function <Test2.lua:3,5> (3 instructions at 0046e728)
2 params, 3 slots, 0 upvalues, 2 locals, 0 constants, 0 functions
        序号    代码行    指令
        1       [4]     ADD             2 0 1    ; //ADD A B C  //将寄存器索引为0、1的两个数相加得到的结果放到寄存器索引为2的地方
        2       [4]     RETURN          2 2        ; //RETURN A B //B:2表示有一个返回值  A:2表示返回值在寄存器索引为2的地方
        3       [5]     RETURN          0 1        ; //RETURN A B //B:1表示无返回值
constants (0) for 0046e728:
locals (2) for 0046e728:
    寄存器索引    起始指令序号  终止指令序号  -1得到实际指令序号
        0       a       1       4        ; a变量的指令范围为[0, 3],起始为0表示为传入的参数变量
        1       b       1       4        ; b变量的指令范围为[0, 3]
upvalues (0) for 0046e728:
luac.exe -l -  // 从标准设备读入脚本,输完后按回车,然后按 Ctrl+Z 并回车,会打印出输入内容对应的二进制 chunk 内容    注:进入输入模式后可按 Ctrl+C 强制退出
luac.exe -l -- // 使用上次输入,打印出二进制 chunk 内容
luac.exe -l -l -- // 使用上次输入,详细模式下打印出二进制 chunk 内容(参数为 2 个-l)

Stack Based VM  vs Rigister Based VM

高级编程语言的虚拟机是利用软件技术对硬件进行的模拟和抽象。按照实现方式,可分为两类:基于栈(Stack Based)和基于寄存器(Rigister Based)。Java、.NET CLR、Python、Ruby、Lua5.0 之前的版本的虚拟机都是基于栈的虚拟机;从 5.0 版本开始,Lua 的虚拟机改成了基于寄存器的虚拟机。

一个简单的加法赋值运算:a=b+c

基于栈的虚拟机,会转化成如下指令:

push b; // 将变量b的值压入stack

push c; // 将变量c的值压入stack

add; // 将stack顶部的两个值弹出后相加,然后将结果压入stack顶

mov a; // 将stack顶部结果放到a中

所有的指令执行,都是基于一个操作数栈的。你想要执行任何指令时,对不起,得先入栈,然后算完了再给我出栈。总的来说,就是抽象出了一个高度可移植的操作数栈,所有代码都会被编译成字节码,然后字节码就是在玩这个栈。好处是实现简单,移植性强。坏处是指令条数比较多,数据转移次数比较多,因为每一次入栈出栈都牵涉数据的转移。

基于寄存器的虚拟机,会转化成如下指令:

add a b c; // 将b与c对应的寄存器的值相加,将结果保存在a对应的寄存器中

没有操作数栈这一概念,但是会有许多的虚拟寄存器。这类虚拟寄存器有别于 CPU 的寄存器,因为 CPU 寄存器往往是定址的(比如 DX 本身就是能存东西),而寄存器式的虚拟机中的寄存器通常有两层含义:

(1)寄存器别名(比如 lua 里的 RA、RB、RC、RBx 等),它们往往只是起到一个地址映射的功能,它会根据指令中跟操作数相关的字段计算出操作数实际的内存地址,从而取出操作数进行计算;

(2)实际寄存器,有点类似操作数栈,也是一个全局的运行时栈,只不过这个栈是跟函数走的,一个函数对应一个栈帧,栈帧里每个 slot 就是一个寄存器,第 1 步中通过别名映射后的地址就是每个 slot 的地址。

好处是指令条数少,数据转移次数少。坏处是单挑指令长度较长。具体来看,lua 里的实际寄存器数组是用 TValue 结构的栈来模拟的,这个栈也是 lua 和 C 进行交互的虚拟栈。

lua 指令集

Lua 虚拟机的指令集为定长(Fixed-width)指令集,每条指令占 4 个字节(32bits),其中操作码(OpCode)占 6bits,操作数(Operand)使用剩余的 26bits。Lua5.3 版本共有 47 条指令,按功能可分为 6 大类:常量加载指令、运算符相关指令、循环和跳转指令、函数调用相关指令、表操作指令和 Upvalue 操作指令。

按编码模式分为 4 类:iABC(39)、iABx(3)、iAsBx(4)、iAx(1)

4 种模式中,只有 iAsBx 下的 sBx 操作数会被解释成有符号整数,其他情况下操作数均被解释为无符号整数。操作数 A 主要用来表示目标寄存器索引,其他操作数按表示信息可分为 4 种类型:OpArgN、OpArgU、OpArgR、OpArgK:

Lua 栈索引

注 1:绝对索引是从 1 开始由栈底到栈顶依次增长的;

注 2:相对索引是从-1 开始由栈顶到栈底依次递减的(在 lua API 函数内部会将相对索引转换为绝对索引);

注 3:上图栈的容量为 7,栈顶绝对索引为 5,有效索引范围为:[1,5],可接受索引范围为:[1, 7];

注 4:Lua 虚拟机指令里寄存器索引是从 0 开始的,而 Lua API 里的栈索引是从 1 开始的,因此当需要把寄存器索引当成栈索引使用时,要进行+1。

Lua State

指令表

下面是 Lua 的 47 条指令详细说明:

B:1 C A:3 MOVE

把源寄存器(索引由 B 指定)里的值移动到目标寄存器(索引有 A 指定),常用于局部变量赋值和参数传递。

公式:R(A) := R(B)

Bx:2 A:4 LOADK

给单个寄存器(索引由 A 指定)设置成常量(其在常量表的索引由 Bx 指定),将常量表里的某个常量加载到指定寄存器。

在 lua 中,数值型、字符串型等局部变量赋初始值 (数字和字符串会放到常量表中):

公式:R(A) := Kst(Bx)

Bx A:4 LOADKX

Ax:585028 EXTRAARG

LOADK 使用 Bx(18bits,最大无符号整数为 262143)表示常量表索引。当将 lua 作数据描述语言使用时,常量表可能会超过这个限制,为了应对这种情况,lua 提供了 LOADKX 指令。LOADKX 指令需要和 EXTRAAG 指令搭配使用,用后者的 Ax(26bits)操作数来指定常量索引。

公式:R(A) := Kst(Ax)

指令名称 类型 操作码 B C A
LOADBOOL iABC 0x03 OpArgU OpArgU 目标寄存器 idx

B:0 C:1 A:2 LOADBOOL

给单个寄存器(索引由 A 指定)设置布尔值(布尔值由 B 指定),如果寄存器 C 为非 0 则跳过下一条指令。

公式:

R(A) := (bool)B

if(C) pc++

指令名称 类型 操作码 B C A
LOADNIL iABC 0x04 OpArgU OpArgN 目标寄存器 idx

B:4 C A:0 LOADNIL

将序号[A,A+B]连续 B+1 个寄存器设置成 nil 值,用于给连续 n 个寄存器放置 nil 值。在 lua 中,局部变量的默认初始值为 nil,LOADNIL 指令常用于给连续 n 个局部变量设置初始值。

公式:R(A), R(A+1), ... ,R(A+B) := nil

指令名称 类型 操作码 B C A
GETUPVAL iABC 0x05 OpArgU OpArgN 目标寄存器 idx

B:1 C A:3 GETUPVAL

把当前闭包的某个 Upvalue 值(索引由 B 指定)拷贝到目标寄存器(索引由 A 指定)中  。

公式:R(A) := Upvalue[B]

指令名称 类型 操作码 B C A
GETTABUP iABC 0x06 OpArgU OpArgK 目标寄存器 idx

B:0 C:0x002 A:3 GETTABUP

把当前闭包的某个 Upvalue 值(索引由 B 指定)拷贝到目标寄存器(索引由 A 指定)中,与 GETUPVAL 不同的是,Upvalue 从表里取值(键由 C 指定,为寄存器或常量表索引)。

R(A) := Upvalue[B][rk(c)]

指令名称 类型 操作码 B C A
GETTABLE iABC 0x07 OpArgR OpArgK 目标寄存器 idx

B:0 C:0x002 A:3 GETTABLE

把表中某个值拷贝到目标寄存器(索引由 A 指定)中,表所在寄存器索引由 B 指定,键由 C(为寄存器或常量表索引)指定。

公式:R(A) := R[B][rk(c)]

指令名称 类型 操作码 B C A
SETTABUP iABC 0x08 OpArgK OpArgK 目标寄存器 idx

B:0x002 C:0x003 A:0 SETTABUP

设置当前闭包的某个 Upvalue 值(索引由 A 指定)为寄存器或常量表的某个值(索引由 C 指定),与 SETUPVAL 不同的是,Upvalue 从表里取值(键由 B 指定,为寄存器或常量表索引)。

Upvalue[A][rk(b)] := RK(C)

指令名称 类型 操作码 B C A
SETUPVAL iABC 0x09 OpArgU OpArgN 目标寄存器 idx

B:0 C A:3 SETUPVAL

设置当前闭包的某个 Upvalue 值(索引由 B 指定)为寄存器的某个值(索引由 A 指定)。

公式:Upvalue[B] := R(A)

指令名称 类型 操作码 B C A
SETTABLE iABC 0x0A OpArgK OpArgK 目标寄存器 idx

B:0x002 C:0x003 A:1 SETTABLE

给寄存器中的表(索引由 A 指定)的某个键进行赋值,键和值分别由 B 和 C 指定(为寄存器或常量表索引)。

公式:R(A)[RK(B)] := RK(C)

指令名称 类型 操作码 B C A
NEWTABLE iABC 0x0B OpArgU OpArgU 目标寄存器 idx

B:0 C:2 A:4 NEWTABLE

创建空表,并将其放入指定寄存器(索引有 A 指定),表的初始数组容量和哈希表容量分别有 B 和 C 指定。

公式:R(A) := {} (size = B, C)

指令名称 类型 操作码 B C A
SELF iABC 0x0C OpArgR OpArgK 目标寄存器 idx

B:1 C:0x100 A:2 SELF

把寄存器中对象(索引由 B 指定)和常量表中方法(索引由 C 指定)拷贝到相邻的两个目标寄存器中,起始目标寄存器的索引由 A 指定。

公式:

R(A+1) := R(B)

R(A) := R(B)[RK(C)]

指令名称 类型 操作码 B C A
ADD iABC 0x0D OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 ADD

对两个寄存器或常量值(索引由 B 和 C 指定)进行相加,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := RK(B) + RK(C)

指令名称 类型 操作码 B C A
SUB iABC 0x0E OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 SUB

对两个寄存器或常量值(索引由 B 和 C 指定)进行相减,并将结果放入另一个寄存器中(索引由 A 指定)

公式:

R(A) := RK(B) - RK(C)

指令名称 类型 操作码 B C A
MUL iABC 0x0F OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 MUL

对两个寄存器或常量值(索引由 B 和 C 指定)进行相乘,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := RK(B) * RK(C)

指令名称 类型 操作码 B C A
MOD iABC 0x10 OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 MOD

对两个寄存器或常量值(索引由 B 和 C 指定)进行求摸运算,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := RK(B) % RK(C)

指令名称 类型 操作码 B C A
POW iABC 0x11 OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 POW

对两个寄存器或常量值(索引由 B 和 C 指定)进行求幂运算,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := RK(B) ^ RK(C)

指令名称 类型 操作码 B C A
DIV iABC 0x12 OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 DIV

对两个寄存器或常量值(索引由 B 和 C 指定)进行相除,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := RK(B) / RK(C)

指令名称 类型 操作码 B C A
IDIV iABC 0x13 OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 IDIV

对两个寄存器或常量值(索引由 B 和 C 指定)进行相整除,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := RK(B) // RK(C)

指令名称 类型 操作码 B C A
BAND iABC 0x14 OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 BAND

对两个寄存器或常量值(索引由 B 和 C 指定)进行求与操作,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := RK(B) & RK(C)

指令名称 类型 操作码 B C A
BOR iABC 0x15 OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 BOR

对两个寄存器或常量值(索引由 B 和 C 指定)进行求或操作,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := RK(B) | RK(C)

指令名称 类型 操作码 B C A
BXOR iABC 0x16 OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 BXOR

对两个寄存器或常量值(索引由 B 和 C 指定)进行求异或操作,并将结果放入另一个寄存器中(索引由 A 指定)

公式:R(A) := RK(B) ~ RK(C)

指令名称 类型 操作码 B C A
SHL iABC 0x17 OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 SHL

索引由 B 指定的寄存器或常量值进行左移位操作(移动位数的索引由 C 指定的寄存器或常量值),并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := RK(B) << RK(C)

指令名称 类型 操作码 B C A
SHR iABC 0x18 OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:4 SHR

索引由 B 指定的寄存器或常量值进行右移位操作(移动位数的索引由 C 指定的寄存器或常量值),并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := RK(B) >> RK(C)

指令名称 类型 操作码 B C A
UNM iABC 0x19 OpArgR OpArgN 目标寄存器 idx

B:1 C A:3 UNM

对寄存器(索引由 B 指定)进行取负数操作,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := - R(B)

指令名称 类型 操作码 B C A
BNOT iABC 0x1A OpArgR OpArgN 目标寄存器 idx

B:1 C A:3 BNOT

对寄存器(索引由 B 指定)进行取反操作,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := ~ R(B)

指令名称 类型 操作码 B C A
NOT iABC 0x1B OpArgR OpArgN 目标寄存器 idx

B:1 C A:3 NOT

对寄存器(索引由 B 指定)进行求非操作,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := not R(B)

指令名称 类型 操作码 B C A
LEN iABC 0x1C OpArgR OpArgN 目标寄存器 idx

B:1 C A:3 LEN

对寄存器(索引由 B 指定)进行求长度操作,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := length of R(B)

指令名称 类型 操作码 B C A
CONCAT iABC 0x1D OpArgR OpArgR 目标寄存器 idx

B:2 C:4 A:1 CONCAT

将连续 n 个寄存器(起始索引和终止索引由 B 和 C 指定)里的值进行拼接,并将结果放入另一个寄存器中(索引由 A 指定)。

公式:R(A) := R(B) .. ... .. R(C)

指令名称 类型 操作码 sBx A
JMP iAsBx 0x1E OpArgR 目标寄存器 idx

sBx:-1 A JMP

当 sBx 不为 0 时,进行无条件跳转,执行 pc = pc + sBx(sBx 为-1,表示将当前指令再执行一次   注:这将是一个死循环)

sBx:0 A:0x001 JMP;

当 sBx 为 0 时(继续执行后面指令,不跳转),用于闭合处于开启状态的 Upvalue(即:把即将销毁的局部变量的值复制出来,并更新到某个 Upvalue 中)。

当前闭包的某个 Upvalue 值的索引由 A 指定:

指令名称 类型 操作码 B C A
EQ iABC 0x1F OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:1 EQ

寄存器或常量表(索引由 B 指定)是否等于寄存器或常量表(索引由 C 指定),若结果等于操作数 A,则跳过下一条指令。

公式:if ((RK(B) == RK(C)) pc++

指令名称 类型 操作码 B C A
LT iABC 0x20 OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:1 LT

寄存器或常量表(索引由 B 指定)是否小于寄存器或常量表(索引由 C 指定),若结果等于操作数 A,则跳过下一条指令。

公式:if ((RK(B) < RK(C)) pc++

指令名称 类型 操作码 B C A
LE iABC 0x21 OpArgK OpArgK 目标寄存器 idx

B:0x001 C:0x100 A:1 LE

寄存器或常量表(索引由 B 指定)是否小于等于寄存器或常量表(索引由 C 指定),若结果等于操作数 A,则跳过下一条指令。

公式:if ((RK(B) <= RK(C)) pc++

指令名称 类型 操作码 B C A
TEST iABC 0x22 OpArgN OpArgU 目标寄存器 idx

B C:0 A:1 TEST

判断寄存器(索引由 A 指定)中的值转换为 bool 值后,是否和操作数 C 表示的 bool 值一致,若结果不一致,则跳过下一条指令。

公式:

if not (R(A) <=> C) pc++

注:<=>表示按 bool 值比较

指令名称 类型 操作码 B C A
TESTSET iABC 0x23 OpArgR OpArgU 目标寄存器 idx

B:3  C:0 A:1 TESTSET

判断寄存器(索引由 B 指定)中的值转换为 bool 值后,是否和操作数 C 表示的 bool 值一致,若结果一致,将寄存器(索引由 B 指定)中的值复制到寄存器中(索引由 A 指定),否则跳过下一条指令。

公式:

if (R(B) \<=\> C)
   R(A) := R(B)
else
   pc++ 

注:<=>表示按 bool 值比较

指令名称 类型 操作码 B C A
CALL iABC 0x24 OpArgU OpArgU 目标寄存器 idx

B:5 C:4 A:0 CALL

被调用函数位于寄存器中(索引由 A 指定),传递给被调用函数的参数值也在寄存器中,紧挨着被调用函数,参数个数为操作数 B 指定。

① B==0,接受其他函数全部返回来的参数

② B>0,参数个数为 B-1

函数调用结束后,原先存放函数和参数值的寄存器会被返回值占据,具体多少个返回值由操作数 C 指定。

① C==0,将返回值全部返回给接收者

② C==1,无返回值

③ C>1,返回值的数量为 C-1

公式:R(A), ... ,

指令名称 类型 操作码 B C A
TAILCALL iABC 0x25 OpArgU OpArgU 目标寄存器 idx

函数调用一般通过调用栈来实现。用这种方法,每调用一个函数都会产生一个调用帧。

如果调用层次太深(如递归),容易导致栈溢出。尾递归优化则可以让我们发挥递归函数调用威力的同时,避免调用栈溢出。利用这种优化,被调函数可以重用主调函数的调用帧,因此可有效缓解调用栈溢出症状。不过该优化只适合某些特定情况。

如:return f(args) 会被编译器优化成 TAILCALL 指令,公式:return R(A)(R(A+1), ... , R(A+B-1))

指令名称 类型 操作码 B C A
RETURN iABC 0x26 OpArgU OpArgN 目标寄存器 idx

B:4 C  A:2 RETURN

把存放在连续多个寄存器里的值返回给父函数,其中第一个寄存器的索引由操作数 A 指定,寄存器数量由操作数 B 指定,操作数 C 没有使用,需要将返回值推入栈顶:

① B==1,不需要返回任何值

② B > 1,需要返回 B-1 个值;这些值已经在寄存器中了,只用再将它们复制到栈顶即可

③ B==0,一部分返回值已经在栈顶了,只需将另一部分也推入栈顶即可

公式:return R(A),...,R(A+B-2)

指令名称 类型 操作码 sBx A
FORLOOP iAsBx 0x27 OpArgR 目标寄存器 idx

数值 for 循环:用于按一定步长遍历某个范围内的数值   如:for i=1,100,2  do  f()  end // 初始值为 1,步长为 2,上限为 100

该指令先给 i 加上步长,然后判断 i 是否在范围之内。若已经超出范围,则循环结束;若为超出范围,则将数值拷贝给用户定义的局部变量,然后跳转到循环体内部开始执行具体的代码块。

公式:

R(A) += R(A+2)
if R(A) <?= R(A+1)
    pc+=sBx
    R(A+3)=R(A)

注:当步长为正数时<?=为<=

当步长为负数时<?=为>=

指令名称 类型 操作码 sBx A
FORPREP iAsBx 0x28 OpArgR 目标寄存器 idx

数值 for 循环:用于按一定步长遍历某个范围内的数值   如:for i=1,100,2  do  f()  end // 初始值为 1,步长为 2,上限为 100。

该指令的目的是在循环之前预先将 i 减去步长(得到-1),然后跳转到 FORLOOP 指令正式开始循环:

公式:

R(A)-=R(A+2)

pc+=sBx

指令名称 类型 操作码 B C A
TFORCALL iABC 0x29 OpArgN OpArgU 目标寄存器 idx

通用 for 循环:for k,v in pairs(t) do print(k,v) end

编译器使用的第一个特殊变量(generator):f 存放的是迭代器,其他两个特殊变量(state):s、(control):var 来调用迭代器,把结果保存在用户定义的变量 k、v 中。

公式:R(A+3),...,R(A+2+C) := R(A)(R(A+1),R(A+2))

指令名称 类型 操作码 sBx A
TFORLOOP iAsBx 0x2A OpArgR 目标寄存器 idx

通用 for 循环:for k,v in pairs(t) do print(k,v) end

若迭代器返回的第一个值(变量 k)不是 nil,则把该值拷贝到(control):var,然后跳转到循环体;若为 nil,则循环结束。

公式:

if R(A+1) ~= nil

R(A)=R(A+1)

pc+=sBx

指令名称 类型 操作码 B C A
SETLIST iABC 0x2B OpArgU OpArgU 目标寄存器 idx

SETTABLE 是通用指令,每次只处理一个键值对,具体操作交给表去处理,并不关心实际写入的是表的 hash 部分还是数组部分。SETLIST 则是专门给数组准备的,用于按索引批量设置数组元素。其中数组位于寄存器中,索引由操作数 A 指定;需要写入数组的一系列值也在寄存器中,紧挨着数组,数量由操作数 B 指定;数组起始索引则由操作数 C 指定。

因为 C 操作数只有 9bits,所以直接用它表示数组索引显然不够用。这里解决办法是让 C 操作数保存批次数,然后用批次数乘上批大小(FPF,默认为 50)就可以算出数组的起始索引。因此,C 操作数能表示的最大索引为 25600(50*512),当数组长度大于 25600 时,SETLIST 指令后会跟一条 EXTRAARG 指令,用其 Ax 操作数来保存批次数。

综上,C>0,表示的是批次数+1,否则,真正批次数存放在后续的 EXTRAARG 指令中。

操作数 B 为 0 时,当表构造器的最后一个元素是函数调用或者 vararg 表达式时,Lua 会把它们产生的所有值都收集起来供 SETLIST 使用。

公式:

R(A)[(C-1)*FPF+i] := R(A+i)

1 <= i <= B

指令名称 类型 操作码 Bx A
CLOSURE iABx 0x2C OpArgU 目标寄存器 idx

把当前 Lua 函数的子函数原型实例化为闭包,放入由操作数 A 指定的寄存器中子函数原型来自于当前函数原型的子函数原型表,索引由操作数 Bx 指定。

下图为将 prototypes 表中索引为 1 的 g 子函数,放入索引为 4 的寄存器中:

公式:R(A) := closure(KPROTO[Bx])

指令名称 类型 操作码 B C A
VARARG iABC 0x2D OpArgU OpArgN 目标寄存器 idx

把传递给当前函数的变长参数加载到连续多个寄存器中。

其中第一个寄存器的索引由操作数 A 指定,寄存器数量由操作数 B 指定,操作数 C 没有使用,操作数 B 若大于 1,表示把 B-1 个 vararg 参数复制到寄存器中,否则只能等于 0。

公式:R(A),R(A+1),...R(A+B-2)=vararg

指令名称 类型 操作码 Ax
EXTRAARG iAx 0x2E OpArgU

Ax:67108864 EXTRAARG

Ax 有 26bits,用来指定常量索引,可存放最大无符号整数为 67108864,可满足大部分情况的需要了。

参考

分享到: