LuaJIT Change History

LuaJIT

# LuaJIT Change History

This is a list of changes between the released versions of LuaJIT. The current version is LuaJIT 1.1.4.

Please check the » Online Change History to see whether newer versions are available.

## LuaJIT 1.1.4 — 2008-02-05

- Merged with Lua 5.1.3. Fixes all » known bugs in Lua 5.1.2.
- Fixed possible (but unlikely) stack corruption while compiling `k^x` expressions.
- Fixed DynASM template for cmpss instruction.

## LuaJIT 1.1.3 — 2007-05-24

- Merged with Lua 5.1.2. Fixes all » known bugs in Lua 5.1.1.
- Merged pending Lua 5.1.x fixes: "return -nil" bug, spurious count hook call.
- Remove a (sometimes) wrong assertion in `luaJIT_findpc()`.
- DynASM now allows labels for displacements and `.aword`.
- Fix some compiler warnings for DynASM glue (internal API change).
- Correct naming for SSSE3 (temporarily known as SSE4) in DynASM and x86 disassembler.
- The loadable debug modules now handle redirection to stdout (e.g. `-j trace=-`).

## LuaJIT 1.1.2 — 2006-06-24

- Fix MSVC inline assembly: use only local variables with `lua_number2int()`.
- Fix "attempt to call a thread value" bug on Mac OS X: make values of consts used as lightuserdata keys unique to avoid joining by the compiler/linker.

## LuaJIT 1.1.1 — 2006-06-20

- Merged with Lua 5.1.1. Fixes all » known bugs in Lua 5.1.
- Enforce (dynamic) linker error for EXE/DLL version mismatches.
- Minor changes to DynASM: faster preprocessing, smaller encoding for some immediates.

This release is in sync with Coco 1.1.1 (see the Coco Change History).

## LuaJIT 1.1.0 — 2006-03-13

- Merged with Lua 5.1 (final).
- New JIT call frame setup:
  - The C stack is kept 16 byte aligned (faster). Mandatory for Mac OS X on Intel, too.
  - Faster calling conventions for internal C helper functions.
  - Better instruction scheduling for function prologue, OP_CALL and OP_RETURN.
- Miscellaneous optimizations:
  - Faster loads of FP constants. Remove narrow-to-wide store-to-load forwarding stalls.
  - Use (scalar) SSE2 ops (if the CPU supports it) to speed up slot moves and FP to integer conversions.
  - Optimized the two-argument form of `OP_CONCAT` (`a..b`).
  - Inlined `OP_MOD` (`a%b`). With better accuracy than the C variant, too.
  - Inlined `OP_POW` (`a^b`). Unroll `x^k` or use `k^x = 2^(log2(k)*x)` or call `pow()`.
- Changes in the optimizer:
  - Improved hinting for table keys derived from table values (`t1[t2[x]]`).
  - Lookup hinting now works with arbitrary object types and supports index chains, too.
  - Generate type hints for arithmetic and comparison operators, OP_LEN, OP_CONCAT and OP_FORPREP.
  - Remove several hint definitions in favour of a generic COMBINE hint.
  - Complete rewrite of `jit.opt_inline` module (ex `jit.opt_lib`).
- Use adaptive deoptimization:
  - If runtime verification of a contract fails, the affected instruction is recompiled and patched on-the-fly. Regular programs will trigger deoptimization only occasionally.
  - This avoids generating code for uncommon fallback cases most of the time. Generated code is up to 30% smaller compared to LuaJIT 1.0.3.
  - Deoptimization is used for many opcodes and contracts:
    - OP_CALL, OP_TAILCALL: type mismatch for callable.
    - Inlined calls: closure mismatch, parameter number and type mismatches.
    - OP_GETTABLE, OP_SETTABLE: table or key type and range mismatches.
    - All arithmetic and comparison operators, OP_LEN, OP_CONCAT, OP_FORPREP: operand type and range mismatches.
  - Complete redesign of the debug and traceback info (bytecode ↔ mcode) to support deoptimization. Much more flexible and needs only 50% of the space.
  - The modules `jit.trace`, `jit.dumphints` and `jit.dump` handle deoptimization.
- Inlined many popular library functions (for commonly used arguments only):
  - Most `math.*` functions (the 18 most used ones) [2x-10x faster].
  - `string.len`, `string.sub` and `string.char` [2x-10x faster].
  - `table.insert`, `table.remove` and `table.getn` [3x-5x faster].
  - `coroutine.yield` and `coroutine.resume` [3x-5x faster].
  - `pairs`, `ipairs` and the corresponding iterators [8x-15x faster].
- Changes in the core and loadable modules and the stand-alone executable:
  - Added `jit.version`, `jit.version_num` and `jit.arch`.
  - Reorganized some internal API functions (`jit.util.*mcode*`).
  - The `-j dump` output now shows JSUB names, too.
  - New x86 disassembler module written in pure Lua. No dependency on ndisasm anymore. Flexible API, very compact (500 lines) and complete (x87, MMX, SSE, SSE2, SSE3, SSSE3, privileged instructions).
  - `luajit -v` prints the LuaJIT version and copyright on a separate line.
- Added SSE, SSE2, SSE3 and SSSE3 support to DynASM.
- Miscellaneous doc changes. Added a section about embedding LuaJIT.

This release is in sync with Coco 1.1.0 (see the Coco Change History).

## LuaJIT 1.0.3 — 2005-09-08

- Even more docs.
- Unified closure checks in `jit.*`.
- Fixed some range checks in `jit.util.*`.
- Fixed __newindex call originating from `jit_settable_str()`.
- Merged with Lua 5.1 alpha (including early bugfixes).

This is the first public release of LuaJIT.

## LuaJIT 1.0.2 — 2005-09-02

- Add support for flushing the Valgrind translation cache
  (`MYCFLAGS= -DUSE_VALGRIND`).
- Add support for freeing executable mcode memory to the `mmap()`-based variant for POSIX systems.
- Reorganized the C function signature handling in `jit.opt_lib`.
- Changed to index-based hints for inlining C functions. Still no support in the backend for inlining.
- Hardcode `HEAP_CREATE_ENABLE_EXECUTE` value if undefined.
- Misc. changes to the `jit.*` modules.
- Misc. changes to the Makefiles.
- Lots of new docs.
- Complete doc reorg.

Not released because Lua 5.1 alpha came out today.

## LuaJIT 1.0.1 — 2005-08-31

- Missing GC step in `OP_CONCAT`.
- Fix result handling for C –> JIT calls.
- Detect CPU feature bits.
- Encode conditional moves (`fucomip`) only when supported.
- Add fallback instructions for FP compares.
- Add support for `LUA_COMPAT_VARARG`. Still disabled by default.
- MSVC needs a specific place for the `CALLBACK` attribute (David Burgess).
- Misc. doc updates.

Interim non-public release. Special thanks to Adam D. Moss for reporting most of the bugs.

## LuaJIT 1.0.0 — 2005-08-29

This is the initial non-public release of LuaJIT.

Copyright © 2005-2008 Mike Pall · Contact