
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 (Aleksey Demakov).

	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.
