* Get rid of the RCS Header stuff.  They're meaningless in git.
 * Add public domain comment to some of the files if the only comment
   was the RCS header.

only affected linux which uses an array for the sigmask.

match the sa_sigaction argument types.  Adjust code appropriately to
use os_context_t appropriately too.

amd64-dd-branch.

sources.  No real attempt has been made to make it work, but the
cross-compile does create a kernel.core, and the C code compiles (on
openSuSE 10.3).  The resulting kernel.core does not yet work.

Use cross-x86-amd64.lisp as the cross-compile script.  This is
intended to be cross-compiled using the 20a release for Linux, and
only supports x87.  The sse2 support has not be ported yet.

tools/cross-scripts/cross-x86-amd64.lisp:
o Update cross-compile with some missing constants, and frob new
  symbols.

tools/clean-target.sh:
o Remove amd64f files too.

code/pred.lisp:
o Define predicates for double-doubles for bootstrapping to work
  around recursive known function problems with these predicates.

code/sap.lisp:
o Define int-sap with (unsigned-byte 64) type declaration.  (May not
  be needed?)

code/unix-glibc2.lisp:
o Build fails defining map_failed to (int-sap -1).  Just hard-wire to
  0 for now so we can build.

compiler/float-tran.lisp:
o Add missing conditional for %complex-double-double-float.

compiler/amd64/float.lisp:
o Merge double-double support for amd64.  Not really tested yet.

compiler/amd64/parms.lisp:
o Update to match x86 build.  In particular, get the space address
  correct and update the static symbols.

compiler/amd64/type-vops.lisp:
o DYLAN-FUNCTION-HEADER-TYPE no longer exists.

compiler/amd64/vm.lisp:
o Add double-double storage classes and register definitions.

lisp/Config.amd64:
o Bring in line with Config.x86 and friends.

lisp/Linux-os.c:
o Bring amd64 code up-to-date with x86/linux code.

lisp/Linux-os.h
o Need to include sys/ucontext.h to get ucontext defined.  (Why?)
o Also define __USE_GNU so we get the register offsets in the ucontext
  defined.  (Why?)

lisp/amd64-arch.c:
o Change struct sigcontext to os_context_t.
o Use SC_PC instead of context->sc_pc.
o Merge some changes in from x86 version, like SC_EFLAGS.  May need
  more work.

lisp/amd64-assem.s:
o Use rbx instead of ebx for jmp.

lisp/amd64-lispregs.h:
o Define SC_REG, SC_PC, SC_SP using the new x86 style.

lisp/backtrace.c:
o Remove inline assembly for now until I figure out what the amd64
  version should be.

lisp/gencgc.c:
o Conditionalize out weak hash table support for now.

lisp/gencgc.h:
o Set PAGE_SIZE for amd64.  (Is 4096 right?)

lisp/globals.h:
o Export current_dynamic_space_free_pointer and
  current_auto_gc_trigger like for x86.

gencgc is in use.

Solaris.  The issue is that the siginfo_t is documented to be NULL
sometimes on Solaris.  Also, it appears that at most we only care
about the si_code field of a siginfo_t, so we only fill in the si_code
field when the siginfo_t parameter is not NULL.  Otherwise use 0.
(Carl suggested this solution.)

Also, the Lisp signal handlers appear to ignore the siginfo_t argument
anyway.

  * Eliminate `printf' format string and the following arguments
    conflicts.

  * A variable may be used uninitialized.

  * A variable may be defined but not used.

sigcontext before calling back into Lisp.  The rounding mode is always
set correctly when we reenter Lisp through call_into_lisp.  We now
ensure that the trap bits enabled by the user are also preserved.

and clean-up some minor damage done by the code beautifier.

all of its remaining references.

definitions accordingly.

sigset_t is different from the one used in the Linux kernel.  This means
that we cannot make assignments of sigset_t objects without corrupting
memory.  To work around this problem we update uc_sigmask differently
on Linux than on other systems.  Also, remove x87 control word updates
since the x87 is setup correctly inside call_into_lisp.

These are in global registers and might be trashed.  This makes heap
overflow checking work better on solaris.

There are still bugs.

reg_NARGS macro on these targets and use SC_REG to replace open-coded
assignments to platform specific sigcontext members in interrupt.c and
os-common.c.  This code could be simplified further by merging the x86
and AMD64 cases into the general case.

.indent.pro.

Reported by Carl Shapiro

versions of all the required things, this commit separates the
interrupt handler proper (now interrupt_handle_now_handler) from the
actual work-horse (interrupt_handle_now), which is now only ever called
from the two interrupt handlers, interrupt_handle_now_handler and
maybe_now_maybe_later.  This follows similar changes in SBCL, and is in
fact needed in order to properly use sigreturn in signal handlers, as
required to work around a problem with the G5.

* interrupt.c: oldcont isn't used.

* interrupt.c, monitor.c, validate.c:  Initialize some variables that
  the compiler thinks might be used without initialization.

Deliver protection violations on a dedicated signal stack for amd64

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

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

  - fix a signed/unsigned cast bug that was prevented the
    auto-gc-trigger from functioning correctly when using certain
    dynamic-space sizes (for platforms that don't have an internal gc
    trigger).

  - added a few #include files to avoid compiler warnings

  - changed some #ifdef semantics: DEBUG activates additional
    assertions, and PRINTNOISE activates debugging statements.

o Remove the code in fake_foreign_function_call that was moved to
  build_fake_control_stack_frame

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

code which were previously conditionalized on :FreeBSD, are now
conditionalized on :BSD instead, with the :BSD feature now implying a
4.4BSD(lite2) derived OS.  This should make future BSD-ports easier.
FreeBSD and OpenBSD are differentiated by having either :FreeBSD or
:OpenBSD on the features list.

Currently the OpenBSD port does not have working ELF support, because
OpenBSD 2.9 is still non-ELF by default.  So don't put ELF on the
features list when building for OpenBSD, or fix the code to work
correctly in this case instead.