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.

Add "jit_block_current_is_dead" to simplify testing if the last block
is reachable or not, taking empty trailing blocks into account.

Add "jit_insn_new_block" to simplify creating a new block that
doesn't have an explicit label.

More bug fixes for the x86 back end.

Fix some compile issues in the x86 native back end.

Selectors for call instructions.

Selectors for branch instructions.

Check in the initial instruction selector for x86 (incomplete).

Add the "gen-sel" program to the tree, to assist with building
native instruction selectors.

Add missing functions to the C++ API.

_jit_gen_start_block: set the address of the exception handler for
interpreted code.

Rewrite the exception region routines to make them easier
to use from CLI and JVM style systems.

Modify the function call logic to use "setjmp" with native back ends.

Rename "jit_insn_move_blocks" to "jit_insn_move_blocks_to_end" and
add a new function "jit_insn_move_blocks_to_start" for creating
initialization code.

_jit_block_peephole_branch: don't allow conditional branches to cross
an exception context boundary, because doing so will violate "finally"
semantics.

Use computed goto's in the interpreter if supported by the underlying compiler.

Add the "jit_insn_alloca" instruction.

Remove the last remaining C++ code from libjit.so so that
it is now a pure C library.

Redesign the exception handling mechanism to use "setjmp" rather
than C++ exceptions.

Treat dead blocks as empty when peepholing branches to the next block.

Treat dead blocks as empty when peepholing branches to the next block.

Perform peephole optimization of branches to branches before live
variable analysis, so that the back ends don't need to worry
about jump threading.

Convert constant conditional branches such as "if true goto L" into
unconditional branches.

Fix a compile bug.

Fix a macro generation bug for Win32 systems.

Put some infrastructure in place to support pluggable object models.

Updating working version to "0.0.3".

Update version for the "0.0.2" release.

Put some infrastructure (incomplete) in place to support
array index expressions.

Add a README file to describe how to write test cases.

Add the "--dont-fold" option to Dynamic Pascal, so that we can run
the test cases without folding.

Test cases and bug fixes for mathematical operations.

Add builtins for mathematical operations.

More coercion test cases and fixes.

jit_type_promote_int: promote ubyte and ushort to uint, not int.

Check in some initial infrastructure for the dpas-based test suite.

dpas_parse_hex: ignore the 'H' on the end of a hexadecimal constant.

Incorrect values for jit_max_int and jit_max_long.

Resolve ea-based lvalues in operators.

IfTail: fix a bug that caused the "then" case of an "if" to fall
through to the "else".

Add the "SameType" and "SameShape" builtins, to assist with unit
testing type coercions.

Use both .libs and non.libs versions of the so paths, because some
versions of libtool add .libs implicitly and others don't.

Modify the autoconf/automake build system to use libtool.

Report errors for unimplemented expressions and statements,
so that users are not "surprised" when things silently fail.

_jit_regs_load_to_top_two: handle the case where the second value
is on the stack but not the first.

Fix a bug that caused global variables in Dynamic Pascal
to be incorrectly allocated as locals.

Implement the exception-handling opcodes for the interpreter.

Round out the function call handling opcodes for the interpreter.

Implement the "New" and "Dispose" builtins.

Loading and storing record fields in Dynamic Pascal.

Interpreter code conversion for relative pointer and copy opcodes;
fix some bugs in stack-based register allocation.

Use "objdump" to dump compiled native code.

Move the "JIT_TYPE_xxx" constants into the public headers and
add "jit_type_get_kind" so that front end code can classify types quickly.

Move the dynlib and C++ name mangling routines into a separate
"jitdynamic" library, which will handle all of the cross-language
naming and dynamic invocation logic.

Remove the locale-sensitive string comparison routines because
they aren't used in libjit, and front ends will normally have
their own functions for this purpose.

Add "_jit_cache_get_end_method", to allow the end of a method's code
to be located without explicit marking.

Code generation for "for" loops.

Implement symbol relocations for the ELF binary reader.

Add the "Flush" and "Terminate" builtins; fix a small bug in string scanning.

Execute the "main" method once a Dynamic Pascal program has been compiled;
fix some calling convention problems with "call_external".

Get basic compilation working in Dynamic Pascal.

Continue the implementation of the C++ name mangling routines.

Add the beginnings of a C++ name mangler, to help with extracting
C++ symbols from dynamic shared libraries.

Tag the system-dependent types so that they can be distinguished from
the fixed-sized types when it is necessary to do so.

Add more instances of JIT_NOTHROW to the headers; add some special
meta tags for types.

Improve the maintainability of the apply macros.

Clean up the builder/parser macros and detect padding of
the floating-point registers.

Add array access instructions.

Implement x86 code generation for some of the basic operators.