0.1.2 (10 Decemeber 2008)

	* Switch from GPL to LGPL 2.1 license.
	* Implement x86-64 backend (Klaus Treichel).
	* Fix interpreter backend (Klaus Treichel, Aleksey Demakov).
	* Introduce jit-unwind interface (Aleksey Demakov, Klaus Treichel).
	* Code cache pages can now grow if needed (Aleksey Demakov).
	* Various fixes (Klaus Treichel, Aleksey Demakov, Juan Jesus Garcia
	  de Soria, Dalibor Topic, Arto Bendiken)

0.1.0 (3 March 2007)

	General improvements:

	* Add on-demand compilation driver (Aleksey Demakov, Klaus Treichel).
	* Add jit_function_from_vtable_pointer function (Klaus Treichel).
        * Add jit_insn_mark_breakpoint_variable function (Radek Polak).
	* Add signal handlers (Kirill Kononenko).
	* Add JIT_OPTION_POSITION_INDEPENDENT context option (not supported
	  by the backends yet) (Aleksey Demakov).
	* Add function indirectors (Klaus Treichel).
	* Allocate function redirectors and indirectors in the code cache
	  (Aleksey Demakov).
	* Use mmap to allocate executable memory where available
	  (Klaus Treichel).
	* Now can dump to any stream not just stdout and stderr (Radek Polak).
	* Use a global lock during context initialization (Aleksey Demakov).
	* Fix problems that take place after compilation is restarted on cache
	  page overflow (Aleksey Demakov).

	Register allocation/instruction selection improvements (Aleksey Demakov):

	* Completely rewrite register allocator. The new allocator works with
	  three-value intermediate instructions rather than with individual
	  values. This allows to fully analyze the effect of the instruction
	  and makes it possible to optimize commutative instructions and 
	  eliminate in some cases redundant register spills and loads.
	* Support three-address architectures.
	* Add register classes.
	* The allocator may now allocate scratch registers for instructions.
	* The allocator now automatically handles cases when a global register
	  is clobbered by the instruction (which may happen on the register
	  constrained x86 architecture).
	* Implement value coalescing for copy instructions.
	* Provide for efficient handling of x87 floating point stack.
	* Add gen-rules program that supersedes gen-sel. It generates code for
	  new register allocator and extends the syntax of instruction selection
	  rules to make use of new features such as register classes, scratch
	  registers, etc.

	Alpha:

	* Add Alpha backend (not yet fully functional) (Thomas Cort).

	x86:

	* Update x86 instruction selector for new register allocator and rules
	  syntax. Take advantage of their new features to generate better code
	  and/or simplify rules (Aleksey Demakov).
	* optimize code generated by throw_builtin, JIT_OP_THROW, JIT_OP_LOAD_PC
	  if the position-independent option is not set (Kirill Kononenko).
	* Implement JIT_OP_IMIN_UN, JIT_OP_ISIGN, JIT_OP_LSIGN, JIT_OP_IABS,
	  JIT_OP_LABS, JIT_OP_LOW_WORD, JIT_OP_EXPAND_INT, JIT_OP_EXPAND_UINT,
	  JIT_OP_INT_TO_NFLOAT, JIT_OP_UINT_TO_NFLOAT, JIT_OP_LONG_TO_NFLOAT,
	  JIT_OP_ULONG_TO_NFLOAT rules (Aleksey Demakov, Kirill Kononenko).
	* optimize loading of zero constants. (Aleksey Demakov).

	Interpreter:

	* The interpreter backend does not use register stack and register
	  allocator anymore (Aleksey Demakov).

0.0.6 (15 January 2006)

	x86:

	* Be careful when using EBX in cpuid instructions so as not to confuse
	  gcc in PIC mode (Rhys W).
	* Fixes to floating point instruction selection (Rhys Weatherley).
	* Some support for structure copying (Rhys Weatherley).
	* Pointer-relative loads and stores (Rhys Weatherley).
	* Correct the offset for long-form backwards branches (Evin Robertson).
	* Constant pointers in relative offset operations (Rhys Weatherley).
	* Merge in Mono's changes to jit-gen-x86.h (Aleksey Demakov).
	* Array loads and stores for floating point values (Aleksey Demakov).
	* Memcpy, memset, and memmove operations (Aleksey Demakov).
	* Return buffer problems in apply function with gcc 4.0.2 (Aleksey Demakov).

	x86-64:

	* Use the correct library entry point when calling jit_memcpy from
	  compiled code (Klaus Treichel).

	Interpreter:

	* Return area pointers (Rhys Weatherley).
	* Prevent double push of indirect function pointers (Rhys Weatherley).

	Function/instruction core:

	* Clear block addresses and fixup lists if a function restart is needed
	  (Evin Robertson).
	* Use destination type for store type, not source type (Evin Robertson).
	* Tail call implementation (Rhys Weatherley).
	* Address of constants (Avinash Atreya, Aleksey Demakov).
	* Functions for locating the proper start of a function in the cache
	  (Aleksey Demakov).
	* New exception type for array out of bounds (Aleksey Demakov).
	* Jump tables (Aleksey Demakov).
	* Intrinsics that return exception codes should be labeled "int" (Aleksy D).
	* Spill both parts of a register pair properly (Aleksey Demakov).
	* Fixes to freeing of register pairs (Aleksey Demakov).

	Dpas:

	* Throw builtin exceptions (Aleksey Demakov).
	* Implement array expressions (Avinash Atreya).

	Other:

	* Sample VM for demonstrating libjit (Norbert Bellow).
	* Debug interface for line numbers and breakpoints (Rhys Weatherley).
	* Man page formatting issues (Peter Lund).
	* Wrong return value in jit_function_apply_vararg (Evin Robertson).
	* Make debug dumping work with cygwin (Aleksey Demakov).
	* Option to force use on long double on Win32 (Aleksey Demakov).

0.0.4 (8 August 2004)

	* Pluggable object models.
	* Problems with "gen-apply" on Win32 systems.
	* Optimize "if true goto" into "goto".
	* Peephole optimization on branches.
	* Adjust ARM codegen macros to support branch elimination instructions.
	* Redesign exception handling to use "setjmp" everywhere.
	* Remove C++ code from "libjit.so" so that it is a pure C library.
	* Use computed goto's in the interpreter if the compiler supports them.
	* Don't allow conditional branches to jump out of exception contexts.
	* Block movement to allow initialization code to be moved to the start
	  of a function, or loop condition code to be moved to the end.
	* Rewrite the exception region routines to make them easier to use.
	* Add the "gen-sel" program, for creating instruction selectors.
	* Write instruction selectors for x86 and ARM (only x86 is enabled).
	* Portability fixes for ARM, PPC, Alpha, IA64, and amd64.
	* Clarify the description of LLVM, at the request of LLVM's author.
	* Deferred argument popping after function calls.
	* Add "--enable-interpreter" to force the interpreter to be used.
	* Implement a simple global register allocator based on usage counts.
	* Recognise increment and decrement idioms.
	* Align cache flushes properly (Miroslaw Dobrzanski-Neumann).
	* Querying of x86 cpuid where necessary.
	* Add a constant pool for ARM, to make constant loads more efficient.
	* Handle register pairs for 64-bit values properly.
	* Support for parameter areas on the stack, to reduce push/pop overhead.
	* Avoid unnecessary register spills if a value won't be used again.
	* Implement tail calls from a function to itself.
	* Optimize x86 prologs and epilogs to avoid doing unnecessry work.
	* Centralise the code that handles parameter passing.
	* Support for parallel builds.

0.0.2 (13 May 2004)

	* Function and instruction building API basics in place, in C and C++.
	* Operations include arithmetic, overflow checking, conversion,
	  mathematical (sin, sqrt, etc), branching, exception handling,
	  function calls, structure types, and arrays.
	* Up-front or on-demand compilation and re-compilation.
	* Interpreter at par with instruction building requirements.
	* x86 and ARM in early stages (not enabled yet).
	* Register allocation for register-based and stack-based architectures.
	* Nested functions.
	* Dynamic Pascal language is usable, suitable for writing test cases.
	* Beginnings of ELF support for eventual ahead-of-time compilation.