code/misc.lisp::
* Remove :i486 from *features*

code/multi-proc.lisp::
* Change :i486 to :x86 on the off chance that multi-proc will be
  ported to other archs.

compiler/x86/cell.lisp::
compiler/x86/macros.lisp::
compiler/x86/memory.lisp::
* Remove guard on backend-featurep :i486 since we got rid of :i486 and
  have it always enabled now.

src/lisp/x86-assem.S:
o Remove the (now) unused alloc_to_<reg> functions.

src/compiler/x86/macros.lisp:
o Simplify the not-inline-allocation to use the same routines as
  inline allocation.

src/bootfiles/20c/boot-2012-07-1-x86-cross.lisp:
o X86 cross-compile script

src/compiler/x86/macros.lisp:
o New inline-allocation to call our new overflow routine.

src/lisp/x86-assem.S:
o New alloc_overflow routine.

src/tools/cross-scripts/cross-x86-x86.lisp:
o Export all symbols in VM that are external symbols in OLD-VM with
  the corresponding symbol name.

lisp/x86-assem.S:
o Make sure the stack is 16-byte aligned in the alloc_overflow_foo and
  alloc_to_foo routines.  These eventually call into C code, and the
  stack is required to be 16-byte aligned on Darwin.  We apply this to
  all x86 implementations since it's harmless.
o Did not update the alloc_8/16_to_foo routines because they are going
  to be deleted.

x86/macros.lisp:
o Don't call the alloc_8/16_to_foo routines when we're not doing
  inline allocation.  I don't think there's much to be gained with
  these special functions and maintainence is a pain with assembly
  code.

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

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.

many cases, the value and result were in the same tn, but not always.)

various stores to 8-bit and 16-bit specialized arrays.

the previous VOPs had.

various loads from 8-bit and 16-bit specialized arrays.

	bootstrapping.

	* src/bootfiles/18e/boot16.lisp: New file.

	* src/docs/cmu-user/extensions.tex (Dynamic-Extent Declarations):
	New section.

	* src/compiler/x86/macros.lisp (dynamic-extent-allocation):
	Rename from stack-allocation, save an instruction.
	(allocation): Don't call trust-dynamic-extent-declaration-p.

	* src/compiler/x86/alloc.lisp (%dynamic-extent-start)
	(%dynamic-extent-end): New vops.
	(list-or-list*): Add constant arg dynamic-extent.
	(fixed-alloc): Likewise.

	* src/compiler/generic/vm-ir2tran.lisp (do-fixed-alloc): Call
	fixed-alloc with dynamic-extent arg.

	* src/compiler/hppa/alloc.lisp (%dynamic-extent-start)
	(%dynamic-extent-end): Add dummy vops.
	* src/compiler/mips/alloc.lisp:
	* src/compiler/ppc/alloc.lisp:
	* src/compiler/alpha/alloc.lisp:
	* src/compiler/rt/alloc.lisp: Likewise.

	* src/compiler/seqtran.lisp (mapper-transform): Add dynamic-extent
	declarations.

	* src/compiler/node.lisp (continuation): Add slot
	dynamic-extent.
	(cleanup): Add :dynamic-extent to type of slot kind.

	* src/compiler/knownfun.lisp (dynamic-extent-closure-safe):
	New attribute.

	* src/compiler/ir2tran.lisp (ir2-stack-allocate): New function.
	(ir2-convert-closure): Handle dynamic-extent case differently.
	(%dynamic-extent, %dynamic-extent-start, %dynamic-extent-end)
	<ir2-convert>: New optimizers.
	(list, list*): Handle dynamic-extent.

	* src/compiler/ir1tran.lisp (*trust-dynamic-extent-declarations*)
	(*dynamic-extent-trace*): New variables.
	(trust-dynamic-extent-declaration-p): New function.
	(process-dynamic-extent-declaration)
	(dynamic-extent-allocation-p, dynamic-extent-closure-args)
	(gen-%dynamic-extent, with-dynamic-extent): New functions/macros.
	(ir1-convert-combination): Handle dynamic-extent closure args.
	(ir1-convert-combination-args): Add arg dynamic-extent-args.
	Set continuation-dynamic-extent for these args.
	(process-dynamic-extent-declaration): Rewritten.
	(ir1-convert-dynamic-extent-bindings): New function.
	(ir1-convert-special-bindings): Call it.
	(ir1-convert-lambda-body): Handle dynamic-extent rest lists.
	(let): Handle dynamic-extent vars.
	(let*): Call ir1-convert-dynamic-extent-bindings.

	* src/compiler/globaldb.lisp (*trust-dynamic-extent-declarations*)
	(trust-dynamic-extent-declaration-p): Remove.

	* src/compiler/fndb.lisp: Add dynamic-extent-closure-safe
	attribute to assorted functions.

	* src/compiler/envanal.lisp (environment-analyze): Call
	find-dynamic-extent-safe-closures.
	(emit-cleanups): Handle :dynamic-extent cleanups.
	(*suppress-dynamic-extent-closure-safe*): New variable.
	(mark-dynamic-extent-safe-closures)
	(find-dynamic-extent-safe-closures): New functions.

	* src/compiler/byte-comp.lisp (compute-produces-and-consumes):
	Treat :dynamic-extent like :tagbody cleanups.

	* src/code/exports.lisp ("C"): Export ir2-stack-allocate,
	%dynamic-extent, %dynamic-extent-start, %dynamic-extent-end.

	* src/code/byte-interp.lisp (%dynamic-extent):
	(%dynamic-extent-start, %dynamic-extent-end): New functions.
	(toplevel): Enable block compilation.

	user-settable variable and an interface function that can be used
	across backends.

	* src/compiler/globaldb.lisp
	(*trust-dynamic-extent-declarations*): New variable.
	(trust-dynamic-extent-declaration-p): New function.
	* src/compiler/x86/macros.lisp (allocation): Use it.
	* src/compiler/sparc/macros.lisp (allocation): Use it.

	* src/code/exports.lisp ("EXTENSIONS"): Export
	*trust-dynamic-extent-declarations*.
	* src/code/exports.lisp ("C"): Export
	trust-dynamic-extent-declaration-p.

	for dynamic-extent because it's otherwise impossible to use use
	dynamic-extent in code that otherwise needs to have type checks
	compiled in.

	greater than safety for stack-allocation to actually happen, which
	is what ACL defaults to.  Use boot15.lisp to bootstrap.

	* src/bootfiles/18e/boot15.lisp: New file.

	* src/compiler/node.lisp (leaf): Add slot dynamic-extent.

	* src/compiler/x86/macros.lisp (load-size, inline-allocation)
	(not-inline-allocation): Extract from function allocation.
	(stack-allocation): New function.
	(allocation): Add arg dynamic-extent.  Call stack-allocation
	if dynamic-extent is true, and speed > safety.

	* src/compiler/x86/call.lisp (listify-rest-args): Add
	constant third arg, and pass it to allocation.

	* src/code/class.lisp (find-layout): Put part in
	#-bootstrap-dynamic-extent.

	* src/compiler/ir1tran.lisp (process-dynamic-extent-declaration):
	New function.
	(*suppress-dynamic-extent-declaration*): New variable.
	(process-1-declaration): Call process-dynamic-extent-declaration.
	(convert-more-entry) [#+x86]: Call %listify-rest-args with
	third arg dynamic-extent.

	* src/compiler/eval-comp.lisp (%listify-rest-args) [#+x86]:
	* src/compiler/fndb.lisp (%listify-rest-args) [#+x86]: Add
	third arg for dynamic-extent.

	Possibly temporary workaround for SBCL build problems caused by a
	situation like

	  (defvar *foo*)
	  (declaim (type foo *foo*))
	  (defstruct foo)
	  (defun foo ()
	    (let ((*foo* (some-unknown-function)))
	       ...))

	When a type check is being generated for the local binding of
	*foo*, *foo*'s type in the info database is still an unknown-type.
	The typep transform generates a call to %instance-typep, because
	it knows that foo is an instance.  The deftransform for
	%instance-typep does not run, so an actual call to %instance-typep
	is being generated.  A function %instance-typep doesn't exist at
	run time, though.

	* src/compiler/ir1tran.lisp (find-free-variable): If the
	variable's type is an unknown-type, reparse it, and change the
	type in the info database.

	have according to CLtS.  Found by Paul Dietz.

	Use boot14.lisp to bootstrap.

	* src/compiler/generic/utils.lisp (fixnumize): Renamed from
	fixnum.

	* src/bootfiles/18e/boot14.lisp: New file.

	* src/code/exports.lisp ("VM"): Export fixnumize.

	* src/assembly/alpha/arith.lisp, src/assembly/alpha/array.lisp:
	* src/assembly/alpha/assem-rtns.lisp, src/assembly/hppa/arith.lisp
	* src/assembly/hppa/array.lisp, src/assembly/hppa/assem-rtns.lisp
	* src/assembly/mips/alloc.lisp, src/assembly/mips/arith.lisp
	* src/assembly/mips/array.lisp, src/assembly/mips/assem-rtns.lisp
	* src/assembly/mips/bit-bash.lisp, src/assembly/ppc/arith.lisp
	* src/assembly/ppc/array.lisp, src/assembly/ppc/assem-rtns.lisp
	* src/assembly/rt/alloc.lisp, src/assembly/rt/arith.lisp
	* src/assembly/rt/array.lisp, src/assembly/rt/assem-rtns.lisp
	* src/assembly/sparc/arith.lisp, src/assembly/sparc/array.lisp
	* src/assembly/sparc/assem-rtns.lisp, src/assembly/x86/arith.lisp
	* src/assembly/x86/array.lisp, src/assembly/x86/assem-rtns.lisp
	* src/compiler/alpha/alloc.lisp, src/compiler/alpha/arith.lisp
	* src/compiler/alpha/array.lisp, src/compiler/alpha/call.lisp
	* src/compiler/alpha/move.lisp, src/compiler/alpha/nlx.lisp
	* src/compiler/alpha/static-fn.lisp, src/compiler/alpha/subprim.lisp
	* src/compiler/alpha/values.lisp, src/compiler/generic/utils.lisp
	* src/compiler/hppa/alloc.lisp, src/compiler/hppa/arith.lisp
	* src/compiler/hppa/array.lisp, src/compiler/hppa/call.lisp
	* src/compiler/hppa/move.lisp, src/compiler/hppa/nlx.lisp
	* src/compiler/hppa/static-fn.lisp, src/compiler/hppa/subprim.lisp
	* src/compiler/hppa/values.lisp, src/compiler/mips/alloc.lisp
	* src/compiler/mips/arith.lisp, src/compiler/mips/array.lisp
	* src/compiler/mips/call.lisp, src/compiler/mips/move.lisp
	* src/compiler/mips/nlx.lisp, src/compiler/mips/static-fn.lisp
	* src/compiler/mips/subprim.lisp, src/compiler/mips/values.lisp
	* src/compiler/ppc/alloc.lisp, src/compiler/ppc/arith.lisp
	* src/compiler/ppc/array.lisp, src/compiler/ppc/call.lisp
	* src/compiler/ppc/move.lisp, src/compiler/ppc/nlx.lisp
	* src/compiler/ppc/static-fn.lisp, src/compiler/ppc/subprim.lisp
	* src/compiler/ppc/values.lisp, src/compiler/rt/alloc.lisp
	* src/compiler/rt/arith.lisp, src/compiler/rt/array.lisp
	* src/compiler/rt/call.lisp, src/compiler/rt/move.lisp
	* src/compiler/rt/nlx.lisp, src/compiler/rt/static-fn.lisp
	* src/compiler/rt/subprim.lisp, src/compiler/rt/values.lisp
	* src/compiler/sparc/alloc.lisp, src/compiler/sparc/arith.lisp
	* src/compiler/sparc/array.lisp, src/compiler/sparc/call.lisp
	* src/compiler/sparc/move.lisp, src/compiler/sparc/nlx.lisp
	* src/compiler/sparc/static-fn.lisp, src/compiler/sparc/subprim.lisp
	* src/compiler/sparc/values.lisp, src/compiler/x86/alloc.lisp
	* src/compiler/x86/arith.lisp, src/compiler/x86/array.lisp
	* src/compiler/x86/call.lisp, src/compiler/x86/cell.lisp
	* src/compiler/x86/macros.lisp, src/compiler/x86/memory.lisp
	* src/compiler/x86/move.lisp, src/compiler/x86/nlx.lisp
	* src/compiler/x86/pred.lisp, src/compiler/x86/static-fn.lisp
	* src/compiler/x86/subprim.lisp, src/compiler/x86/values.lisp:
	Use fixnumize instead of fixnum.

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.

first introduced with the i486.

so need not be targeted to a temporary, possibly saving a temporary TN
and move.

as parameters rather than variables.

the global *adjustable-vectors* resource, rather allocate an new
vector for each use in emit-error-break. These vectors are small and
in most cases the required length is less than 8 bytes which is the
new lower default.

data-vector-set-conditional for simple-arrays which is handy for
writing thread and interrupt safe code.

increase speed.
Replace the fixed-allocation macro by a with-fixed-allocation macro
that wraps the allocation and optional forms in a pseudo-atomic.

node-var as an optional argument so the allocation function can make
policy decisions (to inline with GENCGC).

Remove the make-complex-{single,double}-float functions, and just
define the VOPs as translations of the complex function.

Fix a few bugs in the complex-float move VOPs.

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.

x86 package:
*allocation-pointer*
*binding-stack-pointer*
*x86-cgc-active-p*
*static-blue-bag*
*internal-gc-trigger*
All *unused-static-**