lua虚拟机指令详解：浅析5.1版本核心构造

需积分: 50 33 浏览量更新于2024-07-26 收藏 219KB PDF 举报

本文档是一份深入浅出的Lua 5.1虚拟机指令集介绍，由Kein-Hong Man撰写，专为那些研究Lua虚拟机源代码的读者设计。文章以简洁明了的方式讲解了Lua指令的工作原理，涵盖了从基础指令到复杂功能的详细阐述。 1. **指令集介绍**：文档首先提供了一个简短的介绍，概述了Lua虚拟机的主要目的和指令集对于理解和实现语言解析过程的重要性。 2. **Lua指令基础**：这部分涵盖了Lua的基本指令类型，包括如何解析和执行基本的操作，如变量分配、赋值、数据类型转换等。 3. **简单和二进制chunk**：两种不同的代码表示形式，简单chunk是文本形式，而二进制chunk用于提高性能，减少存储空间占用。 4. **指令表示法**：详细解释了Lua指令的结构和符号表示，帮助读者理解字节码的组成。 5. **常量加载**：介绍了如何在运行时处理和存储常量，这对于性能优化至关重要。 6. **上值与全局变量**：讲解了Lua的变量作用域和上下文管理，特别是上值（upvalues）的概念，这是函数内部与外部共享的数据。 7. **表指令**：深入探讨了Lua中的表操作，如索引、键值对设置以及迭代。 8. **算术和字符串指令**：涉及数值计算、字符串操作，如加法、比较和拼接等。 9. **跳转与调用**：解析条件控制流，如if语句、循环和函数调用的字节码实现。 10. **关系和逻辑指令**：这部分讨论了逻辑运算符、比较操作和逻辑表达式的执行机制。 11. **循环指令**：涵盖while、for等循环结构的字节码表示，以及循环体的控制。 12. **表创建与闭包**：讲解如何创建和操作表，以及Lua的闭包特性，即局部变量的持久化。 13. **Lua 5.0.2与5.1差异**：对比了两个版本在指令集上的变化，可能影响到开发者的选择和升级策略。 14. **进一步探索**：鼓励读者在理解了基础概念后，去挖掘更深层次的虚拟机技术和优化方法。 15. **致谢与变更记录**：感谢了作者和贡献者，并列出了文档的历史更新和未来计划。通过阅读这份文档，读者能够获得深入理解Lua虚拟机指令集的能力，有助于编写高效且可维护的Lua脚本，同时也为深入研究Lua语言和其底层实现提供了宝贵资源。

Number is the Lua number data type, normally an IEEE 754 64-bit double. Integer, Size_t

and Number are all endian-sensitive; Lua 5.1 will not load a chunk whose endianness is

different from that of the platform. Their sizes and formats are of course specified in the

binary chunk header. The data type of Number is determined by its size byte and the integral

flag. Boolean values are encoded as either 0 or 1.

The function prototype list comes after the constant list:

Function prototype list

Holds function prototypes defined within the function.

Integer size of function prototypes (sizep)

[Functions] function prototype data, or function blocks

Function prototypes or function blocks have the exact same format as the top-level function

or chunk. However, function prototypes that isn’t the top-level function do not have the

source name field defined. In this way, function prototypes at different lexical scoping levels

are defined and nested. In a complex binary chunk, the nesting may be several levels deep. A

closure will refer to a function by its number in the list.

The lists following the list of prototypes are optional. They contain debug information and

can be stripped to save space. First comes the source line position list:

Source line position list

Holds the source line number for each corresponding instruction in a

function. This information is used by error handlers or debuggers. In a

stripped binary, the size of this list is zero. The execution of a function does

not depend on this list.

Integer size of source line position list (sizelineinfo)

[Integer] list index corresponds to instruction position; the integer

value is the line number of the Lua source where the

instruction was generated

Next up is the local list. Each local variable entry has 3 fields, a string and two integers:

Local list

Holds list of local variable names and the program counter range in which

the local variable is active.

Integer size of local list (sizelocvars)

[

String name of local variable (varname)

Integer start of local variable scope (startpc)

Integer end of local variable scope (endpc)

]

-10-

The final list is the upvalue list:

Upvalue list

Holds list of upvalue names.

Integer size of upvalue list (sizeupvalues)

[String] name of upvalue

All the lists are not shared or re-used: Locals, upvalues, constants and prototypes referenced

in the code must be specified in the respective lists in the same function. In addition, locals,

upvalues, constants and the function prototypes are indexed using numbers starting from 0. In

disassembly listings, both the source line position list and the instruction list are indexed

starting from 1. Note that the latter is by convention only; the indices does not matter to the

virtual machine itself, since all jump-related instructions use only signed displacements.

However, for debug information, the scope of local variables is encoded using absolute

program counter positions, and these positions are based on a starting index of 1. This is also

consistent with the output listing from luac.

How does it all fit in? You can easily generate a detailed binary chunk disassembly using

ChunkSpy. Enter the following short bit of code and name the file simple.lua:

local a = 8

function b(c) d = a + c end

Next, run ChunkSpy from the command line to generate the listing:

$ lua ChunkSpy.lua --source simple.lua > simple.lst

The following is a description of the generated listing (simple.lst), split into segments.

Pos Hex Data Description or Code

------------------------------------------------------------------------

0000 ** source chunk: simple.lua

** global header start **

0000 1B4C7561 header signature: "\27Lua"

0004 51 version (major:minor hex digits)

0005 00 format (0=official)

0006 01 endianness (1=little endian)

0007 04 size of int (bytes)

0008 04 size of size_t (bytes)

0009 04 size of Instruction (bytes)

000A 08 size of number (bytes)

000B 00 integral (1=integral)

* number type: double

* x86 standard (32-bit, little endian, doubles)

** global header end **

This is an example of a binary chunk header. ChunkSpy calls this the global header to

differentiate it from a function header. For binary chunks specific to a certain platform, it is

easy to match the entire header at one go instead of testing each field. As described

previously, the header is 12 bytes in size, and needs to be exactly compatible with the

platform or else Lua 5.1 won’t load the binary chunk.

-11-

The global header is followed by the function header of the top-level function:

000C ** function [0] definition (level 1)

** start of function **

000C 0B000000 string size (11)

0010 73696D706C652E6C+ "simple.l"

0018 756100 "ua\0"

source name: simple.lua

001B 00000000 line defined (0)

001F 00000000 last line defined (0)

0023 00 nups (0)

0024 00 numparams (0)

0025 02 is_vararg (2)

0026 02 maxstacksize (2)

A function’s header is always variable in size, due to the source name string. The source

name is only present in the top-level function. A top-level chunk does not have a line number

on which it is defined, so both the line defined fields are 0. There are no upvalues or

parameters. A top-level chunk can always take a variable number of parameters; is_vararg is

always 2 for the top-level chunk. The stack size is set at the minimum of 2 for this very

simple chunk.

Next we come to the various lists, starting with the code listing of the main chunk:

* code:

0027 05000000 sizecode (5)

002B 01000000 [1] loadk 0 0 ; 8

002F 64000000 [2] closure 1 0 ; 1 upvalues

0033 00000000 [3] move 0 0

0037 47400000 [4] setglobal 1 1 ; b

003B 1E008000 [5] return 0 1

The first line of the source code compiles to a single instruction, line [1]. Local a is register 0

and the number 8 is constant 0. In line [2], an instance of function prototype 0 is created, and

the closure is temporarily placed in register 1. The MOVE instruction in line [3] is actually

used by the CLOSURE instruction to manage the upvalue a; it is not really executed. This

will be explained in detail in Chapter 14. The closure is then placed into the global b in line

[4]; “b” is constant 1 while the closure is in register 1. Line [5] returns control to the calling

function. In this case, it exits the chunk.

The list of constants follow the instructions:

* constants:

003F 02000000 sizek (2)

0043 03 const type 3

0044 0000000000002040 const [0]: (8)

004C 04 const type 4

004D 02000000 string size (2)

0051 6200 "b\0"

const [1]: "b"

The top-level function requires two constants, the number 8 (which is used in the assignment

on line 1) and the string “b” (which is used to refer to the global variable b on line 2.)

This is followed by the function prototype list of the main chunk. On line 2 of the source, a

function prototype was declared within the main chunk. This function is instantiated and the

closure is assigned to global b.

-12-

剩余56页未读，继续阅读

emptyness

粉丝: 28
资源: 7

lua虚拟机指令详解：浅析5.1版本核心构造

Lua 5.1 Reference Manual（pdf版）

Lua虚拟机指令集介绍

Lua虚拟机指令结构与内存管理

LuaVM：Lua的Lua虚拟机（和各种工具），因此您可以在Lua的同时进行Lua

Lua-5.1-虚拟机指令简明手册1

darkprograms:为 Minecraft Mod Computercraft 的 Lua 虚拟机编写的程序

Lua 5.1 虚拟机指令详解

Lua5.1虚拟机指令手册：中英文版

Lua 5.1虚拟机指令详解：简单入门与二进制处理

Lua 虚拟机执行字节码原理探索

最新资源