For sse2, we don't need to do the fldz/fstp dance when doing a
foreign function call.

A cross-compile is needed!

 * src/bootfiles/20e/boot-2014-04-cross-x86.lisp:
   * Cross-compile script to enable these changes.
 * src/compiler/x86/c-call.lisp:
   * Make the float result tn be xmm registers, not x87 fpu registers.
 * src/compiler/x86/sse2-c-call.lisp:
   * Simplify call-out not to use fldz/fstp except for the minimum
     required for the 32-bit ABI.
 * src/lisp/x86-assem.S
   * Comment out the fstp/fldz insts that aren't needed for SSE2.

compiler/ppc/c-callback.lisp::
compiler/sparc/c-callback.lisp::
compiler/x86/c-callback.lisp::
 New file containing the callback code from c-call.lisp.

compiler/ppc/c-call.lisp::
compiler/sparc/c-call.lisp::
compiler/x86/c-call.lisp::
 Removed the callback code.

code/alien-callback.lisp::
 New file containing the alien callback code.

code/alieneval.lisp::
 Removed the alien callback code.

tools/comcom.lisp::
 Compile c-callback.lisp

tools/worldcom.lisp:
 Compile alien-callback.lisp.

entries with just the file path, removing the revision number, date,
author and state.  The actual information is now computed during
compilation and stored in the fasl itself.  (See ticket:48.)

may get confused with source locations if the reader macros are
installed.

boot-2010-02-1 as the bootstrap file.  You should probably also use
the new -P option for build.sh to generate and update the po files
while building.

sse2-packed-2008-11-12).

  the precision control will always be set to double precision.  For
  the duration of calls into C, the precision control will be set to
  the ABI default.  On Linux and Darwin this is double extended
  precision.  On all other platforms the precision control is left as
  double precision.  The specious FLOAT-ACCURACY declaration has been
  eliminated.

* Shorten the precision control field to 24-bits by disposing of the
  unexamined high order eight bits of the status word.  This compacts
  the code generated around floating point mode changes and reduces
  consing.

* Eliminate unnecessary uses of FLDENV and FSTENV.  We can substitute a
  use of FSTENV with FSTSW in FLOATING-POINT-MODES.  This reduces the
  number of cycles to access the relevant mode bits by a factor of
  thirty.  We cannot eliminate FLDENV in SET-FLOATING-POINT-MODES, but
  the common case does not require an update to the status word.  A
  fast path has been added to the VOP that improves the execution time
  by at least a factor of fifteen.

* Remove the precision control option to SET-FLOATING-POINT-MODES.  It
  is the responsibility of the compiler to generating code that yields
  correctly rounded results in double and single precision.

if the user set a different value.  Fix this so the correct precision
is restored.

compiler/x86/parms.lisp:
o Add new static-symbol *FPU-PRECISION* to hold the precision bits
  that are given in (setf floating-point-modes).

compiler/x86/float.lisp:
o Whenever (setf floating-point-modes) is called, save the precision
  bits to *FPU-PRECISION* so that get restored correctly in
  DEALLOC-NUMBER-STACK-SPACE.

compiler/x86/c-call.lisp:
o Update DEALLOC-NUMBER-STACK-SPACE VOP so that when float-accuracy
  policy says so, we restore the precision from *fpu-precision*,
  instead of always making it :53-bit.

code/lispinit.lisp:
o Initialize the default precision to :53-bit on startup.

* alieneval.lisp:
  o The CALLBACK defstruct holds the entire alien function type
  o COMPATIBLE-RETURN-TYPES-P renamed to COMPATIBLE-FUNCTION-TYPES-P and
    and made specific to each backend.
  o Adjust code appropriately.

ppc/c-call.lisp:
  o Port Thomas Burdick's callback code to ppc.

sparc/c-call.lisp:
x86/c-call.lisp:
  o Adjust code appropriately for new callback structure.
  o Implement COMPATIBLE-FUNCTION-TYPES-P, like original
    COMPATIBLE-RETURN-TYPES-P

double-float-epsilon actually be epsilon on x86.  No effect on other
ports.

The default precision is now 53-bit (double-float) instead of 64-bit
(80-bit floats).  However, to preserve C expectations, all calls to C
have the precision set to 64-bit.  This slows down calls to C, but we
try to make syscalls and such fast by not changing precision for the
call.

By default ext:float-accuracy is 3.

Use boot7.lisp to bootstrap.

code/alieneval.lisp:
	o Main callback support

code/exports.lisp:
	o Export DEF-CALLBACK and CALLBACK.
	o Export CALLBACK-ACCESSOR-FORM and MAKE-CALLBACK-TRAMPOLINE
	o Reindent a few items.

x86/c-call.lisp:
	o Helmut's MAKE-CALLBACK-TRAMPOLINE for x86.

sparc/c-call.lisp:
	o MAKE-CALLBACK-TRAMPOLINE for sparc.

On x86 FreeBSD and Linux, change the way foreign symbol addresses are resolved.
They now go through a table -- effectively a new space in the core file.
Function references are resolved lazily, data references are resolved on startup
and when a .so is loaded.  The end result is that cores can be dumped that
contain references to symbols in shared libraries.  Also, the dependence of the core on addresses in the Lisp runtime is broken.

The linkage table feature is controlled by :linkage-table and LINKAGE_TABLE in C
runtime.  Several foreign symbols are now Lisp static symbols, so a cross
compile is required whether or not the new stuff is used.  I've checked in
boot4-cross-foreign-linkage.lisp that builds the compiler for linkage table; do whatever you usually do for the non-linkage table case:)  Seriously, lets start
a discussion on standardizing "cross compilation," not to mention the general
build procedure.

arguments and result.

supporting the return of 64bit integers.

for the removal of this SC. There is a current limit of 32 SCs and
with new features planned they are becoming a scarce resource; the
dword-reg SC is redundant as the unsigned-reg etc SCs can be used for
temporaries.

clear it during a C call-out.

common binaries to be run on both:

* The immediate-stack storage class has been removed, this is
unnecessary as the descriptor-stack SC can be used. It may have once
been part of some GC stragety to reduce the number of stack slots that
needed to be noted for a GC.

* The object allocation has been abstracted and cleaned up. This
should produce slightly faster smaller code with CGC, and can be
compiled to support inline allocation with GENCGC.  CGC compiled code
will run under GENCGC, and GENCGC binaries that don't use inline
allocation will run under CGC.

* A random hash is now placed in the unused symbol object slot (the
symbol-hash slot). This saves flushing the info cache at each GC, and
may have other uses for symbol based hash tables. Should help MP
safety.

* Common set of static symbols used by both CGC and GENCGC.

* Corrections to the stack-ref VOP; now returns lisp objects not
unsigned numbers. Required some patches to debug-int.

* Inline unsigned/signed byte 32 to bignum allocation enabled.

* Support for the x86 xadd instruction applied to instance slot and
symbol values - may be handy for some MP code.

* Bump up the FASL file version from 1 to 2.

registers off the stack to empty it rather than re-initialising the
whole NPX state. This has the advantage that the flagged exceptions
are preserved (they were just being flushed), and it also a little
quicker.

which was wrong by the x86 C call conventions.