深入理解 Lua 虚拟机

栏目: IT技术 · 发布时间: 4年前

内容简介:作者:nicochen,腾讯 IEG 游戏开发工程师本文从一个简单示例入手,详细讲解 Lua 字节码文件的存储结构及各字段含义,进而引出 Lua 虚拟机指令集和运行时的核心数据结构 Lua State,最后解释 Lua 虚拟机的 47 条指令如何在 Lua State 上运作的。

深入理解  <a href='https://www.codercto.com/topics/21840.html'>Lua</a>  虚拟机

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

Hello.lua 源代码如下:

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

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

深入理解 Lua 虚拟机

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

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

头部字段:

深入理解 Lua 虚拟机

嵌套的函数原型:

深入理解 Lua 虚拟机

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

①NULL 字符串用 0x00 表示;

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

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

注 2:常量 tag 对应表

深入理解 Lua 虚拟机

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

luac.exe -l Hello.lua
luac.exe -l Hello.out
深入理解 Lua 虚拟机

注 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、 PythonRuby 、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)

深入理解 Lua 虚拟机

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

深入理解 Lua 虚拟机

Lua 栈索引

深入理解 Lua 虚拟机

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

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

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

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

Lua State

深入理解 Lua 虚拟机

指令表

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

深入理解 Lua 虚拟机

B:1 C A:3 MOVE

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

深入理解 Lua 虚拟机

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

深入理解 Lua 虚拟机

Bx:2 A:4 LOADK

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

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

深入理解 Lua 虚拟机

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

深入理解 Lua 虚拟机

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 则跳过下一条指令。

深入理解 Lua 虚拟机

公式:

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 个局部变量设置初始值。

深入理解 Lua 虚拟机

公式: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 指定)中  。

深入理解 Lua 虚拟机

公式: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 指定,为寄存器或常量表索引)。

深入理解 Lua 虚拟机

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(为寄存器或常量表索引)指定。

深入理解 Lua 虚拟机

公式: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 指定,为寄存器或常量表索引)。

深入理解 Lua 虚拟机

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

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

B:0 C A:3 SETUPVAL

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

深入理解 Lua 虚拟机

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

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

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

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

深入理解 Lua 虚拟机

公式: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 指定。

深入理解 Lua 虚拟机

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

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

B:1 C:0x100 A:2 SELF

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

深入理解 Lua 虚拟机

公式:

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 指定)。

深入理解 Lua 虚拟机

公式: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 指定)。

深入理解 Lua 虚拟机

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

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

B:1 C A:3 NOT

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

深入理解 Lua 虚拟机

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

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

B:1 C A:3 LEN

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

深入理解 Lua 虚拟机

公式: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 指定)。

深入理解 Lua 虚拟机

公式: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,则跳过下一条指令。

深入理解 Lua 虚拟机

公式: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 值一致,若结果不一致,则跳过下一条指令。

深入理解 Lua 虚拟机

公式:

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 指定),否则跳过下一条指令。

深入理解 Lua 虚拟机

公式:

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

深入理解 Lua 虚拟机

公式: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,一部分返回值已经在栈顶了,只需将另一部分也推入栈顶即可

深入理解 Lua 虚拟机

公式: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 是否在范围之内。若已经超出范围,则循环结束;若为超出范围,则将数值拷贝给用户定义的局部变量,然后跳转到循环体内部开始执行具体的代码块。

深入理解 Lua 虚拟机

公式:

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 指令正式开始循环:

深入理解 Lua 虚拟机

公式:

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 中。

深入理解 Lua 虚拟机

公式: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,则循环结束。

深入理解 Lua 虚拟机

公式:

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 使用。

深入理解 Lua 虚拟机

公式:

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 的寄存器中:

深入理解 Lua 虚拟机

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

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

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

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

深入理解 Lua 虚拟机

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

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

Ax:67108864 EXTRAARG

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

参考

深入理解 Lua 虚拟机


以上所述就是小编给大家介绍的《深入理解 Lua 虚拟机》,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对 码农网 的支持!

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

复制互联网之2

复制互联网之2

文飞翔//刘伟 / 清华大学出版社 / 2011-6 / 45.00元

《复制互联网之2:2011年全球最值得模仿的100个网站》从行业的整体发展趋势中,收录了国内外最值得关注的互联网商业模式,为初创网站设计者提供了诸多可供借鉴的最具有启发价值的商业案例。此外,《复制互联网之2:2011年全球最值得模仿的100个网站》对前沿互联网产品的介绍和思考,也值得网站开发人员、产品设计人员及公司管理人员在产品和运营的创新上借鉴与参考。 作者是网易科技频道的编辑,长期致力于......一起来看看 《复制互联网之2》 这本书的介绍吧!

CSS 压缩/解压工具
CSS 压缩/解压工具

在线压缩/解压 CSS 代码

MD5 加密
MD5 加密

MD5 加密工具

RGB HSV 转换
RGB HSV 转换

RGB HSV 互转工具