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

within guard_zones since the stack overflow checking was only ported
to x86 and sparc.

Make the size of all spaces configurable from the command line.

code/commandline.lisp:
o Define the switches so lisp doesn't complain.

general-info/lisp.1:
o Document new switches.

general-info/release-20c.txt:
o Update

lisp/Darwin-os.c
lisp/FreeBSD-os.c
lisp/Linux-os.c
lisp/NetBSD-os.c
lisp/backtrace.c
lisp/cgc.c
lisp/gencgc.c
lisp/os-common.c
lisp/ppc-validate.h
lisp/purify.c
lisp/solaris-os.c
lisp/sparc-arch.c
lisp/sparc-validate.h
lisp/x86-validate.h:
lisp/validate.c
o Basically rename CONTROL_STACK_SIZE, BINDING_STACK_SIZE,
  READ_ONLY_SPACE_SIZE, and STATIC_SPACE_SIZE to control_stack_size,
  binding_stack_size, read_only_space_size, and static_space_size,
  respectively.

lisp/coreparse.c
o Check the space size in the core file against the allocated size.
  If the allocated space is too small, print an error message and
  exit.

lisp/globals.c
o Define new variables for the allocated size of spaces.

lisp/globals.h
o Declare the new variables for the size of the spaces.

lisp/lisp.c
o Set the default values of the spaces.
o Parse the new command-line flags and set the space sizes.

lisp/sunos-os.c:
o Added os_init0 (that we forgot last time).

lisp/x86-assem.S:
o Change $CONTROL_STACK_END to GNAME(control_stack_end) to get the
  correct end of the stack.

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.

everywhere, not just for unicode.  Non-unicode takes a small hit from
doing an unnecessary strcpy, but that should not be critical.

builds.

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

void keyword to specify empty parameter lists.

h_errno.  Like errno, it is left unspecified whether h_errno is a
macro or an identifier declared with external linkage.  Let the C
compiler sort this out for us.

errno accessors shared by all ports.  Change the definition of
UNIX:UNIX-ERRNO so that it always calls down to an accessor function.

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.

the equivalent standard C mem{cpy,move,set} functions.

relatively straightforward port of the sparc version of
linkage-tables.  Some refinements are probably still needed, as well
as some testing.

Use boot-2005-02-ppc-linkage.lisp to bootstrap this change from the
2005-02 snapshot.

* code/ppc-vm.lisp
  o Add appropriate FOREIGN-SYMBOL-ADDRESS-AUX and FIND-FOREIGN-SYMBOL
    functions for linkage-table.

* compiler/generic/new-genesis.lisp
  o Basically do the same as the sparc port for linkage-tables.
  o need to extern-alien-name on the cold linkages since they C names
    depend on the backend conventions.

* compiler/ppc/alloc.lisp
  o Load "undefined_tramp" appropriately for linkage-tables.

* compiler/ppc/c-call.lisp
  o Define new vops (FOREIGN-SYMBOL-CODE-ADDRESS,
    FOREIGN-SYMBOL-DATA-ADDRESS) for linkage-tables so we can access
    correctly.

* compiler/ppc/cell.lisp
  o Load "closure_tramp" appropriately for linkage-tables
  o Load "undefined_tramp" appropriately for linkage-tables

* compiler/ppc/parms.lisp
  o Put the foreign linkage space start at the end of the static space
    to make it easier to bootstrap.  (We need already mapped memory.)
    We can move this later.
  o Correct TARGET-FOREIGN-LINKAGE-ENTRY-SIZE.
  o Add new static-symbol *linkage-table-data*
  o While were at it, add SPARE-9 and SPARE-0 static symbols so we
    have 10 spares.

* lisp/Config.ppc_darwin
  o Add -DLINKAGE_TABLE to CFLAGS/ASFLAGS if we have linkage-table
    support.

* lisp/Darwin-os.c
  o Add os_dlsym to support linkage-tables.  (This nees a little
    refactoring because we just copied the #defines for dlopen modes.)

* lisp/os-common.c
  o The checking of the linkage tables that is done for sparc almost
    works for ppc, but not quite.  Implement one for ppc.

* lisp/ppc-arch.c
  o Add PPC version of arch_make_jump_entry, arch_make_linkage_entry,
    arch_linkage_entry.

* lisp/ppc-assem.S
  o Add lazy_resolve_linkage to support linkage-tables.  This needs
    some more work.
  o Add undefined_foreign_symbol_trap.  This probably needs work, and
    definitely needs testing.

* lisp/ppc-validate.h
  o Define the start of the linkage space and size.

* backtrace.c, save.c:  fprintf warnings.
* interrupt.h: Declare build_fake_control_stack_frame and
  interrupt_handle_space_overflow.
* os-common.c: Include interrupt.h to define
  build_fake_control_stack_frame.
* parse.c, runprog.c, search.c:  Include some standard system headers
  to get rid of undefined function warnings.

* alloc.c:  Include gencgc.h to get declaration of alloc().
* gencgc.c:
  o Include string.h for memset.
  o Initialize some vars that gcc complains might be uninitialized
    (but they're not).
  o scav_fdefn isn't used on sparc, so comment it out.
  o valid_dynamic_space_pointer, maybe_adjust_large_object, and
    preserve_pointer are only used on x86, so comment #ifdef them for
    i386.
* os-common.c:
  o Fix a few printf warnings.
  o Cast args to bcopy.

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

o Make new-genesis save target-foreign-linkage-table-size to
  internals.h.

o Conditionalized some code that is only used in linkage-table builds
  on :linkage-table and LINKAGE_TABLE respectively.
o Modernized undefined_ff_tramp based on recent changes, and renamed
  it to undefined_foreign_symbol_trap, because it really isn't a
  trampoline.
o Conditionalized a stray puts(...,dlerror()) in Linux-os.c on DEBUG
o Installed an error reporter for UNDEFINED_FOREIGN_SYMBOL_ERROR,
  which for now signals a simple-program-error.  We might want to
  introduced a new condition UNDEFINED-FOREIGN-SYMBOL or something,
  which could also be used by the old foreign linkage code.

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.

genesis anyway.