Handle the special case of constant destination pointers in
"store_relative" instructions, because otherwise the register
allocator gets confused.

fix ChangeLog entry

fix manpage formatting - patch to bug #10779

Implement some of the locking code for the debugging API.

Test case for the long-form backward branch bug.

output_branch: correct the offset when outputting a long-form backward branch.

Redesign the debugger API so that it contains functions
like "add breakpoint", "run", "step", etc that more closely resemble
what a front end debugger will want to have, shifting the
implementation burden off the front end.

Use a common helper function for performing debug hook tests on
native platforms, to avoid the need to implement breakpoint testing
individually in every native back end.

Clean up the breakpoint API and implement debug hooks for the interpreter.

Add instructions and function API's for supporting debug line
numbers and breakpoints.

Pointer-relative loads and stores for structures in the x86 back end.

Add some support for structure copying to the x86 back end.

The pointer value for indirect and vtable calls was being pushed onto the stack twice.

Add a sample program that demonstrates a simple VM based
on libjit (committed by Rhys).

Fix x86 code generation for floating-point return instructions.

cpuid_query: use %ebx in a way that doesn't confuse PIC mode in some
versions of gcc (bug #10022).

Re-implement the "push_return_area_ptr" patch so as to avoid wasting
stack space in functions with more than one native function call.

Account for the extra value that is added to the stack by the
"push_return_area_ptr" instruction.

Minor fix to previous checkin.

Updating working version to "0.0.3".

Update version for the "0.0.4" release.

Support for parallel builds.

Documentation updates.

Fix the operand types for "call_vtable_ptr".

Write an x86-64 assembly version of "__builtin_apply", because
the version inside gcc has an unusable register ordering.

Fix a crash in gen-apply under x86-64.

Use separate JIT_REG_xxx flags for float32, float64, and nfloat
because some platforms need to put these values in different
types of registers (e.g. x86-64).

Properly set the "may_throw" flag for opcodes that throw exceptions and
which are also supported by the back end.

Move the code for loading/storing small structures into a central location.

Rewrite the x86 and ARM parameter handling routines to centralise the
code and fix several bugs; add new tests for fastcall and stdcall conventions.

Allow floating-point values to be passed in "fastcall" registers.

_jit_regs_set_outgoing: pass 64-bit "fastcall" parameters in ECX:EDX,
not in ECX:EBX.

Add a missing semi-colon.

Enable register allocation for 64-bit values under x86 and ARM; expand some
64-bit opcodes in the instruction selectors.

Add some test cases for parameter passing; fix fastcall/stdcall
conventions for x86.

Add the "outgoing_frame_posn" instruction, to support tail calls.

Implement or stub missing x86 instruction selection rules.

Optimize the x86 function epilog when we are certain that the
stack height doesn't change between entry and exit (i.e. the
function is a leaf and there are no alloca's).

Implement global register allocation for parameters in stack slots.

Implement tail calls from a function to itself.

_jit_regs_load_value: avoid unnecessary spills if a temporary value
won't be used again in the current block.

Don't over-allocate x86 stack frames if EBX, ESI, and EDI don't need to
be saved; don't perform global register allocation on stacked parameters
because it confuses the register spill logic.

Add support for outgoing parameter areas, which should reduce
the overhead of function calls that involve stacked arguments
on non-x86 platforms; use parameter areas in the ARM back end.

Dump the hex address of external functions, to aid with debugging
native disassembly dumps.

Flush the constant pool after unconditional branches, to try to
minimize the probability that the pool will be flushed in the
middle of a loop body.

Redesign the ARM code generation macros so that they have stronger
protection against buffer overruns.

_jit_gen_load_value: use ARM register pairs properly for "long"
and "float64" values.

Optimize the use of rotated immediate values.

_arm_alu_reg_imm: forgot to update the instruction pointer when
loading the immediate value.

Fix some bugs in the encoding of floating-point load and store instructions.

flush_constants: update the instruction location after flushing the
constant table.

Implement a constant pool for ARM, which gets complicated constants out
of the main stream of execution.

ARM parameters cannot be split between registers and the stack.

Minor register assignment bugs.

_jit_gen_spill_reg: spill properly to global registers for ARM.

_jit_gen_spill_reg: spill properly to global registers for ARM.

Introduce conditional rules into "gen-sel" so that we can disable
certain rules on ARM platforms that lack floating-point support.

arm_call: use a more efficient form of call for offsets beyond the
simple target range.

_jit_regs_set_outgoing: implement missing function.

More x86 instruction selection rules.

Remove obsolete opcodes which violate "_jit_load_opcode"'s rules.

Add an API for querying the x86 "cpuid" information.

Fix ROUND_END_PTR so that it adds the size after casting to jit_nuint.

(jit_flush_exec): warning fix for ia64.

Gen-apply fix for ia64.

Bypass the auto-detection logic in gen-apply under MacOSX because
it doesn't work with Apple's version of gcc.

Add "_setjmp" to the list of names to try to work around the
"setjmp" macro (needed for Win32).

Fix misnaming of jit_type_get_abi, jit_abi_stdcall, and jit_abi_fastcall.

Expand floating-point instructions for ARM.

Add floating-point instruction macros.

Use "sigsetjmp" instead of "setjmp", because "setjmp" may
be a macro on some systems.

Fix a warning.

Work around a SIGFPE for sqrt(-1) on Alpha; it should return NaN instead.

Alignment problem with "push_const_float32" on 64-bit platforms.

Gen-apply fixes for Alpha platforms.

jit_flush_exec: flush cache lines properly if the start is not
on a line boundary.

Add some more instructions to the ARM back end; split some x86
back end code out into common code for ARM to use as well.

Recognise "t = a op b; a = t" and turn it into "a = a op b" to make
it easier for back ends to recognise special idioms such as
increments and decrements.

_jit_regs_load_value: if a value is in a global register and it is
not going to be destroyed by an instruction, then use the global
register as the operand.

Implement a simple global register allocation policy, based on usage counts.

Enable the x86 back end by default on platforms where it makes sense,
and add the option "--enable-interpreter" to "configure".

More instruction selection rules for ARM.

Fix some gcc 3.x compile warnings.

Throw exceptions correctly for "check_null".

Inline and optimize divisions for x86.

Optimize multiplications for x86.

Fix a cpu vs non-cpu register problem in the floating-point
"push" operations for x86.

Add "jit_insn_defer_pop_stack" and "jit_insn_flush_defer_pop",
to defer the popping of function call arguments as long as possible.

Improve instruction selection for floating-point "push" operations.

Another small change.

Small update to LLVM URL.

jit_insn_convert: use intrinsic functions for conversions when the
back end doesn't support the opcode.

Clarify the text that describes LLVM, at the request of Chris Lattner,
LLVM's author.

Stub out JIT_OP_RETURN_REG, which doesn't need any special handling for x86.

Continue the x86 back end; particularly byte/short stores.

Relative loads and stores for x86.

dpas_type_identical: treat "float64" and "nfloat" as identical on
platforms whose "long double" type is the same as "double".

Split "detect_struct_conventions" up a bit more to (hopefully) prevent
problems under MacOSX; fix a bug in the generation of
"jit_apply_builder_align_regs" that affected ARM and PPC systems.

Add the beginnings of the instruction selector for ARM.

More selection cases for the x86 back end.