CHAR-BYTES to x86-x86 cross-compile script.

Only the change for CHAR-BYTES is needed for cross-compiling from x86
to x86, but I think the other changes will be needed if you do a
cross-compile from some other arch to x86.

 code/export.lisp::
 * Export new symbols

 compiler/x86/parms.lisp::
 * Define constants for useful the number of lowtag bits and masks and
   the number of fixnum tag bits and masks.

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.)

This change requires a cross-compile.  Use boot-2011-04-01-cross.lisp
as the cross-compile script.

bootfiles/20b/boot-2011-04-01-cross.lisp:
o New cross-compile bootstrap file

lisp/lisp.c:
o Recognize -unidata option and setup *UNIDATA-PATH* appropriately.

code/commandline.lisp:
o Add defswitch for unidata so we don't get complaints about unknown
  switch.

code/unidata.lisp:
o Rename +UNIDATA-PATH+ to *UNIDATA-PATH*, since it's not a constant
  anymore.
o Update code to use new name.

code/print.lisp:
o Update code to use *UNIDATA-PATH*

compiler/sparc/parms.lisp:
o Add *UNIDATA-PATH* to list of static symbols.
o Add back in spare-9 and spare-8 static symbols since we need to do a
  cross-compile for this change anyway.

compiler/x86/parms.lisp:
o Add *UNIDATA-PATH* to list of static symbols.
o Reorder the static symbols in a more logical arrangment so that the
  spare symbols are at the end.

i18n/local/cmucl.pot:
o Update

Solaris/x86.  There should be no functional changes for either other
x86 ports or for the sparc port.

bugs with dumping unicode strings to fasls on a different endian
architecture.  Combined with cross-x86-sparc.lisp, this will
successfully cross-compile from x86 (OSX) to sparc (Solaris).  The
result won't, unfortunately, built itself, but if the callback support
is commented out, the build is successful.  This new build can then be
successfully used to do another build that includes callback support.
don't know what is causing this issue.

compiler/dump.lisp:
o DUMP-DATA-MAYBE-BYTE-SWAPPING needs to byte-swap unicode (16-bit)
  strings.

compiler/generic/new-genesis.lisp:
o STRING-TO-CORE needs to swap the byte order of unicode strings if
  the backend and native backend have different endianness.
o LOAD-CHAR-CODE should load characters based on the backend, not
  native-backend.  (This not used anymore, though?)
o Add new function byte-swap the char codes of a unicode string.
o COLD-LOAD-SYMBOL calls MAYBE-BYTE-SWAP-STRING
o FOP-UNINTERNED-SYMBOL-SAVE, FOP-UNINTERNED-SMALL-SYMBOL-SAVE,
  FOP-STRING, FOP-SMALL-STRING, FOP-FOREIGN-FIXUP,
  and FOP-FOREIGN-DATA-FIXUP need to call MAYBE-BYTE-SWAP-STRING for
  unicode strings.

compiler/ppc/parms.lisp:
compiler/sparc/parms.lisp:
compiler/x86/parms.lisp:
o Initialize backend foreign-linkage space start and entry size
  appropriately.  The target versions are initialized from the backend
  values now too.


lisp/os-common.c:
o Some debugging stuff for foreign linkage data to print out symbol
  names.  Currently ifdef'ed out.

"cmucl-x86-vm" domain.

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.

x87.  (This should have been done long ago, but wasn't.)

unicode-utf16-extfmt-2009-06-11.

Use bootstrap-2009-01-1.lisp to bootstrap this change.

code/float-trap.lisp:
o FLOATING-POINT-MODES for :X87 needs to massage the results into the
  expected format (SSE2 MXCSR order).
o Update for changed VOP names too.

compiler/x86/float.lisp:
o Rename the floating-point-modes and set-floating-point-modes VOPS to
  x87-floating-point-modes and set-x87-floating-point-modes.  Change
  the translations accordingly too.

compiler/x86/parms.lisp:
o The float property bytes have been updated to match the SSE2 MXCSR
  register for both SSE2 and X87 builds because the code assumes SSE2
  format.

lisp/Linux-os.c:
o Don't OR in the SSE2 modes if we're not running an SSE2 build.
  Doing this can erroneously mask out exceptions because the Lisp code
  didn't set up the sse2 modes.  (This happens if you select the x87
  core on a chip that supports sse2.)

lisp/globals.h:
o Declare fpu_mode.

lisp/lisp.c:
o Set fpu_mode to be the mode determined from the core file.  Needed
  in Linux-os.c to process the SSE2 modes correctly with an x87 core
  on a sse2-capable chip.

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.

The merge is from the tag "double-double-irrat-end".  The
double-double branch is now obsolete.

The code should build without double-double support (tested on sparc)
as well as build with double-double support (tested also on sparc).

  target-dynamic-space-start be defconstants so that they'll get
  dumped to internals.h.

o Move the dynamic space start on Linux to a higher address so that
  CMUCL can run in an x86-64 CPU.

o Move the start of the foreign linkage space higher on Linux too so
  that we don't lose as much heap space.

	* x86-assem.S (multiple_value_return): Add new functions to handle
	heap overflow warnings and errors.

	* x86-arch.c (sigtrap_handler): Add cases for the two new heap
	overflow traps.

	* interrupt.c (interrupt_handle_space_overflow): Add support for
	x86.

	* parms.lisp (static-symbols): Add new static symbols for heap
	overflow checking.  Add new trap types for heap overflow
	checking.

some hardwired random number.

	feature :stack-checking because it's not implemented for other
	systems/architectures yet.  It is currently known to work on
	FreeBSD 4.8-RC/x86 and Debian 2.2.20/x86.

	* bootfiles/18e/boot3.lisp: New boot file, well, only a
	description of the boot procedure since no boot file is needed.

	* lisp/x86-validate.h (SIGNAL_STACK_START, SIGNAL_STACK_SIZE)
	[__FreeBSD__, __linux__]: New defines.
	(CONTROL_STACK_SIZE) {__FreeBSD__, __linux__]:
	Adjust for signal stack.

	* lisp/validate.c (validate) [RED_ZONE_HIT]: Call
	os_guard_control_stack.  Some cleanup.

	* lisp/os.h (BOTH_ZONES, YELLOW_ZONE, RED_ZONE): New enums.
	Add function prototypes.

	* lisp/interrupt.c (interrupt_install_low_level_handler)
	[RED_ZONE_HIT]: Deliver protection violations on a dedicated
	signal stack.

	* lisp/os-common.c (os_stack_grows_down_1, os_stack_grows_down):
	New functions.
	(guard_zones, control_stack_zone, os_guard_control_stack)
	(os_control_stack_overflow) [RED_ZONE_HIT]: New functions.
	(os_control_stack_overflow) [!RED_ZONE_HIT]: Dummy function.

	* lisp/Linux-os.c (sigsegv_handler) [RED_ZONE_HIT]: Handle control
	stack overflows.

	* lisp/FreeBSD-os.c: General cleansing.
	(sigbus_handler) [RED_ZONE_HIT]: Handle control stack overflows.

	* lisp/FreeBSD-os.h (PROTECTION_VIOLATION_SIGNAL): New define.

	* lisp/Linux-os.h (PROTECTION_VIOLATION_SIGNAL): New define.

	* compiler/x86/system.lisp (lisp::%scrub-control-stack): Change
	defknown from sys:scrub-control-stack.
	(%scrub-control-stack): Rename VOP.

	* code/lispinit.lisp (os-guard-control-stack) [#+stack-checking]:
	Define alien os_guard_control_stack.
	(%scrub-control-stack) [#+x86]: New function.
	(scrub-control-stack) [#+x86]: Call %scrub-control-stack,
	call os-guard-control-stack if #+stack-checking.

	* code/interr.lisp (yellow-zone-hit,
	red-zone-hit) [#+stack-checking]: New functions.

	* code/error.lisp (stack-overflow) [#+stack-checking]: New
	condition.

	* compiler/generic/new-genesis.lisp (finish-symbols)
	[#+stack-checking]: Add symbols for control stack checking.

	* compiler/x86/parms.lisp (static-symbols): Likewise.

files being generated, thus requiring new genesis.

preparation for the 18e release. This change makes it necessary to
intervene during the rebuild: when loading the FASL files, a
continuable error related to fasl-file-version mismatch will be
signalled. Say

   (setq cl::*skip-fasl-file-version-check* t)

then select the CONTINUE restart, and the build should proceed without
problems.

  location of the lisp C binary, when CMUCLLIB is not given, and the
  core file is not specified.
o Add support for a CMUCLCORE envvar, and a -lib option for setting
  the path for the library: search-list.
o Added some spare static symbols for the sparc port so we don't have
  to cross-compile again for a while.

See cmucl-imp archives for some more details.

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.

  - change the FASL file format to store fasl-file version as uint32,
    rather than a single octet. This requires small changes to the
    FASL dumper and two FOP functions
  - change the FASL-FILE-FORMAT to #x18d for each of the backends
  - change the byte-code version number to #x18d
  - make the FASL file version checking errors continuable
  - add a variable CL::*SKIP-FASL-FILE-VERSION-CHECK* that avoids the
    version check
  - add a bootfile that bootstraps this change

Loading an old FASL file results in the following behaviour:

,----
| Error in function COMMON-LISP::CHECK-VERSION:
|    #<Stream for file "/usr/local/lib/cmucl/lib/subsystems/defsystem-library.x86f">
|    was compiled for fasl-file version 3E3F02, but this is version 18D
| Restarts:
|   0: [CONTINUE] Load #<Stream for file "/usr/local/lib/cmucl/lib/subsystems/defsystem-library.x86f"> anyway
|   1:            Return NIL from load of #p"modules:defsystem-library".
|   2:            Return NIL from load of "home:.cmucl-init".
|   3: [ABORT   ] Skip remaining initializations.
`----

Support for dynamic loading in FreeBSD 4.0 and later.  This involves moving
the static space up, so a cross-compile is required to bootstrap these changes.

precision for x86 floating-point operations.

read-only spaces.

and bringing it closer to the FreeBSD map. From Raymond Toy.

address space.

larger heaps and stacks:

* There is now the potential for up to 2.75GB dynamic space on
FreeBSD, and 1.75GB on linux.  Since GENCGC statically allocates page
tables the default size is set at just 1GB.

* The Read-only and Static spaces have been increased to 256MB
allowing larger heaps to be purified. The Read-only and Static spaces
are in the same locations for both the FreeBSD and Linux ports to
avoid unnecessary binary incompatibility.

* The Control stack and Binking stack now have room for upto 128MB,
supporting deeply nested algorithms, and potentially giving room for
subdivision for thread stacks.

* There is a reserve for the FreeBSD static libraries in the event
that the FreeBSD lisp binary is dynamically linked, and the foreign
segment size for FreeBSD is now 32MB, up from just 4MB.

* There is now significantly more room for C allocated memory, roughly
128M on Linux and 224M on FreeBSD.

unbound checks.