LuaJIT

The LuaJIT project was started in 2005 by developer Mike Pall, released under the MIT open source license.[4]

The second major release of the compiler, 2.0.0, featured major performance increases.[5]

The latest release, 2.0.5 is released in 2017. However, Mike Pall, the creator and maintainer recommends using the tip of the v2.1 branch, and does not believe in releases.[6]

• CERN, for their Methodical Accelerator Design 'next-generation' software for describing and simulating particle accelerators[7]
• OpenResty, a fork of nginx with Lua scripting[8]
• Kong, a web API gateway[9]
• Cloudflare, who use LuaJIT in their web application firewall service[10]

LuaJIT is often the fastest Lua runtime.[11] LuaJIT has also been named the fastest implementation of a dynamic programming language.[12][13]

LuaJIT includes a Foreign Function Interface compatible with C data structures. Its use is encouraged for numerical computation.[14]

-- Loop with if-statement

local x = 0

for i=1,1e4 do
    x = x + 11
    if i%10 == 0 then -- if-statement
        x = x + 22
    end
    x = x + 33
end

---- TRACE 1 start Ex.lua:5
---- TRACE 1 IR
0001 int SLOAD #2 CI
0002 > num SLOAD #1 T
0003 num ADD 0002 +11
0004 int MOD 0001 +10
0005 > int NE 0004 +0
0006 + num ADD 0003 +33
0007 + int ADD 0001 +1
0008 > int LE 0007 +10000
0009 ------ LOOP ------------
0010 num ADD 0006 +11
0011 int MOD 0007 +10
0012 > int NE 0011 +0
0013 + num ADD 0010 +33
0014 + int ADD 0007 +1
0015 > int LE 0014 +10000
0016 int PHI 0007 0014
0017 num PHI 0006 0013
---- TRACE 1 stop -> loop
---- TRACE 2 start 1/4 Ex.lua:8
---- TRACE 2 IR
0001 num SLOAD #1 PI
0002 int SLOAD #2 PI
0003 num ADD 0001 +22
0004 num ADD 0003 +33
0005 int ADD 0002 +1
0006 > int LE 0005 +10000
0007 num CONV 0005 num.int
---- TRACE 2 stop -> 1

LuaJIT adds several extensions to its base implementation, Lua 5.1, most of which do not break compatibility.[16]

• "BitOp" for binary operations on unsigned 32-bit integers (these operations are also compiled by the just-in-time compiler)[17]
• "CoCo", which allows the VM to be fully resumable across all contexts[18]
• A foreign function interface[19]
• Portable bytecode (regardless of architecture, word size, or endianness, not version)[20]

DynASM is a lightweight preprocessor for C which was created for LuaJIT 1.0.0 to make developing the just-in-time compiler easier. DynASM replaces assembly code in C files with runtime writes to a 'code buffer', such that a developer may generate and then evoke code at runtime from a C program.

DynASM was phased out in LuaJIT 2.0.0 after a complete rewrite of the assembler, but remains in use by the LuaJIT contributors as a better assembly syntax for the LuaJIT interpreter.

DynASM includes a bare-bones C header file which is used at compile time for logic the preprocessor generates. The actual preprocessor is written in Lua.

|.type L,      lua_State,  esi  // L.
|.type BASE,   TValue,     ebx  // L->base.
|.type TOP,    TValue,     edi  // L->top.
|.type CI,     CallInfo,   ecx  // L->ci.
|.type LCL,    LClosure,   eax  // L->ci->func->value.
|.type UPVAL,  UpVal

|.macro copyslot, D, S, R1, R2, R3
|  mov R1, S.value;  mov R2, S.value.na[1];  mov R3, S.tt
|  mov D.value, R1;  mov D.value.na[1], R2;  mov D.tt, R3
|.endmacro

|.macro copyslot, D, S;  copyslot D, S, ecx, edx, eax; .endmacro

|.macro getLCL, reg
||if (!J->pt->is_vararg) {
|  mov LCL:reg, BASE[-1].value
||} else {
|  mov CI, L->ci
|  mov TOP, CI->func
|  mov LCL:reg, TOP->value
||}
|.endmacro

|.macro getLCL;  getLCL eax; .endmacro

[...]

static void jit_op_getupval(jit_State *J, int dest, int uvidx)
{
  |  getLCL
  |  mov UPVAL:ecx, LCL->upvals[uvidx]
  |  mov TOP, UPVAL:ecx->v
  |  copyslot BASE[dest], TOP[0]
}