2022年6月10日15:15:22

luajit开发文档中文版(一)下载和安装

luajit开发文档中文版(二)LuaJIT扩展

luajit开发文档中文版(三)FAQ 常见问题

介绍

以下文档描述了 LuaJIT 2.0 字节码指令。有关详细信息，请参阅src/lj_bc.hLuaJIT 源代码。字节码可以用 列出luajit -bl，参见 -b 选项。

单个字节码指令为 32 位宽，具有 8 位操作码字段和多个 8 位或 16 位操作数字段。指令采用以下两种格式之一：

该图显示了右侧的最低有效位。内存指令始终按主机字节顺序存储。例如，0xbbccaa1e 是操作码为 0x1e ( ADDVV) 的指令，操作数 A = 0xaa、B = 0xbb 和 C = 0xcc。

指令名称的后缀区分同一基本指令的变体：

• V可变槽
• S 字符串常量
• N数常数
• P 原始类型
• B 无符号字节文字
• M 多个参数/结果

以下是可能的操作数类型：

• (无)：未使用的操作数
• var: 可变槽号
• dst：可变槽号，用作目的地
• base：基本槽号，可读写
• rbase：基本槽号，只读
• uv：上值数
• 点燃：字面意思
• lits：带符号的文字
• pri：原始类型(0 = nil，1 = false，2 = true)
• num：数字常量，索引到常量表
• str：字符串常量，常量表的否定索引
• tab：模板表，否定索引到常量表
• func：函数原型，常量表的否定索引
• cdata：cdata 常量，常量表的否定索引
• jump：分支目标，相对于下一条指令，偏置为 0x8000

比较操作

所有比较和测试操作都紧跟在一条JMP 指令之后，该指令包含条件跳转的目标。如果比较或测试为真，则所有比较和测试都会跳转到目标。否则，他们将通过JMP.

问：为什么我们需要四种不同的有序比较？适当交换的操作数还不够<吗 ？<=

答：不，因为浮点比较(x < y)与存在NaN 的情况不同。not (x >= y)

LuaJIT 解析器保留源代码的有序比较语义，如下所示：

根据需要交换(不)等式比较以将常量移到右侧。

一元测试和复制操作

这些指令测试一个变量在布尔上下文中的计算结果是真还是假。仅在 Lua中nil并被false认为是假的，所有其他值都是真。这些指令是为简单的真实性测试而生成的，例如if x then在评估andandor 运算符时。

问：我们需要测试和复制操作做什么？

答：在 Lua 中，andandor运算符返回其操作数之一的原始值。通常只有在解析完整表达式后才知道结果是否未被使用。在这种情况下，测试和复制操作可以很容易地转换为先前发出的字节码中的测试操作。

一元操作

Binary ops

注意：该CAT指令将变量槽 B 到 C 中的所有值连接起来。

Constant ops

注意：使用 设置单个nil值KPRI。KNIL仅在需要将多个值设置为 时使用nil。

Upvalue and Function ops

问：为什么UCLO会有跳跃目标？

A :UCLO通常是块中的最后一条指令，通常后面跟一个JMP. 将跳转合并到UCLO加速执行并简化一些字节码修复步骤(参见 参考资料fs_fixup_ret()) src/lj_parse.c。非分支UCLO只是跳转到下一条指令。

Table ops

备注：

• 16 位文字 D 操作数TNEW分为两个字段：最低 11 位给出数组大小(分配插槽 0..asize-1，如果为零，则不分配)。高 5 位将哈希大小作为 2 的幂(分配 2^hsize 哈希槽，如果为零，则不分配)。
• GGET并被GSET命名为“全局”获取和设置，但实际上索引当前函数环境getfenv(1)(通常与 相同_G)。
• TGETB并将TSETB8 位文字 C 操作数解释为表 B 中的无符号整数索引 (0..255)。
• 操作数 DTSETM指向常量表中的偏置浮点数。只有尾数的最低 32 位用作起始表索引。来自前一个字节码的 MULTRES 给出了要填充的表槽数。

调用和可变参数处理

所有调用指令都需要一个特殊的设置：要调用的函数(或对象)位于插槽 A 中，后面是连续插槽中的参数。操作数 C 是固定参数数量的加一。操作数 B 是返回值数量的一加，或者对于返回所有结果的调用为零(并相应地设置 MULTRES)。

带有多个参数(CALLM或CALLMT)的调用的操作数 C 设置为固定参数的数量。MULTRES 添加到其中以获取要传递的实际参数数量。

为了保持一致性，专用调用指令ITERC和ITERN可变参数指令VARG共享相同的操作数格式。ITERCand的操作数 CITERN始终为 3 = 1+2，即两个参数被传递给迭代器函数。操作数 C ofVARG重新用于保存封闭函数的固定参数的数量。这加快了对下面 vararg 伪帧的可变参数部分的访问。

MULTRES 是一个内部变量，用于跟踪上一次调用或VARG具有多个结果的指令返回的结果数量。它被多个参数的调用(CALLM或CALLMT)或返回(RETM)以及表初始化程序(TSETM)使用。

注意：Lua 解析器启发式地确定是否pairs()或 next()可能在循环中使用。在这种情况下，JMP和 迭代器调用ITERC被替换为专用版本 ISNEXT和ITERN。

ISNEXT在运行时验证迭代器实际上是next() 函数，参数是表，控制变量是 nil. 然后它将控制变量的槽的最低 32 位设置为零并跳转到迭代器调用，它使用这个数字有效地逐步遍历表的键。

如果任何假设被证明是错误的，则字节码在运行时将被反专门化为JMPand ITERC。

Returns

所有返回指令都将从槽 A 开始的结果复制到从基本槽(保存帧链接和当前执行函数的槽)下一个开始的槽。

和RET0指令RET1只是RET. 操作数 D 是要返回的结果数的一加。

对于RETM，操作数 D 保存要返回的固定结果的数量。将 MULTRES 添加到其中以获取要返回的实际结果数。

循环和分支

Lua 语言提供了四种循环类型，它们被翻译成不同的字节码指令：

• 数字“for”循环：for i=start,stop,step do body end=> 设置开始、停止、步骤FORI主体FORL
• 迭代器'for'循环：for vars... in iter,state,ctl do body end=> set iter,state,ctl JMPbodyITERC ITERL
• 'while' 循环：while cond do body end=> inverse-cond- JMP LOOPbodyJMP
• “重复”循环：repeat body until cond=>LOOP身体条件-JMP

breakandgoto语句被翻译成无条件的 orJMP指令UCLO。

操作数 A 保存指令的第一个未使用的槽、JMP指令的循环控制变量的基本槽*FOR*(idx、stop、step、ext idx)或指令迭代器返回结果的基*ITERL(存储在下面是 func、state和ctl)。

JFORL和指令将跟踪JITERL号JLOOP存储在操作数 D 中(JFORI从对应的 中检索JFORL)。否则，操作数 D 指向循环后的第一条指令。

和指令FORL进行热点检测。如果循环执行得足够频繁，就会触发跟踪记录。ITERLLOOP

IFORLJIT 编译器使用IITERL和ILOOP指令将无法编译的循环列入黑名单。他们不在解释器中进行热点检测和强制执行。

如果循环进入条件为真JFORI，则JFORL、JITERL和指令进入 JIT 编译的跟踪。JLOOP

*FORL指令idx = idx + step先做。所有*FOR* 指令都会检查idx <= stop(if step >= 0) 或idx >= stop (if step < 0)。如果为真，idx则复制到ext idx槽(循环体中可见的循环变量)。然后输入循环体或 JIT 编译的跟踪。否则，通过继续执行 . 之后的下一条指令来离开循环*FORL。

*ITERL指令检查槽 A 中迭代器返回的第一个结果是否为非nil. 如果为真，则将此值复制到插槽 A-1 并输入循环体或 JIT 编译的跟踪。

这些*LOOP指令实际上是无操作的(热点检测除外)并且不分支。操作数 A 和 D 仅由 JIT 编译器用于加速数据流和控制流分析。字节码指令本身是必需的，因此 JIT 编译器可以对其进行修补以输入循环的 JIT 编译跟踪。

Function headers

操作数 A 保存函数的帧大小。操作数 D 保存 和 的跟踪JFUNCF号JFUNCV。

对于 Lua 函数，省略的固定参数被设置为nil，多余的参数被忽略。Vararg 函数设置涉及创建一个特殊的 vararg 框架，该框架包含固定参数之外的参数。固定的参数被复制到一个常规的 Lua 函数框架，并且它们在可变参数框架中的槽被设置为nil.

和指令为固定参数或可变参数 Lua 函数设置框架并进行热点检测FUNCF。FUNCV如果函数执行得足够频繁，就会触发跟踪记录。

JIT 编译器使用IFUNCF和IFUNCV指令将无法编译的函数列入黑名单。他们不在解释器中进行热点检测和强制执行。

JFUNCF和指令在JFUNCV初始设置后进入 JIT 编译的跟踪。

FUNCCand指令是C 闭包字段FUNCCW指向的伪头文件。pc它们从不发出，仅用于分派到 C 函数调用的设置代码。

所有较高编号的字节码指令都用作快速函数的伪标头。它们从不发出，仅用于为相应的快速功能分派到机器代码。

LuaJIT 2.0 Bytecode Dump Format

LuaJIT 字节码转储格式是使用luajit -bor string.dump函数生成的。它可以保存到文件并稍后加载，而不是存储普通的 Lua 源，占用更多空间并花费更长的时间加载。

字节码转储格式的详细信息可以src/lj_bcdump.h 在 LuaJIT 源代码中找到。这是简洁的格式说明：

dump   = header proto+ 0U
header = ESC 'L' 'J' versionB flagsU [namelenU nameB*]
proto  = lengthU pdata
pdata  = phead bcinsW* uvdataH* kgc* knum* [debugB*]
phead  = flagsB numparamsB framesizeB numuvB numkgcU numknU numbcU[debuglenU [firstlineU numlineU]]
kgc    = kgctypeU { ktab | (loU hiU) | (rloU rhiU iloU ihiU) | strB* }
knum   = intU0 | (loU1 hiU)
ktab   = narrayU nhashU karray* khash*
karray = ktabk
khash  = ktabk ktabk
ktabk  = ktabtypeU { intU | (loU hiU) | strB* }B = 8 bit, H = 16 bit, W = 32 bit, U = ULEB128 of W, U0/U1 = ULEB128 of W+1

TODO : 将描述转换为人类可读的文本 :-)

转储以魔法开始\x1bLJ。神奇的是版本号，它表示字节码的版本。不同版本不兼容。在撰写本文时，当前版本号1由. 接下来， 使用 ULEB128对位标志(在 中找到)进行编码。如果未设置标志，则接下来是 ULEB128 编码的块名称的长度，并且它本身紧跟在长度之后，否则跳过此步骤。BCDUMP_VERSIONsrc/lj_dump.hBCDUMP_F_{STRIP, BE, FFI}src/lj_dump.hBCDUMP_F_STRIP

TODO：具体lj_bcwrite.c:370 ctx->status = ctx->wfunc(ctx->L, ctx->sb.buf, ctx->sb.n, ctx->wdata);做什么？

TODO : 更多信息GCproto

接下来，GCproto写入携带字节码的对象。注意复数对象，每个函数有一个对象。对象写得最深，首先在前，即：

function a()function b()print(1)endreturn b
end
a()()

首先b，然后a再编写范围的其余部分。

最后有一个\0字节，表示bcread_proto.

BCDUMP_F_* 标志

todo

GCProto

todo

LuaJIT 2.0 SSA IR

介绍

以下文档描述了LuaJIT 2.0 的 JIT 编译器使用的中间表示 ( IR )。跟踪编译器按照控制流记录字节码指令，并即时发出相应的 IR 指令。

IR具有以下特点：

• IR 采用 SSA(静态单一分配)形式。每条指令(节点)都代表一个值的单一定义。多条指令形成一个部分连接的数据流图。循环的数据流使用 PHI 指令表示。控制流总是隐含的。

• IR 是线性的、无指针的且隐含编号：每条指令都可以通过其在线性数组中的位置来唯一引用 (IRRef)。特制的、有偏见的 IR 参考允许快速做出 const 与非 const 决策。存储明确的参考编号、值编号或类似信息不会浪费任何空间。

• IR 是 2-operand-normalized 形式：每条指令都有一个操作码和最多两个操作数。一些指令可能需要更多的操作数(例如CALL*)，这些操作数是使用扩展指令(CARG)组成的。

• IR 是有类型的：每条指令都有一个输出数据类型。建模类型对应于基本 Lua 数据类型和低级数据类型。更高级别的数据类型根据需要使用受保护的断言进行间接建模。

• IR 具有隔离的每个操作码链接：这允许以相反的顺序快速搜索特定指令，而无需完全遍历。这用于加速许多优化，例如 CSE 或别名分析。大多数搜索在零(不匹配)之后停止，实际上是一两次取消引用。

• IR 非常紧凑：每条指令只需要 64 位，并且所有指令彼此相邻。这种布局的缓存效率非常高，索引或遍历速度非常快。

• IR 是增量生成的：IR 数组是双向增长的：常量向下增长，所有其他指令向上增长。大多数优化都是即时执行的，消除的指令要么根本不发出，要么在代码生成期间被忽略，要么被适当地标记。一般不需要在中间插入或删除指令。这避免了大多数编译器教科书中提出的缓存效率非常低的链接节点海数据结构。

• IR 是统一的：它同时携带高级语义和低级细节。编译器的不同阶段使用 IR 的不同方面，但共享一个通用的 IR 格式。消除经典的 HIR、MIR、LIR 分离(高、中、低级 IR)大大降低了复杂性和编译器开销。它避免了由于抽象不匹配导致的语义信息丢失，并允许对内存引用进行廉价且有效的高级语义消歧。

• IR 使用辅助快照：快照捕获对应于字节码执行堆栈中修改的槽和帧的 IR 引用。每个快照都保存一个特定的字节码执行状态，以后可以在跟踪退出时恢复。快照被稀疏地发射和压缩。快照提供了 IR 和字节码域(以及源代码域，通过字节码调试信息)之间的链接。

Status

COMPLETE REWRITE IN PROGRESS

src/lj_ir.h有关完整的详细信息，请参阅src/lj_jit.hLuaJIT 源代码。生成的 IR 可以与luajit -jdump(跟踪的字节码、IR 和机器代码)或luajit -jdump=i(仅 IR)一起列出。

示例 IR 转储

$ ./luajit -jdump=bitmsr
LuaJIT 2.0.0-beta10 -- Copyright (C) 2005-2012 Mike Pall. http://luajit.org/
JIT: ON CMOV SSE2 SSE3 AMD fold cse dce fwd dse narrow loop abc sink fuse
> local x = 1.2 for i=1,1e3 do x = x * -3 end
---- TRACE 1 start stdin:1
0006  MULVN    0   0   1  ; -3
0007  FORL     1 => 0006
---- TRACE 1 IR
....              SNAP   #0   [ ---- ]
0001 rbp      int SLOAD  #2    CI
0002 xmm7  >  num SLOAD  #1    T
0003 xmm7   + num MUL    0002  -3
0004 rbp    + int ADD    0001  +1
....              SNAP   #1   [ ---- 0003 ]
0005       >  int LE     0004  +1000
....              SNAP   #2   [ ---- 0003 0004 ---- ---- 0004 ]
0006 ------------ LOOP ------------
0007 xmm7   + num MUL    0003  -3
0008 rbp    + int ADD    0004  +1
....              SNAP   #3   [ ---- 0007 ]
0009       >  int LE     0008  +1000
0010 rbp      int PHI    0004  0008
0011 xmm7     num PHI    0003  0007
---- TRACE 1 mcode 81
394cffa3  mov dword [0x4183f4a0], 0x1
394cffae  movsd xmm0, [0x4184f698]
394cffb7  cvtsd2si ebp, [rdx+0x8]
394cffbc  cmp dword [rdx+0x4], 0xfffeffff
394cffc3  jnb 0x394c0010    ->0
394cffc9  movsd xmm7, [rdx]
394cffcd  mulsd xmm7, xmm0
394cffd1  add ebp, +0x01
394cffd4  cmp ebp, 0x3e8
394cffda  jg 0x394c0014 ->1
->LOOP:
394cffe0  mulsd xmm7, xmm0
394cffe4  add ebp, +0x01
394cffe7  cmp ebp, 0x3e8
394cffed  jle 0x394cffe0    ->LOOP
394cffef  jmp 0x394c001c    ->3
---- TRACE 1 stop -> loop

上面打印了跟踪的字节码、从带有快照的字节码生成的 IR，以及从 IR 生成的机器码.

The columns of the IR are as follows:

1st column: IR instruction number (implicit SSA ref)
2nd column: physical CPU register or physical CPU stack slot thatvalue is written to when converted to machine code.'[%x+]' (rather than register name) indicates hexadecimal offsetfrom stack pointer.(This column is only present if the 'r' flags is included in -jdump, whichaugments the IR with register/stack slots.  It is not part of the IR itself.)
3rd column: Instruction flags:">" (IRT_GUARD = 0x80 instruction flag) are locations ofguards (leading to possible side exits from the trace)."+" (IRT_ISPHI = 0x40 instruction flag) indicatesinstruction is left or right PHI operand. (i.e referredto in some PHI instruction).
4th column: IR type (see IR Types below)
5th column: IR opcode (see opcode reference)
6th/7th column: IR operands (SSA refs or literals)'#' prefixes refer to slot numbers, used in SLOADS.#0 is the base frame (modified only in tail calls).#1 is the first slot in the first frame (register 0 inthe bytecode)'[+-]' prefixes indicate positive or negative numeric literals.'[0x%d+]' and NULL are memory addresses.'"..."' are strings.'@' prefixes indicate slots (what is this?).Other possible values: "bias" (number 2^52+2^51 ?), "userdata:%p","userdata:%p" (table)--when do these occur?.

另见 SSA 转储格式注释： http: //lua-users.org/lists/lua-l/2008-06/msg00225.html(旧版本)。参见dump.lua。formatk_

每个快照 (SNAP) 都会列出修改后的堆栈槽及其值。快照列表中的第 i 个值表示在插槽号#i 中写入值的 IR 的索引。'---' 表示该槽没有被写入。帧由“|”分隔。有关快照的更多评论，请参阅http://lua-users.org/lists/lua-l/2009-11/msg00089.html。

IR Types

每条指令都有一个输出数据类型，它要么是基本 Lua 类型之一，要么是低级类型。该顺序经过精心设计，以简化标记值类型的映射并优化常见检查(例如“任何整数类型”)。见src/lj_ir.h和src/lj_obj.h。

Constants

常量指令仅存在于 IR 的常量部分(向上增长到较低的参考)。IR 常量是 interned(去重)，并且只能通过查看它们的引用来比较它们的相等性。

常量指令永远不会出现在转储中，因为-jdump始终显示内联到引用指令中的实际常量值

每个跟踪KPRI在固定引用处都有三个指令，用于常量 nil、false 和 true(REF_NIL、REF_FALSE、REF_TRUE)。

32 位整数或指针值占用左右 16 位操作数的空间。64 位值在一个全局常量表中，并由 32 位指针间接引用。

KPTR是指向可能非常量数据的常量指针(绝对地址)。KKPTR指向绝对恒定的数据。只有VM已知为常量的数据才符合条件，例如，一个内部的 Lua 字符串。被用户(例如const char *)标记为“const”的内容不符合条件。

KSLOT用作键HREFK并保存要在其中找到键的哈希槽和对常量键本身的引用。

Guarded Assertions

受保护的断言有双重目的：

• 它们提供有关其操作数的断言，编译器可以使用该断言来优化同一跟踪中的所有后续指令。
• 它们由后端作为分支比较发出，在直通路径中具有“真实”结果。“假”结果退出跟踪并将状态恢复到最近的快照。

操作码为整数类型提供无符号比较语义，U..为浮点类型提供无序比较语义。操作数导致有序比较的 NaN“假”结果和无序比较EQ的“真”结果NE。

ABC就像UGT在后端一样对待。但它遵循不同的 FOLD 规则，这简化了 ABC 消除。

返回的原型RETF位于到目前为止的跟踪所覆盖的调用图下方。因此RETF需要锚定原型以防止垃圾回收后回收PC。

Bit Ops

移位和循环指令的移位计数以移位类型的位宽为模进行解释，即只有最低的 N 位是有效的。适当的位掩码指令 ( BAND) 被插入到底层机器指令本身不执行掩码的后端。类似地，旋转统一到一个方向，以防架构不为这两个方向提供机器指令。

Arithmetic Ops

所有算术运算都在其类型的域内运行：整数、指针或浮点数。并非所有操作都针对所有可能的类型定义。有符号和无符号整数都会在溢出时回绕。

溢出检查操作在有符号整数算术溢出时退出跟踪。

MOD被分解为浮点数的left-floor(left/right)right。POW要么转换为POW整数作为右操作数，要么转换为 sqrt(left)，如果 right 为 0.5，否则转换为 exp2(log2(left) right)(后端可能稍后将其合并到对 pow() 的调用中)。

的整数变体的未定义情况DIV，MOD并POW 返回仅设置了最高位的整数值。

NEGABS对于浮点数，请在右操作数中引用 SIMD 对齐的常量。一些后端将这些实现为数字和常数的按位异或或与。

的右操作LDEXP数在 x86 和 x64 平台上是浮点数，在所有其他平台上是 32 位整数。

所有浮点算术运算都遵循 IEEE 754 wrt 的标准定义。+-0、+-Inf、NaN 和非规范化。MIN并且MAX对 NaN 操作数没有定义的行为。

FPMATH用于一元浮点算术运算。右操作数指定实际操作：

Memory References

内存引用生成一个指针值，供相应的加载或存储使用。为了保留更高级别的语义并简化别名分析，它们不会分解为较低级别的操作(如XLOAD引用)。其中一些可以(部分)融合到大多数后端的加载或存储指令的操作数中。

AREF并使用其左操作数HREFK引用FLOADLua 表的数组部分或哈希部分。HREF并NEWREF直接引用 Lua 表，因为他们需要搜索或扩展表。 HREFK专用于期望常量键的哈希槽——见KSLOT上面的右操作数。NEWREF假设该键在 Lua 表中尚不存在。

UREFO和UREFC引用当前函数的左操作数(闭包)。右操作数在最低 8 位中保存上值消歧散列，在高位中保存上值索引。

有关 中的字段 ID 的可能值FREF，请参阅 中的 IRFLDEF src/lj_ir.h。

Loads and Stores

加载和存储对内存引用进行操作，并加载一个值(指令的结果)或存储一个值(右操作数)。为了保留更高级别的语义并简化别名分析，它们没有统一或分解为较低级别的操作。

FLOAD并SLOAD内联它们的内存引用，所有其他加载和所有存储都将内存引用作为其左操作数。除了标签值之外的所有加载FLOAD，XLOAD并同时作为一个受保护的断言来检查加载的类型。

FLOAD并FSTORE访问对象内部的特定字段，由其引用的字段 ID 标识(例如，表或用户数据对象中的元表字段)。

XLOAD适用于较低级别的类型，并且内存引用是 a STRREF或分解为较低级别的操作、指针、偏移量或索引的组合 ADD或组合MUL。BSHL

的槽号SLOAD是相对于跟踪的起始帧的，其中#0 表示闭包/帧槽，#1 表示第一个可变槽(对应于字节码的槽 0)。请注意，RETF下移 BASE 和后续SLOAD指令指的是较低帧的插槽。

请注意，堆栈插槽或可变参数插槽没有存储操作。所有堆垛槽的商店都有效地沉入出口或侧面痕迹。快照有效地管理要存储的引用。从被调用的可变参数函数的角度来看，可变参数插槽是只读的。

对于字段 ID 的可能值FLOAD和 和 中的标志 SLOAD，XLOAD请参阅 IRFLDEF、IRSLOAD_* 和 IRXLOAD_* 中 src/lj_ir.h。

Allocations

SNEW仅用于引用保证保持不变的数据，例如其他字符串。这允许在不使用字符串对象的情况下消除分配(它的数据可能仍被使用)。这个假设不适用于由 引用的数据ffi.string()，它必须发出XSNEW。

分配的 cdata 对象的大小CNEW是CNEWI从 ctypeid 操作数推断出来的。对于变长 cdata，大小由大小操作数明确给出，否则大小操作数为 REF_NIL。

CNEWI仅用于不可变的标量 cdata 类型。它结合了分配和初始化。右操作数给出的值被隐式存储。这缩短了 IR 并将分配下沉转变为简单的死代码消除(仅适用于不可变类型 -更涉及通用分配下沉优化)。

Barriers

TBAR并且OBAR是增量 GC 所需的写屏障。 OBAR目前仅用于商店升值。这些障碍被放置在相应的商店之后。

XBAR防止优化XLOAD和XSTORE跨越障碍。请注意，CALLX*隐含地充当这样的屏障。

Type Conversions

的偏置操作数TOBIT引用浮点常数 2^52+2^51，它被添加到 FP 数上。结果的低 32 位表示以 2^32 为模的整数分量(在一定范围内，请参阅Lua BitOp 语义。

flags 操作数的低 5 位CONV指定源类型，接下来的 5 位指定目标类型(与 IR 指令结果类型相同)。第 10 位指定 FP 到整数转换的截断行为，第 11 位指定扩大整数转换的符号扩展。位 12 和 13 指定检查(保护)从双精度数到整数的转换的强度：1 表示任何 FP 数都可以，2 和 3 表示检查 FP 数的整数。2 为索引转换的反向传播启用了特殊规则。

Calls

对内部函数的调用分为三类：

• 正常调用可以像大多数算术运算一样被共同和消除。
• 对于执行加载(例如lj_tabl_len())的调用，编译器必须检查干预存储。
• 无法消除执行存储的调用(但如果这样的优化是有益的，它们可能会被沉没)。

有关 ircall 操作数的可能值，请参阅src/lj_ircall.h。

FFI 发出CALLXS对外部函数的调用。它们通常被认为是商店，不能被淘汰。它们形成了XLOAD和XSTORE指令的隐式优化屏障。

CARGcall 指令的 args 操作数使用扩展指令引用左倾参数树：

• func(): args = REF_NIL
• 函数(arg1)：args = arg1
• 函数(arg1，arg2)：args = CARG(arg1，arg2)
• 函数(arg1，arg2，arg3)：args = CARG(CARG(arg1，arg2)，arg3)
• 等等

func 操作数CALLXS要么直接引用函数CARG指针，要么为非标准调用约定(例如可变参数调用)保存函数指针和 ctypeid。

Miscellaneous Ops

NOP用于修补先前发出的 IR 指令，以防它们无法即时消除或忽略。

BASE是 REF_BASE 处的固定指令，用于保存 BASE 指针。它由 eg 隐式引用SLOAD。

PVAL提供了一种替代方法来引用父跟踪的特定值，这些值不能被父引用SLOAD(因为它们没有存储在快照的堆栈中)。

GCSTEP为某些需要在初始快照之后完成的情况提供显式 GC 步骤。

HIOP必须立即遵循拆分指令(拆分 64 位操作或软 fp 操作)。

USE需要为它们的副作用保留指令，否则这些副作用将被消除：例如ADDOV，用于检查循环边界的潜在整数溢出。

PHI指令位于循环跟踪的末尾。左操作数保存对初始值的引用，右操作数保存对每次循环迭代后的值的引用。

RENAME由寄存器分配器在为某个值重命名寄存器时生成(为了提高效率或保留 PHI 寄存器)。一条 RENAME指令保存用于在给定快照下方引用的寄存器。对于同一个参考，可能会出现多个这种情况。最初引用的指令保存上面使用的最高此类快照(如果有)的寄存器。

字节码优化

单通道解析器将 Lua 源代码转换为 LuaJIT字节码。字节码对动态类型的值进行操作，并且具有非常接近源代码的语义。这就是为什么可以对字节码本身执行相对较少的优化的原因——它们中的大多数都不是动态语言中的有效转换。

类似地，字节码的虚拟寄存器分配紧跟 Lua 源代码中局部变量的作用域。没有尝试最小化或重叠局部变量的生命周期(虚拟寄存器既便宜又充足)。

恒定折叠

对所有算术运算符(+ - * / % ^ 和一元减号)和逻辑运算符执行常量折叠not。如果输入仅由常数组成，则输出也会变成常数。例如，这是字节码return 1.5 * 3：

0001    KNUM     0   0      ; 4.5
0002    RET1     0   2

乘法已被消除，只返回其结果。

优化复合条件

像这样的复合条件表达式x < 10 and x or 10被转换为一系列分支，而不是将中间表达式评估为布尔值。逻辑运算符and永远or不会出现在字节码中。not仅当结果在逻辑结果上下文之外使用时才会出现。例如，这是字节码 return a < b and x or y：

0001    GGET     0   0      ; "a"
0002    GGET     1   1      ; "b"
0003    ISGE     0   1
0004    JMP      0 => 0008
0005    GGET     0   2      ; "x"
0006    IST          0
0007    JMP      1 => 0009
0008 => GGET     0   3      ; "y"
0009 => RET1     0   2

消除条件

如果输入是常数，则可以消除条件。这仅适用于“真实性”测试。例如，这是字节码 return "a" and 99：

0001    KSHORT   0  99
0002    RET1     0   2

"a"已取消对 的真实性的检查。

一个更常见的习语是cond and x or y，它可用作三元条件句。但是行为是不一样的，因为x被评估并且不能是false或nil(或者成语会失败)。然而x ，很多时候是一个常数。例如，这是字节码 return a and 10 or 20：

0001    GGET     0   0      ; "a"
0002    ISF          0
0003    JMP      1 => 0006
0004    KSHORT   0  10
0005    JMP      1 => 0007
0006 => KSHORT   0  20
0007 => RET1     0   2

10已取消对 的真实性的测试。

消除不需要的结果

逻辑运算符计算实际结果，例如print("a" and 99) prints 99。if但是在逻辑结果上下文(例如语句)中不需要此结果。例如，这是字节码 if "a" and 99 then end：

0001    RET0     0   1

条件及其结果已被消除。

不需要的调用结果也被消除：例如，CALL* 指令被修补以不返回任何结果。

跳跃折叠

导致其他跳跃的无条件跳跃被折叠成到最终目标的跳跃。类似地，在作用域结束时关闭 upvalues 通常会跟随一个跳转。然后将跳转折叠到UCLO接受分支目标的 中。

模板表

Lua 可以用作数据描述语言，这通常涉及创建用许多常量初始化的表。不是分配一个空表并生成大量显式存储，而是由解析器生成一个模板表。使用指令可以非常快速地复制模板表TDUP(复制是必要的，因为结果表可能会被修改)。

也允许混合常量和变量初始化器。仅当表构造函数表达式中存在至少一个常量初始值设定项(常量键和常量值)时，才会创建模板表。例如，这是字节码return { foo=1, bar=2, 1,2,x,4 }：

0001    TDUP     0   0
0002    GGET     1   1      ; "x"
0003    TSETB    1   0   3
0004    RET1     0   2

所有常量初始化器都合并到模板表中。只有存储操作t[3] = x保留在字节码中。

指令和操作数专业化

许多字节码指令具有用于常用操作数类型或操作数数量的特殊形式。这降低了调度成本，因为它消除了(通常是不可预测的)实现内部的分支：

• 每种常量类型(和范围)都有专门的常量负载。例如KSTR加载字符串常量。或者KSHORT加载 16 位有符号整数常量，而KNUM加载所有其他数字常量。
• 比较和测试操作员专门针对他们的测试方向。例如，两者都有ISTand ISF，它们会跳到真假上。与出于相同目的使用单个指令和操作数相比，这节省了分派。
• 如果操作数之一是常数，则相等性比较专门针对操作数类型。例如ISEQN，是与数字常量的相等比较。
• 算术指令专门用于在左侧或右侧具有数字常量的常见情况。例如ADDVN，右边是一个数字常数的加法。
• 设置上值是专门针对操作数类型的。例如USETN用于存储数字常数。
• 索引操作专门针对 getter 和 setter 以及索引操作数类型和范围。例如TGETB，用于具有常量整数索引 0 到 255 的加载，或者TSETS用于具有常量字符串键的存储。
• 调用专门分为常规调用CALL和尾调用CALLT。
• 返回 0 或 1 个结果，使用RET0或RET1代替泛型RET。
• 使用多个结果的调用、返回和表初始值设定项是专门的。例如CALLM，是一个将多个结果作为参数传递的调用。
• 每种类型的循环都使用自己专门的字节码指令。例如，*FOR*指令用于数字“for”循环。
• 循环使用pairs()使用专门的ISNEXT和ITERN指令。
• 函数头专门用于固定参数与可变参数函数以及 Lua 函数与 C 函数与快速函数。例如FUNCV，是 vararg Lua 函数的函数头。

有关更多详细信息，请参阅字节码指令的描述。

SSA IR 优化

去做

TRACE：区域选择

NLF：自然循环优先

热点检测

处罚和黑名单

函数内联

尾声消除

递归展开

控制流优化

记录：跟踪记录

即时 SSA 转换

构造不可变的上值

升值别名分析

数据流分析

稀疏快照

一维快照压缩

控制流专业化

哈希键专业化

快速函数内联

字节码修补

折叠：折叠引擎

恒定折叠

代数简化

强度降低

重新关联

CSE：通用子表达式消除

ABC：数组边界检查消除

标量演化分析

NARROW：缩小

缩小整数转换

算术运算符的缩窄

归纳变量的预测缩小

消除溢出检查

MEM：内存访问优化

AA：别名分析

ESC：逃逸分析

索引重新关联

FWD：加载转发、存储转发

DSE：死店消除

读取-修改-写入简化

LOOP：循环优化

DCE：死代码消除

通过合成展开的循环不变提升

PHI 消除

不稳定的循环展开

SPLIT：指令拆分

FFI64：64 位指令拆分

SOFTFP：FP 值拆分和软浮点调用

SINK：分配下沉和存储下沉

如果可能，分配下沉和存储下沉尝试消除代码快速路径中的临时分配。

详细信息可以在这里找到：分配下沉优化

ASM：汇编器后端

反向代码生成

DCE：即时死码消除

线性扫描寄存器分配

注册提示

注册重命名

注册合并

PHI 寄存器洗牌

重新实现

不断合成

溢出和恢复调度

循环反转

循环对齐

GC 步骤消除

FUSE：操作数融合

教学专业化

指令结合

机器码补丁

以上是官方文档没有内容，不是没有翻译

非公开 jit.* API

LuaJIT 有一些未记录的工具用于跟踪程序执行以及跟踪编译器正在做什么。下面的内容有点粗糙、不准确、可能会发生变化并且非常不完整。这可能是没有记录的一个很好的理由。

这些函数在几个 -j 库文件中使用。 dump.lua可能是一个很好的起点。

jit.attach

您可以使用jit.attach. 可以调用回调：

• 当一个函数被编译为字节码(“bc”)；
• 当跟踪记录开始或停止时(“跟踪”)；
• 正在记录痕迹(“记录”)；
• 或者当跟踪通过侧出口(“texit”)退出时。

设置回调jit.attach(callback, "event")并清除相同的回调jit.attach(callback)

传递给回调的参数取决于所报告的事件：

• “bc”：callback(func)。func是刚刚录制的函数。
• “trace”：callback(what, tr, func, pc, otr, oex)
  • what是对跟踪事件的描述：“flush”、“start”、“stop”、“abort”。适用于所有活动。
  • tr是跟踪号。不可用于冲洗。
  • func是被跟踪的函数。可用于启动和中止。
  • pc是程序计数器 - 被记录的函数的字节码编号(如果这是一个 Lua 函数)。可用于启动和中止。
  • otr开始：父跟踪号，如果这是边跟踪，中止：中止代码(整数)？
  • oexstart：父跟踪的退出号，abort：中止原因(字符串)
• “record”：callback(tr, func, pc, depth)。第一个参数与跟踪启动相同。depth是当前字节码的内联深度。
• “texit”：callback(tr, ex, ngpr, nfpr)。
  • tr是跟以前一样的跟踪号
  • ex是出口号
  • ngpr和nfpr是在出口处活动的通用和浮点寄存器的数量。

jit.util.funcinfo(func, pc)

当从回调中传递时， func返回一个关于函数的信息表，很像.pcjit.attachjit.util.funcinfodebug.getinfo

该表的字段是：

• linedefined: 至于debug.getinfo
• lastlinedefined: 至于debug.getinfo
• params: 函数接受的参数个数
• stackslots: 函数局部变量使用的栈槽数
• upvalues：函数使用的上值数
• bytecodes: 编译函数的字节码数
• gcconsts: ??
• nconsts: ??
• currentline: 至于debug.getinfo
• isvararg：如果函数是可变参数函数`
• source: 至于debug.getinfo
• loc: 描述源和当前行的字符串，如 "<source>:<line>"
• ffid: 函数的快速函数 id(如果它是一个)。在这种情况下，只有upvalues上面和addr下面是有效的
• addr: 函数的地址(如果不是 Lua 函数)。如果它是 C 函数而不是快速函数，upvalues则仅上述有效

新的垃圾收集器

if (!obj->grey) setGrey(obj); void setGrey(obj){ obj->grey = true; if (isBlack(obj)){ // if black state has been split as suggested above, also // need to check that it's not already on the mark stack push(obj); } }

local x, z = 0, nil for i=1,100 do local t = {i} if i == 90 then z = t end x = x + t[1] end print(x, z[1])

....        SNAP   #4   [ ---- 0009 ---- 0010 ---- ---- 0010 ]
0012 ------ LOOP ------------
0013 >  tab TNEW   #3    #0
0014    p32 FLOAD  0013  tab.array
0015    p32 AREF   0014  +1
0016    num CONV   0010  num.int
0017    num ASTORE 0015  0016
....        SNAP   #5   [ ---- 0009 ---- 0010 ---- ---- 0010 0013 ]
0018 >  int NE     0010  +90
0019  + num ADD    0016  0009
0020  + int ADD    0010  +1
....        SNAP   #6   [ ---- 0019 ---- ]
0021 >  int LE     0020  +100
0022    int PHI    0010  0020
0023    num PHI    0009  0019

local x, z = 0, nil | local x, z = 0, nil for i=1,100 do | for i=1,100 do local t = {i} | ---. if i == 90 then | if i == 90 then | | local t = {i} <--´ z = t | z = t | end | end | x = x + t[1] | x = x + i <--´ end | end print(x, z[1]) | print(x, z[1]) 

....        SNAP   #4   [ ---- 0005 ---- 0006 ---- ---- 0006 ]
0008 ------ LOOP ------------
....        SNAP   #5   [ ---- 0005 ---- 0006 ---- ---- 0006 ]
0009 >  int NE     0006  +90
0010    num CONV   0006  num.int
0011  + num ADD    0010  0005
0012  + int ADD    0006  +1
....        SNAP   #6   [ ---- 0011 ---- ]
0013 >  int LE     0012  +100
0014    int PHI    0006  0012
0015    num PHI    0005  0011

local x, z = 0, nil for i=1,100 do local t = {i} if i == 90 then z = t end x = x + t[1] end print(x, z[1])

....              SNAP   #4   [ ---- 0009 ---- 0010 ---- ---- 0010 ]
0012 ------------ LOOP ------------
0013  {sink}  tab TNEW   #3    #0
0014          p32 FLOAD  0013  tab.array
0015          p32 AREF   0014  +1
0016 xmm6     num CONV   0010  num.int
0017  {0013}  num ASTORE 0015  0016
....              SNAP   #5   [ ---- 0009 ---- 0010 ---- ---- 0010 0013 ]
0018       >  int NE     0010  +90
0019 xmm7   + num ADD    0016  0009
0020 rbp    + int ADD    0010  +1
....              SNAP   #6   [ ---- 0019 ---- ]
0021       >  int LE     0020  +100
0022 rbp      int PHI    0010  0020
0023 xmm7     num PHI    0009  0019

->LOOP:
394cffd0  xorps xmm6, xmm6
394cffd3  cvtsi2sd xmm6, ebp
394cffd7  cmp ebp, +0x5a
394cffda  jz 0x394c0024 ->5
394cffe0  addsd xmm7, xmm6
394cffe4  add ebp, +0x01
394cffe7  cmp ebp, +0x64
394cffea  jle 0x394cffd0 ->LOOP
394cffec  jmp 0x394c0028 ->6

local z = nil
for i=1,200 do local t = {i} if i > 100 then if i == 190 then z = t end end end print(z[1])

....        SNAP   #0   [ ---- ]
0001    int SLOAD  #2    CI
0002 }  tab TNEW   #3    #0
0003    p32 FLOAD  0002  tab.array
0004    p32 AREF   0003  +1
0005    num CONV   0001  num.int
0006 }  num ASTORE 0004  0005
....        SNAP   #1   [ ---- ---- 0001 ---- ---- 0001 0002 ]
0007 >  int LE     0001  +100
0008  + int ADD    0001  +1
....        SNAP   #2   [ ---- ---- ]
0009 >  int LE     0008  +200
....        SNAP   #3   [ ---- ---- 0008 ---- ---- 0008 ]
0010 ------ LOOP ------------
0011 }  tab TNEW   #3    #0
0012    p32 FLOAD  0011  tab.array
0013    p32 AREF   0012  +1
0014    num CONV   0008  num.int
0015 }  num ASTORE 0013  0014
....        SNAP   #4   [ ---- ---- 0008 ---- ---- 0008 0011 ]
0016 >  int LE     0008  +100
0017  + int ADD    0008  +1
....        SNAP   #5   [ ---- ---- ]
0018 >  int LE     0017  +200
0019    int PHI    0008  0017

0001    int SLOAD  #2    PI
0002 }  tab TNEW   #3    #0
0003    p32 FLOAD  0002  tab.array
0004    p32 AREF   0003  +1
0005    num CONV   0001  num.int
0006 }  num ASTORE 0004  0005
....        SNAP   #0   [ ---- ---- 0001 ---- ---- 0001 0002 ]
0007 >  nil GCSTEP
....        SNAP   #1   [ ---- ---- 0001 ---- ---- ---- 0002 ]
0008 >  int NE     0001  +190
0009    int ADD    0001  +1
....        SNAP   #2   [ ---- ---- ]
0010 >  int LE     0009  +200
0011    num CONV   0009  num.int
....        SNAP   #3   [ ---- ---- 0011 ---- ---- 0011 ]

local point
point = { new = function(self, x, y) return setmetatable({x=x, y=y}, self) end, __add = function(a, b) return point:new(a.x + b.x, a.y + b.y) end, } point.__index = point local a, b = point:new(1.5, 2.5), point:new(3.25, 4.75) for i=1,100000000 do a = (a + b) + b end print(a.x, a.y) 

->LOOP:
394cffe0  addsd xmm6, xmm1
394cffe4  addsd xmm7, xmm0
394cffe8  addsd xmm6, xmm1
394cffec  addsd xmm7, xmm0
394cfff0  add ebp, +0x01
394cfff3  cmp ebp, 0x05f5e100
394cfff9  jle 0x394cffe0 ->LOOP
394cfffb  jmp 0x394c0028 ->6

local ffi = require("ffi") local point point = ffi.metatype("struct { double x, y; }", { __add = function(a, b) return point(a.x + b.x, a.y + b.y) end }) local a, b = point(1.5, 2.5), point(3.25, 4.75) for i=1,100000000 do a = (a + b) + b end print(a.x, a.y)

#include <iostream>class Point {
public: Point(double x, double y) : x(x), y(y) { } Point operator+(const Point &b) const { return Point(x+b.x, y+b.y); } double x, y; }; int main() { int i; Point a(1.5, 2.5), b(3.25, 4.75); for (i = 0; i < 100000000; i++) a = (a + b) + b; std::cout << a.x << ' ' << a.y << '\n'; return 0; }

public class Point {public double x, y; public Point(double x0, double y0) { x = x0; y = y0; } public Point add(Point b) { return new Point(x + b.x, y + b.y); } public static void main(String args[]) { int i; Point a = new Point(1.5, 2.5); Point b = new Point(2.25, 4.75); for (i = 0; i < 100000000; i++) a = a.add(b).add(b); System.out.println(a.x + " " + a.y); } }

chunk ::= {stat [`;´]} [laststat [`;´]]block ::= chunkstat ::=  varlist `=´ explist | functioncall | lua52_label |`do´ block `end´ | `while´ exp `do´ block `end´ | `repeat´ block `until´ exp | `if´ exp `then´ block {`elseif´ exp `then´ block} [`else´ block] `end´ | `for´ Name `=´ exp `,´ exp [`,´ exp] `do´ block `end´ | `for´ namelist `in´ explist `do´ block `end´ | `function´ funcname funcbody | `local´ `function´ Name funcbody | `local´ namelist [`=´ explist] laststat ::= `return´ [explist] | `break´ | lua52_gotolua52_goto ::= `goto´ Namelua52_label ::= ‘::’ Name ‘::’funcname ::= Name {`.´ Name} [`:´ Name]varlist ::= var {`,´ var}var ::=  Name | prefixexp `[´ exp `]´ | prefixexp `.´ Name namelist ::= Name {`,´ Name}explist ::= {exp `,´} expexp ::=  `nil´ | `false´ | `true´ | numeric | String | `...´ | function | prefixexp | tableconstructor | exp binop exp | unop exp numeric ::= FFI_Int64 | FFI_Uint64 | FFI_Imaginary | Numberprefixexp ::= var | functioncall | `(´ exp `)´functioncall ::=  prefixexp args | prefixexp `:´ Name args args ::=  `(´ [explist] `)´ | tableconstructor | String function ::= `function´ funcbodyfuncbody ::= `(´ [parlist] `)´ block `end´parlist ::= namelist [`,´ `...´] | `...´tableconstructor ::= `{´ [fieldlist] `}´fieldlist ::= field {fieldsep field} [fieldsep]field ::= `[´ exp `]´ `=´ exp | Name `=´ exp | expfieldsep ::= `,´ | `;´binop ::= `+´ | `-´ | `*´ | `/´ | `^´ | `%´ | `..´ | `<´ | `<=´ | `>´ | `>=´ | `==´ | `~=´ | `and´ | `or´unop ::= `-´ | `not´ | `#´