bootfiles/20d/boot-2012-12-1.lisp::
  Add :alien-callback to *features*

bin/build.sh::
  Change bootstrap directory to 20d.

code/lispinit.lisp::
  * Register :alien-callback feature if enabled.
  * Heap overflow checking depends on gencgc, so register that only if
    both are enabled.

tools/comcom.lisp::
  Compile c-callback only if :alien-callback is a feature.

tools/worldcom.lisp:
  Compile alien-callback onlf if :alien-callback is a feature.

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.

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

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

overflow checking.  Enable with :heap-overflow-check.  We reserve some
number of pages on the heap.  When the heap reaches the reserved
pages, an overflow warning is signalled.  The reserved pages are set
0.  This allows some additional allocation to happen during debugging,
if necessary.  If another overflow happens, we throw to top-level.

Sparc only right now.

	* lisp/sparc-assem.S (_do_dynamic_space_overflow_error): New
	function to handle a heap overflow error.
	(_do_dynamic_space_overflow_warning): New function to handle heap
	overflow warning.

	* lisp/sparc-arch.c (sigill_handler): Handle the two new traps
	caused by heap overflows.

	* lisp/interrupt.c (interrupt_handle_space_overflow): New function
	to handle interrupt caused by heap space overflows.

	* lisp/gencgc.c (handle_heap_overflow): New function to handle
	heap overflows.
	(gc_alloc_new_region): Use handle_heap_overflow.
	(gc_alloc_large): Use handle_heap_overflow

	* compiler/sparc/parms.lisp (static-symbols): Add new static
	symbols for heap overflow checking:
	dynamic-space-overflow-error-hit and
	dynamic-space-overflow-warning-hit.

	* compiler/generic/new-genesis.lisp (finish-symbols): Initialize
	the new dynamic-space-overflow-error-hit and
	dynamic-space-overflow-warning-hit static symbols.

	* code/lispinit.lisp (:heap-overflow-check): Add
	heap-overflow-check to *runtime-features*, if necessary.
	("reserved_heap_pages"): Access to alien variable for heap
	overflow.
	(*reserved-heap-pages*): Default number of heap pages to reserve
	for heap overflow.
	(%top-level): Set reserved-heap-pages to the default.

	* code/interr.lisp (dynamic-space-overflow-warning-hit): Add
	function to handle heap overflow warnings.
	(dynamic-space-overflow-error-hit): Add function to handle heap
	overflow error.

	* code/error.lisp (heap-overflow): Add new condition type for heap
	overflow

and *RUNTIME-FEATURES* and setting them appropriately as files are
loaded so that recompiling CMUCL produces a result with the same set
of features.  *RUNTIME-FEATURES* is a subset of *FEATURES* that is
written out to internals.h so the C code can be compiled
appropriately.

A simple bootstrap with boot17 is needed.

Non-simple-streams-related changes:

* Stop commands which go through invoke-command-interactive from
  affecting the history variables.

* Fix some typos in comments

* When the GC closes a lost stream, revert to original contents

* Replace #+nil with #+(or) in unix*.lisp
  [NIL is a potentially valid feature name]


Simple-streams-related changes:

* Teach reader to handle simple-streams

* Add missing package prefixes in OPEN

* Add unix:unix-msync for force-output on mmapped files

* Add placeholder documentation

* Numerous changes in simple-streams implementation

* Add "external-formats" directory for external formats


Note: :BIG-ENDIAN or :LITTLE-ENDIAN should be put on *features*

	* lisp/sunos-os.h (PROTECTION_VIOLATION_SIGNAL): Define it for
	stack-checking.

	* lisp/solaris-os.c (segv_handler): Add stack-checking support for
	Solaris.

	* lisp/os.h (os_control_stack_overflow): Give a type name to the
	zone enums (mostly for the debugger).

	* lisp/os-common.c (guard_zones): Add stack-checking support for
	Solaris.
	(os_control_stack_overflow): Add stack-checking support for
	Solaris.

	* lisp/interrupt.c (build_fake_control_stack_frame): New function
	for building a stack frame without the foreign call stuff.  Used
	for stack checking.
	(interrupt_install_low_level_handler): Only need to install
	alternate signal stack for x86.

	* lispinit.lisp:
	(scrub-control-stack): Rename to %scrub-control-stack to match x86
	version so control stack guard is done.

	* parms.lisp (static-symbols): Added new static symbols for
	control stack checking.

	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.

it defaults to simple-program-error.  Removed duplicate definition of
simple-program-error from package.lisp, and converted various places
to use the new simple-program-error function.  Also rewrote the
function check-disjoint for clarity.

 * (pcl:class-precedence-list (find-class 'null)) should have symbol
   occurring before list, as per CLHS.

 * minor changes to certain error conditions: eg trying to set
   DEFAULT-DIRECTORY to a non-existent directory should raise a
   condition of type FILE-ERROR. (Some of these changes are from
   Alexey Dejneka, via SBCL).

 * cleanup of some Hemlock-related symbols that shouldn't be exported
   when :no-hemlock is defined.

	This patch makes QUIT call a list of functions at
	exit, so that the Motif interface can clean up without having to
	redefine it.

Allow duplicate keyword arguments in macro calls and destructuring-bind
to be ANSI compliant. Offending clause in VALIDATE-KEYWORD is commented
out in case anyone needs to revive the old behaviour.

confusing output noted by Tunc Simsek.

VOP takes care to decrease the stack pointer as the stack is scrubbed,
which allows a grow-down control stack to be used on Linux.

approximately twice as long as requested.

of heap corruption and to try and handle return address on the stack.

Enhance new-genesis to save the code fixups for x86 code objects
allowing the code to be placed in the dynamic heap and thus garbage
collected by purify.

sys:wait-until-fd-usable but uses process-wait so avoids blocking if
there are other runnable processes.

Redefine the sleep function to use process-wait-with-timeout to avoid
blocking if there are other runnable processes.

compiled with support.

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.

*current-unwind-protect-block*.

Note *batch-mode* is set at the command line.