LuaJIT Change History

LuaJIT 2.1.0-beta3 — 2017-05-01

• Rewrite memory block allocator.
• Add various extension from Lua 5.2/5.3.
• Remove old Lua 5.0 compatibility defines.
• Set arg table before evaluating LUA_INIT and -e chunks.
• Fix FOLD rules for math.abs() and FP negation.
• Fix soft-float math.abs() and negation.
• Fix formatting of some small denormals at low precision.
• LJ_GC64: Add JIT compiler support.
• x64/LJ_GC64: Add JIT compiler backend.
• x86/x64: Generate BMI2 shifts and rotates, if available.
• Windows/x86: Add full exception interoperability.
• ARM64: Add big-endian support.
• ARM64: Add JIT compiler backend.
• MIPS: Fix TSETR barrier.
• MIPS: Support MIPS16 interlinking.
• MIPS soft-float: Fix code generation for HREF.
• MIPS64: Add MIPS64 hard-float JIT compiler backend.
• MIPS64: Add MIPS64 hard-float/soft-float support to interpreter.
• FFI: Compile bitfield loads/stores.
• Various fixes common with the 2.0 branch.

LuaJIT 2.1.0-beta2 — 2016-03-03

• Enable trace stitching.
• Use internal implementation for converting FP numbers to strings.
• Parse Unicode escape '\u{XX...}' in string literals.
• Add MIPS soft-float support.
• Switch MIPS port to dual-number mode.
• x86/x64: Add support for AES-NI, AVX and AVX2 to DynASM.
• FFI: Add ssize_t declaration.
• FFI: Parse #line NN and #NN.
• Various minor fixes.

LuaJIT 2.1.0-beta1 — 2015-08-25

This is a brief summary of the major changes in LuaJIT 2.1 compared to 2.0. Please take a look at the commit history for more details.

• Changes to the VM core:
  • Add low-overhead profiler (-jp).
  • Add LJ_GC64 mode: 64 bit GC object references (really: 47 bit). Interpreter-only for now.
  • Add LJ_FR2 mode: Two-slot frame info. Required by LJ_GC64 mode.
  • Add table.new() and table.clear().
  • Parse binary number literals (0bxxx).
• Improvements to the JIT compiler:
  • Add trace stitching (disabled for now).
  • Compile various builtins: string.char(), string.reverse(), string.lower(), string.upper(), string.rep(), string.format(), table.concat(), bit.tohex(), getfenv(0), debug.getmetatable().
  • Compile string.find() for fixed string searches (no patterns).
  • Compile BC_TSETM, e.g. {1,2,3,f()}.
  • Compile string concatenations (BC_CAT).
  • Compile __concat metamethod.
  • Various minor optimizations.
• Internal Changes:
  • Add support for embedding LuaJIT bytecode for builtins.
  • Replace various builtins with embedded bytecode.
  • Refactor string buffers and string formatting.
  • Remove obsolete non-truncating number to integer conversions.
• Ports:
  • Add Xbox One port (LJ_GC64 mode).
  • ARM64: Add port of the interpreter (LJ_GC64 mode).
  • x64: Add separate port of the interpreter to LJ_GC64 mode.
  • x86/x64: Drop internal x87 math functions. Use libm functions.
  • x86: Remove x87 support from interpreter. SSE2 is mandatory now.
  • PPC/e500: Drop support for this architecture.
• FFI library:
  • FFI: Add 64 bit bitwise operations.
  • FFI: Compile VLA/VLS and large cdata allocations with default initialization.
  • FFI: Compile conversions from functions to function pointers.
  • FFI: Compile lightuserdata to void * conversion.
  • FFI: Compile ffi.gc(cdata, nil), too.
  • FFI: Add ffi.typeinfo().

LuaJIT 2.0.5 — 2017-05-01

• Add workaround for MSVC 2015 stdio changes.
• Limit mcode alloc probing, depending on the available pool size.
• Fix overly restrictive range calculation in mcode allocation.
• Fix out-of-scope goto handling in parser.
• Remove internal __mode = "K" and replace with safe check.
• Add "proto" field to jit.util.funcinfo().
• Fix GC step size calculation.
• Initialize uv->immutable for upvalues of loaded chunks.
• Fix for cdata vs. non-cdata arithmetics/comparisons.
• Drop leftover regs in 'for' iterator assignment, too.
• Fix PHI remarking in SINK pass.
• Don't try to record outermost pcall() return to lower frame.
• Add guard for obscure aliasing between open upvalues and SSA slots.
• Remove assumption that lj_math_random_step() doesn't clobber FPRs.
• Fix handling of non-numeric strings in arithmetic coercions.
• Fix recording of select(n, ...) with off-trace varargs
• Fix install for cross-builds.
• Don't allocate unused 2nd result register in JIT compiler backend.
• Drop marks from replayed instructions when sinking.
• Fix unsinking check.
• Properly handle OOM in trace_save().
• Limit number of arguments given to io.lines() and fp:lines().
• Fix narrowing of TOBIT.
• OSX: Fix build with recent XCode.
• x86/x64: Don't spill an explicit REF_BASE in the IR.
• x86/x64: Fix instruction length decoder.
• x86/x64: Search for exit jumps with instruction length decoder.
• ARM: Fix BLX encoding for Thumb interworking calls.
• MIPS: Don't use RID_GP as a scratch register.
• MIPS: Fix emitted code for U32 to float conversion.
• MIPS: Backport workaround for compact unwind tables.
• MIPS: Fix cross-endian jit.bcsave.
• MIPS: Fix BC_ISNEXT fallback path.
• MIPS: Fix use of ffgccheck delay slots in interpreter.
• FFI: Fix FOLD rules for int64_t comparisons.
• FFI: Fix SPLIT pass for CONV i64.u64.
• FFI: Fix ipairs() recording.
• FFI: Don't propagate qualifiers into subtypes of complex.

LuaJIT 2.0.4 — 2015-05-14

• Fix stack check in narrowing optimization.
• Fix Lua/C API typecheck error for special indexes.
• Fix string to number conversion.
• Fix lexer error for chunks without tokens.
• Don't compile IR_RETF after CALLT to ff with-side effects.
• Fix BC_UCLO/BC_JMP join optimization in Lua parser.
• Fix corner case in string to number conversion.
• Gracefully handle lua_error() for a suspended coroutine.
• Avoid error messages when building with Clang.
• Fix snapshot #0 handling for traces with a stack check on entry.
• Fix fused constant loads under high register pressure.
• Invalidate backpropagation cache after DCE.
• Fix ABC elimination.
• Fix debug info for main chunk of stripped bytecode.
• Fix FOLD rule for string.sub(s, ...) == k.
• Fix FOLD rule for STRREF of SNEW.
• Fix frame traversal while searching for error function.
• Prevent GC estimate miscalculation due to buffer growth.
• Prevent adding side traces for stack checks.
• Fix top slot calculation for snapshots with continuations.
• Fix check for reuse of SCEV results in FORL.
• Add PS Vita port.
• Fix compatibility issues with Illumos.
• Fix DragonFly build (unsupported).
• OpenBSD/x86: Better executable memory allocation for W^X mode.
• x86: Fix argument checks for ipairs() iterator.
• x86: lj_math_random_step() clobbers XMM regs on OSX Clang.
• x86: Fix code generation for unused result of math.random().
• x64: Allow building with LUAJIT_USE_SYSMALLOC and LUAJIT_USE_VALGRIND.
• x86/x64: Fix argument check for bit shifts.
• x86/x64: Fix code generation for fused test/arith ops.
• ARM: Fix write barrier check in BC_USETS.
• PPC: Fix red zone overflow in machine code generation.
• PPC: Don't use mcrxr on PPE.
• Various archs: Fix excess stack growth in interpreter.
• FFI: Fix FOLD rule for TOBIT + CONV num.u32.
• FFI: Prevent DSE across ffi.string().
• FFI: No meta fallback when indexing pointer to incomplete struct.
• FFI: Fix initialization of unions of subtypes.
• FFI: Fix cdata vs. non-cdata arithmetic and comparisons.
• FFI: Fix __index/__newindex metamethod resolution for ctypes.
• FFI: Fix compilation of reference field access.
• FFI: Fix frame traversal for backtraces with FFI callbacks.
• FFI: Fix recording of indexing a struct pointer ctype object itself.
• FFI: Allow non-scalar cdata to be compared for equality by address.
• FFI: Fix pseudo type conversions for type punning.

LuaJIT 2.0.3 — 2014-03-12

• Add PS4 port.
• Add support for multilib distro builds.
• Fix OSX build.
• Fix MinGW build.
• Fix Xbox 360 build.
• Improve ULOAD forwarding for open upvalues.
• Fix GC steps threshold handling when called by JIT-compiled code.
• Fix argument checks for math.deg() and math.rad().
• Fix jit.flush(func|true).
• Respect jit.off(func) when returning to a function, too.
• Fix compilation of string.byte(s, nil, n).
• Fix line number for relocated bytecode after closure fixup
• Fix frame traversal for backtraces.
• Fix ABC elimination.
• Fix handling of redundant PHIs.
• Fix snapshot restore for exit to function header.
• Fix type punning alias analysis for constified pointers
• Fix call unroll checks in the presence of metamethod frames.
• Fix initial maxslot for down-recursive traces.
• Prevent BASE register coalescing if parent uses IR_RETF.
• Don't purge modified function from stack slots in BC_RET.
• Fix recording of BC_VARG.
• Don't access dangling reference to reallocated IR.
• Fix frame depth display for bytecode dump in -jdump.
• ARM: Fix register allocation when rematerializing FPRs.
• x64: Fix store to upvalue for lightuserdata values.
• FFI: Add missing GC steps for callback argument conversions.
• FFI: Properly unload loaded DLLs.
• FFI: Fix argument checks for ffi.string().
• FFI/x64: Fix passing of vector arguments to calls.
• FFI: Rehash finalizer table after GC cycle, if needed.
• FFI: Fix cts->L for cdata unsinking in snapshot restore.

LuaJIT 2.0.2 — 2013-06-03

• Fix memory access check for fast string interning.
• Fix MSVC intrinsics for older versions.
• Add missing GC steps for io.* functions.
• Fix spurious red zone overflows in machine code generation.
• Fix jump-range constrained mcode allocation.
• Inhibit DSE for implicit loads via calls.
• Fix builtin string to number conversion for overflow digits.
• Fix optional argument handling while recording builtins.
• Fix optional argument handling in table.concat().
• Add partial support for building with MingW64 GCC 4.8-SEH.
• Add missing PHI barrier to string.sub(str, a, b) == kstr FOLD rule.
• Fix compatibility issues with Illumos.
• ARM: Fix cache flush/sync for exit stubs of JIT-compiled code.
• MIPS: Fix cache flush/sync for JIT-compiled code jump area.
• PPC: Add plt suffix for external calls from assembler code.
• FFI: Fix snapshot substitution in SPLIT pass.
• FFI/x86: Fix register allocation for 64 bit comparisons.
• FFI: Fix tailcall in lowest frame to C function with bool result.
• FFI: Ignore long type specifier in ffi.istype().
• FFI: Fix calling conventions for 32 bit OSX and iOS simulator (struct returns).
• FFI: Fix calling conventions for ARM hard-float EABI (nested structs).
• FFI: Improve error messages for arithmetic and comparison operators.
• FFI: Insert no-op type conversion for pointer to integer cast.
• FFI: Fix unroll limit for ffi.fill().
• FFI: Must sink XBAR together with XSTOREs.
• FFI: Preserve intermediate string for const char * conversion.

LuaJIT 2.0.1 — 2013-02-19

• Don't clear frame for out-of-memory error.
• Leave hook when resume catches error thrown from hook.
• Add missing GC steps for template table creation.
• Fix discharge order of comparisons in Lua parser.
• Improve buffer handling for io.read().
• OSX: Add support for Mach-O object files to -b option.
• Fix PS3 port.
• Fix/enable Xbox 360 port.
• x86/x64: Always mark ref for shift count as non-weak.
• x64: Don't fuse implicitly 32-to-64 extended operands.
• ARM: Fix armhf call argument handling.
• ARM: Fix code generation for integer math.min/math.max.
• PPC/e500: Fix lj_vm_floor() for Inf/NaN.
• FFI: Change priority of table initializer variants for structs.
• FFI: Fix code generation for bool call result check on x86/x64.
• FFI: Load FFI library on-demand for bytecode with cdata literals.
• FFI: Fix handling of qualified transparent structs/unions.

LuaJIT 2.0.0 — 2012-11-08

• Correctness and completeness:
  • Fix Android/x86 build.
  • Fix recording of equality comparisons with __eq metamethods.
  • Fix detection of immutable upvalues.
  • Replace error with PANIC for callbacks from JIT-compiled code.
  • Fix builtin string to number conversion for INT_MIN.
  • Don't create unneeded array part for template tables.
  • Fix CONV.num.int sinking.
  • Don't propagate implicitly widened number to index metamethods.
  • ARM: Fix ordered comparisons of number vs. non-number.
  • FFI: Fix code generation for replay of sunk float fields.
  • FFI: Fix signedness of bool.
  • FFI: Fix recording of bool call result check on x86/x64.
  • FFI: Fix stack-adjustment for __thiscall callbacks.

LuaJIT 2.0.0-beta11 — 2012-10-16

• New features:
  • Use ARM VFP instructions, if available (build-time detection).
  • Add support for ARM hard-float EABI (armhf).
  • Add PS3 port.
  • Add many features from Lua 5.2, e.g. goto/labels. Refer to this list.
  • FFI: Add parameterized C types.
  • FFI: Add support for copy constructors.
  • FFI: Equality comparisons never raise an error (treat as unequal instead).
  • FFI: Box all accessed or returned enums.
  • FFI: Check for __new metamethod when calling a constructor.
  • FFI: Handle __pairs/__ipairs metamethods for cdata objects.
  • FFI: Convert io.* file handle to FILE * pointer (but as a void *).
  • FFI: Detect and support type punning through unions.
  • FFI: Improve various error messages.
• Build-system reorganization:
  • Reorganize directory layout:
    lib/* → src/jit/*
    src/buildvm_*.dasc → src/vm_*.dasc
    src/buildvm_*.h → removed
    src/buildvm* → src/host/*
  • Add minified Lua interpreter plus Lua BitOp (minilua) to run DynASM.
  • Change DynASM bit operations to use Lua BitOp
  • Translate only vm_*.dasc for detected target architecture.
  • Improve target detection for msvcbuild.bat.
  • Fix build issues on Cygwin and MinGW with optional MSys.
  • Handle cross-compiles with FPU/no-FPU or hard-fp/soft-fp ABI mismatch.
  • Remove some library functions for no-JIT/no-FFI builds.
  • Add uninstall target to top-level Makefile.
• Correctness and completeness:
  • Preserve snapshot #0 PC for all traces.
  • Fix argument checks for coroutine.create().
  • Command line prints version and JIT status to stdout, not stderr.
  • Fix userdata __gc separations at Lua state close.
  • Fix TDUP to HLOAD forwarding for LJ_DUALNUM builds.
  • Fix buffer check in bytecode writer.
  • Make os.date() thread-safe.
  • Add missing declarations for MSVC intrinsics.
  • Fix dispatch table modifications for return hooks.
  • Workaround for MSVC conversion bug (double → uint32_t → int32_t).
  • Fix FOLD rule (i-j)-i => 0-j.
  • Never use DWARF unwinder on Windows.
  • Fix shrinking of direct mapped blocks in builtin allocator.
  • Limit recursion depth in string.match() et al.
  • Fix late despecialization of ITERN after loop has been entered.
  • Fix 'f' and 'L' options for debug.getinfo() and lua_getinfo().
  • Fix package.searchpath().
  • OSX: Change dylib names to be consistent with other platforms.
  • Android: Workaround for broken sprintf("%g", -0.0).
  • x86: Remove support for ancient CPUs without CMOV (before Pentium Pro).
  • x86: Fix register allocation for calls returning register pair.
  • x86/x64: Fix fusion of unsigned byte comparisons with swapped operands.
  • ARM: Fix tonumber() argument check.
  • ARM: Fix modulo operator and math.floor()/math.ceil() for inf/nan.
  • ARM: Invoke SPLIT pass for leftover IR_TOBIT.
  • ARM: Fix BASE register coalescing.
  • PPC: Fix interpreter state setup in callbacks.
  • PPC: Fix string.sub() range check.
  • MIPS: Support generation of MIPS/MIPSEL bytecode object files.
  • MIPS: Fix calls to floor()/ceil()/trunc().
  • ARM/PPC: Detect more target architecture variants.
  • ARM/PPC/e500/MIPS: Fix tailcalls from fast functions, esp. tostring().
  • ARM/PPC/MIPS: Fix rematerialization of FP constants.
  • FFI: Don't call FreeLibrary() on our own EXE/DLL.
  • FFI: Resolve metamethods for constructors, too.
  • FFI: Properly disable callbacks on iOS (would require executable memory).
  • FFI: Fix cdecl string parsing during recording.
  • FFI: Show address pointed to for tostring(ref), too.
  • FFI: Fix alignment of C call argument/return structure.
  • FFI: Initialize all fields of standard types.
  • FFI: Fix callback handling when new C types are declared in callback.
  • FFI: Fix recording of constructors for pointers.
  • FFI: Always resolve metamethods for pointers to structs.
  • FFI: Correctly propagate alignment when interning nested types.
• Structural and performance enhancements:
  • Add allocation sinking and store sinking optimization.
  • Constify immutable upvalues.
  • Add builtin string to integer or FP number conversion. Improves cross-platform consistency and correctness.
  • Create string hash slots in template tables for non-const values, too. Avoids later table resizes.
  • Eliminate HREFK guard for template table references.
  • Add various new FOLD rules.
  • Don't use stack unwinding for lua_yield() (slow on x64).
  • ARM, PPC, MIPS: Improve XLOAD operand fusion and register hinting.
  • PPC, MIPS: Compile math.sqrt() to sqrt instruction, if available.
  • FFI: Fold KPTR + constant offset in SPLIT pass.
  • FFI: Optimize/inline ffi.copy() and ffi.fill().
  • FFI: Compile and optimize array/struct copies.
  • FFI: Compile ffi.typeof(cdata|ctype), ffi.sizeof(), ffi.alignof(), ffi.offsetof() and ffi.gc().

LuaJIT 2.0.0-beta10 — 2012-05-09

• New features:
  • The MIPS of LuaJIT is complete. It requires a CPU conforming to the MIPS32 R1 architecture with hardware FPU. O32 hard-fp ABI, little-endian or big-endian.
  • Auto-detect target arch via cross-compiler. No need for TARGET=arch anymore.
  • Make DynASM compatible with Lua 5.2.
  • From Lua 5.2: Try __tostring metamethod on non-string error messages..
• Correctness and completeness:
  • Fix parsing of hex literals with exponents.
  • Fix bytecode dump for certain number constants.
  • Fix argument type in error message for relative arguments.
  • Fix argument error handling on Lua stacks without a frame.
  • Add missing mcode limit check in assembler backend.
  • Fix compilation on OpenBSD.
  • Avoid recursive GC steps after GC-triggered trace exit.
  • Replace <unwind.h> definitions with our own.
  • Fix OSX build issues. Bump minimum required OSX version to 10.4.
  • Fix discharge order of comparisons in Lua parser.
  • Ensure running __gc of userdata created in __gc at state close.
  • Limit number of userdata __gc separations at state close.
  • Fix bytecode JMP slot range when optimizing and/or with constant LHS.
  • Fix DSE of USTORE.
  • Make lua_concat() work from C hook with partial frame.
  • Add required PHIs for implicit conversions, e.g. via XREF forwarding.
  • Add more comparison variants to Valgrind suppressions file.
  • Disable loading bytecode with an extra header (BOM or #!).
  • Fix PHI stack slot syncing.
  • ARM: Reorder type/value tests to silence Valgrind.
  • ARM: Fix register allocation for ldrd-optimized HREFK.
  • ARM: Fix conditional branch fixup for OBAR.
  • ARM: Invoke SPLIT pass for double args in FFI call.
  • ARM: Handle all CALL* ops with double results in SPLIT pass.
  • ARM: Fix rejoin of POW in SPLIT pass.
  • ARM: Fix compilation of math.sinh, math.cosh, math.tanh.
  • ARM, PPC: Avoid pointless arg clearing in BC_IFUNCF.
  • PPC: Fix resume after yield from hook.
  • PPC: Fix argument checking for rawget().
  • PPC: Fix fusion of floating-point XLOAD/XSTORE.
  • PPC: Fix HREFK code generation for huge tables.
  • PPC: Use builtin D-Cache/I-Cache sync code.
• FFI library:
  • Ignore empty statements in ffi.cdef().
  • Ignore number parsing errors while skipping definitions.
  • Don't touch frame in callbacks with tailcalls to fast functions.
  • Fix library unloading on POSIX systems.
  • Finalize cdata before userdata when closing the state.
  • Change ffi.load() library name resolution for Cygwin.
  • Fix resolving of function name redirects on Windows/x86.
  • Fix symbol resolving error messages on Windows.
  • Fix blacklisting of C functions calling callbacks.
  • Fix result type of pointer difference.
  • Use correct PC in FFI metamethod error message.
  • Allow 'typedef _Bool int BOOL;' for the Windows API.
  • Don't record test for bool result of call, if ignored.

LuaJIT 2.0.0-beta9 — 2011-12-14

• New features:
  • PPC port of LuaJIT is complete. Default is the dual-number port (usually faster). Single-number port selectable via src/Makefile at build time.
  • Add FFI callback support.
  • Extend -b to generate .c, .h or .obj/.o files with embedded bytecode.
  • Allow loading embedded bytecode with require().
  • From Lua 5.2: Change to '\z' escape. Reject undefined escape sequences.
• Correctness and completeness:
  • Fix OSX 10.7 build. Fix install_name and versioning on OSX.
  • Fix iOS build.
  • Install dis_arm.lua, too.
  • Mark installed shared library as executable.
  • Add debug option to msvcbuild.bat and improve error handling.
  • Fix data-flow analysis for iterators.
  • Fix forced unwinding triggered by external unwinder.
  • Record missing for loop slot loads (return to lower frame).
  • Always use ANSI variants of Windows system functions.
  • Fix GC barrier for multi-result table constructor (TSETM).
  • Fix/add various FOLD rules.
  • Add potential PHI for number conversions due to type instability.
  • Do not eliminate PHIs only referenced from other PHIs.
  • Correctly anchor implicit number to string conversions in Lua/C API.
  • Fix various stack limit checks.
  • x64: Use thread-safe exceptions for external unwinding (GCC platforms).
  • x64: Fix result type of cdata index conversions.
  • x64: Fix math.random() and bit.bswap() code generation.
  • x64: Fix lightuserdata comparisons.
  • x64: Always extend stack-passed arguments to pointer size.
  • ARM: Many fixes to code generation backend.
  • PPC/e500: Fix dispatch for binop metamethods.
  • PPC/e500: Save/restore condition registers when entering/leaving the VM.
  • PPC/e500: Fix write barrier in stores of strings to upvalues.
• FFI library:
  • Fix C comment parsing.
  • Fix snapshot optimization for cdata comparisons.
  • Fix recording of const/enum lookups in namespaces.
  • Fix call argument and return handling for I8/U8/I16/U16 types.
  • Fix unfused loads of float fields.
  • Fix ffi.string() recording.
  • Save GetLastError() around ffi.load() and symbol resolving, too.
  • Improve ld script detection in ffi.load().
  • Record loads/stores to external variables in namespaces.
  • Compile calls to stdcall, fastcall and vararg functions.
  • Treat function ctypes like pointers in comparisons.
  • Resolve __call metamethod for pointers, too.
  • Record C function calls with bool return values.
  • Record ffi.errno().
  • x86: Fix number to uint32_t conversion rounding.
  • x86: Fix 64 bit arithmetic in assembler backend.
  • x64: Fix struct-by-value calling conventions.
  • ARM: Ensure invocation of SPLIT pass for float conversions.
• Structural and performance enhancements:
  • Display trace types with -jv and -jdump.
  • Record isolated calls. But prefer recording loops over calls.
  • Specialize to prototype for non-monomorphic functions. Solves the trace-explosion problem for closure-heavy programming styles.
  • Always generate a portable vmdef.lua. Easier for distros.

LuaJIT 2.0.0-beta8 — 2011-06-23

• New features:
  • Soft-float ARM port of LuaJIT is complete.
  • Add support for bytecode loading/saving and -b command line option.
  • From Lua 5.2: __len metamethod for tables (disabled by default).
• Correctness and completeness:
  • ARM: Misc. fixes for interpreter.
  • x86/x64: Fix bit.* argument checking in interpreter.
  • Catch early out-of-memory in memory allocator initialization.
  • Fix data-flow analysis for paths leading to an upvalue close.
  • Fix check for missing arguments in string.format().
  • Fix Solaris/x86 build (note: not a supported target).
  • Fix recording of loops with instable directions in side traces.
  • x86/x64: Fix fusion of comparisons with u8/u16 XLOAD.
  • x86/x64: Fix register allocation for variable shifts.
• FFI library:
  • Add ffi.errno(). Save errno/GetLastError() around allocations etc.
  • Fix __gc for VLA/VLS cdata objects.
  • Fix recording of casts from 32 bit cdata pointers to integers.
  • tonumber(cdata) returns nil for non-numbers.
  • Show address pointed to for tostring(pointer).
  • Print NULL pointers as "cdata<... *>: NULL".
  • Support __tostring metamethod for pointers to structs, too.
• Structural and performance enhancements:
  • More tuning for loop unrolling heuristics.
  • Flatten and compress in-memory debug info (saves ~70%).

LuaJIT 2.0.0-beta7 — 2011-05-05

• New features:
  • ARM port of the LuaJIT interpreter is complete.
  • FFI library: Add ffi.gc(), ffi.metatype(), ffi.istype().
  • FFI library: Resolve ld script redirection in ffi.load().
  • From Lua 5.2: package.searchpath(), fp:read("*L"), load(string).
  • From Lua 5.2, disabled by default: empty statement, table.unpack(), modified coroutine.running().
• Correctness and completeness:
  • FFI library: numerous fixes.
  • Fix type mismatches in store-to-load forwarding.
  • Fix error handling within metamethods.
  • Fix table.maxn().
  • Improve accuracy of x^-k on x64.
  • Fix code generation for Intel Atom in x64 mode.
  • Fix narrowing of POW.
  • Fix recording of retried fast functions.
  • Fix code generation for bit.bnot() and multiplies.
  • Fix error location within cpcall frames.
  • Add workaround for old libgcc unwind bug.
  • Fix lua_yield() and getmetatable(lightuserdata) on x64.
  • Misc. fixes for PPC/e500 interpreter.
  • Fix stack slot updates for down-recursion.
• Structural and performance enhancements:
  • Add dual-number mode (int/double) for the VM. Enabled for ARM.
  • Improve narrowing of arithmetic operators and for loops.
  • Tune loop unrolling heuristics and increase trace recorder limits.
  • Eliminate dead slots in snapshots using bytecode data-flow analysis.
  • Avoid phantom stores to proxy tables.
  • Optimize lookups in empty proxy tables.
  • Improve bytecode optimization of and/or operators.

LuaJIT 2.0.0-beta6 — 2011-02-11

• New features:
  • PowerPC/e500v2 port of the LuaJIT interpreter is complete.
  • Various minor features from Lua 5.2: Hex escapes in literals, '\*' escape, reversible string.format("%q",s), "%g" pattern, table.sort checks callbacks, os.exit(status|true|false[,close]).
  • Lua 5.2 __pairs and __ipairs metamethods (disabled by default).
  • Initial release of the FFI library.
• Correctness and completeness:
  • Fix string.format() for non-finite numbers.
  • Fix memory leak when compiled to use the built-in allocator.
  • x86/x64: Fix unnecessary resize in TSETM bytecode.
  • Fix various GC issues with traces and jit.flush().
  • x64: Fix fusion of indexes for array references.
  • x86/x64: Fix stack overflow handling for coroutine results.
  • Enable low-2GB memory allocation on FreeBSD/x64.
  • Fix collectgarbage("count") result if more than 2GB is in use.
  • Fix parsing of hex floats.
  • x86/x64: Fix loop branch inversion with trailing HREF+NE/EQ.
  • Add jit.os string.
  • coroutine.create() permits running C functions, too.
  • Fix OSX build to work with newer ld64 versions.
  • Fix bytecode optimization of and/or operators.
• Structural and performance enhancements:
  • Emit specialized bytecode for pairs()/next().
  • Improve bytecode coalescing of nil constants.
  • Compile calls to vararg functions.
  • Compile select().
  • Improve alias analysis, esp. for loads from allocations.
  • Tuning of various compiler heuristics.
  • Refactor and extend IR conversion instructions.
  • x86/x64: Various backend enhancements related to the FFI.
  • Add SPLIT pass to split 64 bit IR instructions for 32 bit CPUs.

LuaJIT 2.0.0-beta5 — 2010-08-24

• Correctness and completeness:
  • Fix trace exit dispatch to function headers.
  • Fix Windows and OSX builds with LUAJIT_DISABLE_JIT.
  • Reorganize and fix placement of generated machine code on x64.
  • Fix TNEW in x64 interpreter.
  • Do not eliminate PHIs for values only referenced from side exits.
  • OS-independent canonicalization of strings for non-finite numbers.
  • Fix string.char() range check on x64.
  • Fix tostring() resolving within print().
  • Fix error handling for next().
  • Fix passing of constant arguments to external calls on x64.
  • Fix interpreter argument check for two-argument SSE math functions.
  • Fix C frame chain corruption caused by lua_cpcall().
  • Fix return from pcall() within active hook.
• Structural and performance enhancements:
  • Replace on-trace GC frame syncing with interpreter exit.
  • Improve hash lookup specialization by not removing dead keys during GC.
  • Turn traces into true GC objects.
  • Avoid starting a GC cycle immediately after library init.
  • Add weak guards to improve dead-code elimination.
  • Speed up string interning.

LuaJIT 2.0.0-beta4 — 2010-03-28

• Correctness and completeness:
  • Fix precondition for on-trace creation of table keys.
  • Fix {f()} on x64 when table is resized.
  • Fix folding of ordered comparisons with same references.
  • Fix snapshot restores for multi-result bytecodes.
  • Fix potential hang when recording bytecode with nested closures.
  • Fix recording of getmetatable(), tonumber() and bad argument types.
  • Fix SLOAD fusion across returns to lower frames.
• Structural and performance enhancements:
  • Add array bounds check elimination. -Oabc is enabled by default.
  • More tuning for x64, e.g. smaller table objects.

LuaJIT 2.0.0-beta3 — 2010-03-07

• LuaJIT x64 port:
  • Port integrated memory allocator to Linux/x64, Windows/x64 and OSX/x64.
  • Port interpreter and JIT compiler to x64.
  • Port DynASM to x64.
  • Many 32/64 bit cleanups in the VM.
  • Allow building the interpreter with either x87 or SSE2 arithmetics.
  • Add external unwinding and C++ exception interop (default on x64).
• Correctness and completeness:
  • Fix constructor bytecode generation for certain conditional values.
  • Fix some cases of ordered string comparisons.
  • Fix lua_tocfunction().
  • Fix cutoff register in JMP bytecode for some conditional expressions.
  • Fix PHI marking algorithm for references from variant slots.
  • Fix package.cpath for non-default PREFIX.
  • Fix DWARF2 frame unwind information for interpreter on OSX.
  • Drive the GC forward on string allocations in the parser.
  • Implement call/return hooks (zero-cost if disabled).
  • Implement yield from C hooks.
  • Disable JIT compiler on older non-SSE2 CPUs instead of aborting.
• Structural and performance enhancements:
  • Compile recursive code (tail-, up- and down-recursion).
  • Improve heuristics for bytecode penalties and blacklisting.
  • Split CALL/FUNC recording and clean up fast function call semantics.
  • Major redesign of internal function call handling.
  • Improve FOR loop const specialization and integerness checks.
  • Switch to pre-initialized stacks. Avoid frame-clearing.
  • Colocation of prototypes and related data: bytecode, constants, debug info.
  • Cleanup parser and streamline bytecode generation.
  • Add support for weak IR references to register allocator.
  • Switch to compressed, extensible snapshots.
  • Compile returns to frames below the start frame.
  • Improve alias analysis of upvalues using a disambiguation hash value.
  • Compile floor/ceil/trunc to SSE2 helper calls or SSE4.1 instructions.
  • Add generic C call handling to IR and backend.
  • Improve KNUM fuse vs. load heuristics.
  • Compile various io.*() functions.
  • Compile math.sinh(), math.cosh(), math.tanh() and math.random().

LuaJIT 2.0.0-beta2 — 2009-11-09

• Reorganize build system. Build static+shared library on POSIX.
• Allow C++ exception conversion on all platforms using a wrapper function.
• Automatically catch C++ exceptions and rethrow Lua error (DWARF2 only).
• Check for the correct x87 FPU precision at strategic points.
• Always use wrappers for libm functions.
• Resurrect metamethod name strings before copying them.
• Mark current trace, even if compiler is idle.
• Ensure FILE metatable is created only once.
• Fix type comparisons when different integer types are involved.
• Fix getmetatable() recording.
• Fix TDUP with dead keys in template table.
• jit.flush(tr) returns status. Prevent manual flush of a trace that's still linked.
• Improve register allocation heuristics for invariant references.
• Compile the push/pop variants of table.insert() and table.remove().
• Compatibility with MSVC link /debug.
• Fix lua_iscfunction().
• Fix math.random() when compiled with -fpic (OSX).
• Fix table.maxn().
• Bump MACOSX_DEPLOYMENT_TARGET to 10.4
• luaL_check*() and luaL_opt*() now support negative arguments, too.
  This matches the behavior of Lua 5.1, but not the specification.

LuaJIT 2.0.0-beta1 — 2009-10-31

• This is the first public release of LuaJIT 2.0.
• The whole VM has been rewritten from the ground up, so there's no point in listing differences over earlier versions.