a-no-frills-introduction-to-lua-5.1-vm-instructions资源-CSDN文库

4星 · 超过85%的资源需积分: 20 90 浏览量 2013-11-15 21:41:08 上传评论 1 收藏 219KB PDF 举报

Lua是一种小巧且功能强大的脚本语言，它被设计为一种轻量级的嵌入式语言。Lua 5.1是该语言的一个版本，它具有自己的虚拟机（VM），用于执行Lua编写的程序。虚拟机指令集是虚拟机的核心，它定义了虚拟机可以理解和执行的指令。本文将提供一个不加修饰的介绍，向读者展示Lua 5.1虚拟机的指令集。 Lua 5.1的虚拟机相比Perl或Python等其他脚本语言来说更小，也更容易理解其内部工作原理。了解一个编程语言的内部细节对于完全掌握它至关重要。要想深刻理解Lua或任何复杂系统，我们需要深入其内部，看看通常不被看到的“脏东西”，即它的内部机制。本文档专注于Lua 5.1的介绍，旧版文档提供了Lua 5.0.2虚拟机指令的指南。因为Lua的内部并没有固定或标准化，用户不能期望从一个版本到另一个版本之间保持兼容性。文档的示例来自ChunkSpy（一个Lua 5二进制块反汇编器，作者在研究Lua内部时编写），使用了ChunkSpy的简短反汇编模式。这些反汇编代码与ChunkSpy的输出非常相似。接下来，文档详细介绍了Lua指令集的基本知识，包括： 1. Lua指令基础，包括真的简单的块（chunks）和Lua二进制块。 2. 指令表示法，这是理解指令格式的关键。 3. 加载常量、上值（upvalues）和全局变量的方法。 4. 表指令，涉及表的创建和操作。 5. 算术和字符串指令，涵盖算术运算和字符串处理。 6. 跳转和调用指令，用于程序流程控制。 7. 关系和逻辑指令，涉及比较操作和逻辑操作。 8. 循环指令，用于执行循环控制结构。 9. 表创建，探讨如何在Lua中创建和操作表。 10. 闭包和结束闭包指令，用于定义和结束函数作用域。 11. 更深入的探讨，例如元表、元方法等高级概念。文档还包括致谢部分，其中提到了作者对于在编写文档过程中提供帮助的人表示感谢，以及变动日志和待办事项，指明了文档的版本历史和作者未来的计划。文档还提到，它使用了创意共享署名-非商业性-相同方式共享许可证2.0版本，这允许其他人复制、分发和展示文档内容，以及制作衍生作品，但需遵循特定条件，如保留原作者的信用，不得用于商业目的，以及修改或基于本作品构建时，仅能使用与本许可证相同的许可协议分发。从内容来看，本文是一份对于对Lua 5.1虚拟机指令集感兴趣的开发者和研究人员来说十分有价值的资料，它不仅介绍了指令集，还提供了关于Lua内部工作原理的深刻见解。通过对指令集的理解，读者可以更好地掌握Lua脚本语言，进而有效地利用Lua进行软件开发。

资源推荐

资源详情

资源评论

A No-Frills Introduction to Lua 5.1 VM Instructions

by Kein-Hong Man, esq. <khman AT users.sf.net>

Version 0.1, 20060313

Contents

1 Introduction 2

2 Lua Instruction Basics 3

3 Really Simple Chunks 5

4 Lua Binary Chunks 7

5 Instruction Notation 15

6 Loading Constants 16

7 Upvalues and Globals 20

8 Table Instructions 22

9 Arithmetic and String Instructions 23

10 Jumps and Calls 28

11 Relational and Logic Instructions 35

12 Loop Instructions 42

13 Table Creation 48

14 Closures and Closing 52

15 Comparing Lua 5.0.2 and Lua 5.1 56

16 Digging Deeper 57

17 Acknowledgements 57

18 ChangeLog & ToDos 57

“A No-Frills Introduction to Lua 5.1 VM Instructions” is licensed under the Creative

Commons Attribution-NonCommercial-ShareAlike License 2.0. You are free to copy,

distribute and display the work, and make derivative works as long as you give the original

author credit, you do not use this work for commercial purposes, and if you alter, transform,

or build upon this work, you distribute the resulting work only under a license identical to this

one. See the following URLs for more information:

http://creativecommons.org/licenses/by-nc-sa/2.0/

http://creativecommons.org/licenses/by-nc-sa/2.0/legalcode

-1-

1 Introduction

This is a no-frills introduction to the instruction set of the Lua 5.1 virtual machine. Compared

to Perl or Python, the compactness of Lua makes it relatively easier for someone to peek

under the hood and understand its internals. I think that one cannot completely grok a

scripting language, or any complex system for that matter, without slitting the animal open

and examining the entrails, organs and other yucky stuff that isn’t normally seen. So this

document is supposed to help with the “peek under the hood” bit.

This introductory guide covers Lua 5.1 only. Please see the older document for the guide to

Lua 5.0.2 virtual machine instructions. This is intentional; the internals of Lua is not fixed or

standardized in any way, so users must not expect compatibility from one version of Lua to

another as far as internals are concerned.

Output from ChunkSpy (URL: http://luaforge.net/projects/chunkspy/), a Lua 5

binary chunk disassembler which I wrote while studying Lua internals, was used to generate

the examples shown in this document. The brief disassembly mode of ChunkSpy is very

similar to the output of the listing mode of luac, so you do not need to learn a new listing

syntax. ChunkSpy can be downloaded from LuaForge (URL: http://luaforge.net/); it

is licensed under the same type of MIT-style license as Lua 5 itself.

ChunkSpy has an interactive mode: you can enter a source chunk and get an immediate

disassembly. This allows you to use this document as a tutorial by entering the examples into

ChunkSpy and seeing the results yourself. The interactive mode is also very useful when you

are exploring the behaviour of the Lua code generator on many short code snippets.

This is a quick introduction, so it isn’t intended to be a comprehensive or expert treatment of

the Lua virtual machine (from this point on, “Lua” refers to “Lua 5” unless otherwise stated)

or its instructions. It is intended to be a simple, easy-to-digest beginner’s guide to the Lua

virtual machine instruction set – it won’t do cartwheels or blow smoke rings.

The objective of this introduction is to cover all the Lua virtual machine instructions and the

structure of Lua 5 binary chunks with a minimum of fuss. Then, if you want more detail, you

can use luac or ChunkSpy to study non-trivial chunks of code, or you can dive into the Lua

source code itself for the real thing.

This is currently a draft, and I am not a Lua internals expert. So feedback is welcome. If you

find any errors, or if you have anything to contribute please send me an e-mail (to khman AT

users.sf.net or mkh AT pl.jaring.my) so that I can correct it. Thanks.

-2-

2 Lua Instruction Basics

The Lua virtual machine instruction set we will look at is a particular implementation of the

Lua language. It is by no means the only way to skin the chicken. The instruction set just

happens to be the way the authors of Lua chose to implement version 5 of Lua. The following

sections are based on the instruction set used in Lua 5.1. The instruction set might change in

the future – do not expect it to be set in stone. This is because the implementation details of

virtual machines are not a concern to most users of scripting languages. For most

applications, there is no need to specify how bytecode is generated or how the virtual machine

runs, as long as the language works as advertised. So remember that there is no official

specification of the Lua virtual machine instruction set, there is no need for one; the only

official specification is of the Lua language.

In the course of studying disassemblies of Lua binary chunks, you will notice that many

generated instruction sequences aren’t as perfect as you would like them to be. This is

perfectly normal from an engineering standpoint. The canonical Lua implementation is not

meant to be an optimizing bytecode compiler or a JIT compiler. Instead it is supposed to load,

parse and run Lua source code efficiently. It is the totality of the implementation that counts.

If you really need the performance, you are supposed to drop down into native C functions

anyway.

Lua instructions have a fixed size, using a 32 bit unsigned integer data type by default. In

binary chunks, endianness is significant, but while in memory, an instruction can be portably

decoded or encoded in C using the usual integer shift and mask operations. The details can be

found in lopcodes.h, while the Instruction type definition is defined in llimits.h.

There are three instruction types and 38 opcodes (numbered 0 through 37) are currently in use

as of Lua 5.1. The instruction types are enumerated as iABC, iABx, iAsBx, and may be

visually represented as follows:

Lua 5 Instruction Formats

Instruction fields are encoded as simple unsigned integer values, except for sBx. Field sBx

can represent negative numbers, but it doesn’t use 2s complement. Instead, it has a bias equal

to half the maximum integer that can be represented by its unsigned counterpart, Bx. For a

field size of 18 bits, Bx can hold a maximum unsigned integer value of 262143, and so the

bias is 131071 (calculated as 262143 >> 1). A value of -1 will be encoded as (-1 + 131071)

or 131070 or 1FFFE in hexadecimal.

Fields A, B and C usually refers to register numbers (I’ll use the term “register” because of its

similarity to processor registers). Although field A is the target operand in arithmetic

operations, this rule isn’t always true for other instructions. A register is really an index into

the current stack frame, register 0 being the bottom-of-stack position.

-3-

31 24 23 16 15 8 7 0

Opcode:6

A:8B:9 C:9 Opcode:6

A:8Bx:18 Opcode:6

A:8sBx:18

iABC

iABx

iAsBx

Unlike the Lua C API, negative indices (counting from the top of stack) are not supported.

For some instructions, where the top of stack may be required, it is encoded as a special

operand value, usually 0. Local variables are equivalent to certain registers in the current

stack frame, while dedicated opcodes allow read/write of globals and upvalues. For some

instructions, a value in fields B or C may be a register or an encoding of the number of a

constant in the constant pool. This will be described further in the section on instruction

notation.

By default, Lua has a maximum stack frame size of 250. This is encoded as MAXSTACK in

llimits.h. The maximum stack frame size in turn limits the maximum number of locals

per function, which is set at 200, encoded as LUAI_MAXVARS in luaconf.h. Other limits

found in the same file include the maximum number of upvalues per function (60), encoded

as LUAI_MAXUPVALUES, call depths, the minimum C stack size, etc. Also, with an sBx field

of 18 bits, jumps and control structures cannot exceed a jump distance of about 131071.

A summary of the Lua 5.1 virtual machine instruction set is as follows:

Opcode Name Description

0 MOVE Copy a value between registers

1 LOADK Load a constant into a register

2 LOADBOOL Load a boolean into a register

3 LOADNIL Load nil values into a range of registers

4 GETUPVAL Read an upvalue into a register

5 GETGLOBAL Read a global variable into a register

6 GETTABLE Read a table element into a register

7 SETGLOBAL Write a register value into a global variable

8 SETUPVAL Write a register value into an upvalue

9 SETTABLE Write a register value into a table element

10 NEWTABLE Create a new table

11 SELF Prepare an object method for calling

12 ADD Addition operator

13 SUB Subtraction operator

14 MUL Multiplication operator

15 DIV Division operator

16 MOD Modulus (remainder) operator

17 POW Exponentiation operator

18 UNM Unary minus operator

19 NOT Logical NOT operator

20 LEN Length operator

21 CONCAT Concatenate a range of registers

22 JMP Unconditional jump

23 EQ Equality test

24 LT Less than test

25 LE Less than or equal to test

26 TEST Boolean test, with conditional jump

27 TESTSET Boolean test, with conditional jump and assignment

28 CALL Call a closure

29 TAILCALL Perform a tail call

30 RETURN Return from function call

31 FORLOOP Iterate a numeric for loop

32 FORPREP Initialization for a numeric for loop

33 TFORLOOP Iterate a generic for loop

34 SETLIST Set a range of array elements for a table

35 CLOSE Close a range of locals being used as upvalues

36 CLOSURE Create a closure of a function prototype

37 VARARG Assign vararg function arguments to registers

-4-

3 Really Simple Chunks

Before heading into binary chunk and virtual machine instruction details, this section will

demonstrate briefly how ChunkSpy can be used to explore Lua 5 code generation. All the

examples in this document were produced using the Lua 5.1 version of ChunkSpy found in

the ChunkSpy 0.9.8 distribution.

First, start ChunkSpy in interactive mode (user input is set in bold):

$ lua ChunkSpy.lua --interact

ChunkSpy: A Lua 5.1 binary chunk disassembler

The COPYRIGHT file describes the conditions under which this

software may be distributed (basically a Lua 5-style license.)

Type 'exit' or 'quit' to end the interactive session. 'help' displays

this message. ChunkSpy will attempt to turn anything else into a

binary chunk and process it into an assembly-style listing.

A '\' can be used as a line continuation symbol; this allows multiple

lines to be strung together.

We’ll start with the shortest possible binary chunk that can be generated:

>do end

; source chunk: (interactive mode)

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

; function [0] definition (level 1)

; 0 upvalues, 0 params, 2 stacks

.function 0 0 2 2

[1] return 0 1

; end of function

ChunkSpy will treat your keyboard input as a small chunk of Lua source code. The library

function string.dump() is first used to generate a binary chunk string, then ChunkSpy will

disassemble that string and give you a brief assembly language-style output listing.

Some features of the listing: Comment lines are prefixed by a semicolon. The header portion

of the binary chunk is not displayed with the brief style. Data or header information that isn’t

an instruction is shown as an assembler directive with a dot prefix. luac-style comments are

generated for some instructions, and the instruction location is in square brackets.

A “do end” generates a single RETURN instruction and does nothing else. There are no

parameters, locals, upvalues or globals. For the rest of the disassembly listings shown in this

document, we will omit some common header comments and show only the function

disassembly part. Instructions will be referenced by its marked position, e.g. line [1]. Here is

another very short chunk:

>return

; function [0] definition (level 1)

; 0 upvalues, 0 params, 2 stacks

.function 0 0 2 2

[1] return 0 1

[2] return 0 1

; end of function

-5-

剩余56页未读，继续阅读

评论收藏

内容反馈

土曜日

2015-04-25

清晰pdf，学习编译原理的好资料
雨艺工作室

2014-08-28

第一次评三星。感觉此文写得罗嗦。其实没那么复杂。此书在描述字节码的同时也把附带的一些东西说了，如果你已经对lua的实现机制有一定了解了，就不用下载此文了。如果你刚开始学lua，下载下来看看说不定有用。