1.0.6.59: bogus metacircles due to interrupted applicable method comp.

 * If an interrupt arrives while have stuff on the *CACHE-MISS-VALUES-STACK*
   and the interrupt handler happens to call a gf that is already there,
   we used to think this was a metacircle. Instead we need to bind
   variables like this to "empty" values for interrupt hanlers.

 * Test.

 * Note some bugs.

1.0.6.58: better heap exhaustion information

 * Print states of *GC-PENDING*, *GC-INHIBIT*, and
   *SIG-STOP-FOR-GC-PENDING* for fatal heap exhaustions.

 * Use alloc_number instead of make_fixnum for requested/available.

1.0.6.57: fix sb-bsd-socket build on win32

         * Reported by Yaroslav Kavenchuk.

1.0.6.56: replace CALL-WITH-DX-FUNCTION with DX-FLET

 * Essentially same underlying macroexpansion, but more flexible in
   use, and possibly even easier to read.

 * Use DX-FLET instead of LAMBDAs in our CALL-WITH-FOO expansions
   to avoid consing up closures.

1.0.6.55: fix ppc/linux build (probably)

1.0.6.54: fix building contribs from a clean checkout (oops)

1.0.6.53: oops, forgot to "cvs add" some new files

1.0.6.52: mark most current tests failures on buildbot as expected

        * To make it easier to find out when there are new failures.

1.0.6.51: clean up compiler warnings in the runtime

        * Patch by Robert Brown.

1.0.6.50: better arglists for generic functions

        * Parameter names in the lambda list of the generic function
          are given priority to those of the gf's methods, since the
          names given in the generic function are likely to be more
          general.
        * Fix merging of &key parameters of all the methods.
        * Patch by Tobias Rittweiler.

1.0.6.49: make asdf-based contribs more friendly to :FORCE T

        * Do the groveling part of sb-grovel only at contrib build time.
          If the contrib is later recompiled, reuse the results from that
          grovel.
        * Doesn't solve the asdf-binary-locations problems related to
          groveling, but it looks as if asdf-binary-locations is already
          automatically adding SBCL_HOME into it's exceptions list.

1.0.6.48: Don't instrument the internal flets from the PROGV expansion

        * PROGV would get compiled to BINDING-STACK-POINTER -> X, ...,
          BIND-SENTINEL, UNBIND-TO-HERE X, UNBIND-SENTINEL. So the
          UNBIND-TO-HERE would also pop the sentinel from the binding stack,
          and the UNBIND-SENTINEL would then unbalance the stack.
        * Ensure that there will only be matched BIND-SENTINEL /
          UNBIND-SENTINEL pairs between taking the binding stack pointer
          and unwinding by adding some (OPTIMIZE (INSERT-DEBUG-CATCH 0))
          declarations.
* Reported by Nikodemus

1.0.6.47: small fixes

 * When expanding the CLOS cache, insert the new value before copying
   the old ones, in order to ensure that FILL-CACHE always terminations.

 * Cancel deadline before signalling the DEADLINE-ERROR, so that same
   deadline cannot be caught again during unwind.

1.0.6.46: better standard-specializer-p implementation
Instead of defining a gf with several methods, define a new
class STANDARD-SPECIALIZER to be used as a superclass to the
various specializers that are handled internally in PCL.

It's not exported, because we don't want people to subclass it:
they will not be able to implement the relevant protocols.

1.0.6.45: fix compilation speed regression from DATA-VECTOR-REF-WITH-OFFSET

* Change the remaining x86oid DATA-VECTOR-REF VOPs to
          DATA-VECTOR-REF-WITH-OFFSETs. The VOPs only accept an offset of
          0, and are thus functionally identical to the old ones.
        * This allows replacing the conditional deftransform from D-V-R to
          D-V-R-W-O with an unconditional source-transform.
        * Rewrite transformations with (OR (SIMPLE-UNBOXED-ARRAY (*))
          SIMPLE-VECTOR) argument types to instead do the type tests in the
          body of the transform, since the test can be expressed
          in a cheaper way in the latter case.

1.0.6.44: make WITHOUT-INTERRUPTS non-consing

* Consing up a closure for CALL-WITHOUT-INTERRUPTS is a performance
          problem, stack-allocate the closure on platforms with dx support.
        * Doing the stack-allocation properly is a bit tricky, encapsulate
          the right way into the CALL-WITH-DX-FUNCTION macro.
        * TODO: apply the same procedure to other CALL-WITH-FOOs.

1.0.6.43: support saving and restoring code coverage state in sb-cover

1.0.6.42: handle unbound markers (from BIND-SENTINEL) in unbind_to_here

* Like in the x86oid UNBIND-TO-HERE vop
        * Fixes calling SAVE-LISP-AND-DIE when the call stack contains
          functions compiled with high DEBUG quality

1.0.6.41: optimized bignum printing

 * Cache the power-vectors, the computation of which is the real
   bottleneck of bignum printing. So that we don't keep huge bignums
   forever, make GC gently scrub the cache.

 * Rename %OUTPUT-FIXNUM-IN-BASE to %OUTPUT-REASONABLE-INTEGER-IN-BASE
   and %OUTPUT-BIGNUM-IN-BASE to %OUTPUT-HUGE-INTEGER-IN-BASE.

 * The ideal cutoff point between the two algorithms isn't the
   fixnum/bignum divide, but is (on x86/Darwin) around 87 bits -- so
   make the cutoff point N-POSITIVE-FIXNUM-BITS * 3, and hope that
   makes sense on other platforms as well.

 This improves (on x86/Darwin) bignum printing speed in the reasonable
 range by 40%, and by 30% while below 2048 bits. The benefit decreases
 after that, as the GC drops bignums with over 2048 bits from the
 cache -- this doesn't show in a tight benchmarking loop, though.

1.0.6.40: missed tests from 1.0.6.38

 ...for ADD/REMOVE-METHOD thread safety, that is.

1.0.6.39: COMPUTE-DISCRIMINATING-FUNCTION micro-optimization

 * Old versio used WITH-SLOTS to read DFUN-STATE twice per call,
   but (let ((dfun-state (slot-value gf 'dfun-state))) ...)
   is faster, as it avoids the second lookup.

1.0.6.38: thread and interrupt safe ADD/REMOVE-METHOD

 * ADD/REMOVE-METHOD need to grab the GF lock and disable interrupts.

 * ADD/REMOVE-DIRECT-METHOD, and SPECIALIZER-DIRECT-GENERIC-FUNCTIONS
   need a lock as well, but instead of adding per-specializer lock
   just use one global one: contention should be minimal here.

 * INTERN-EQL-SPECIALIZER needs a lock.

 * Fix non-threaded build.

 * Delete dead NAME variables from ADD/REMOVE-METHOD.

 * Tests.

1.0.6.37: thread safety test for the CLOS cache

 ...better late then never.

1.0.6.36: ALLOW-WITH-INTERRUPTS and interrupt safe WITH-MUTEX &co

 * Remove the *IN-INTERRUPTION* kludge, and replace it with a
   general-purpose mechanism.

 * New variable: *ALLOW-WITH-INTERRRUPTS*. WITH-INTERRUPTS is a no-op
   unless it is true and interrupts are inhibited.

 * WITHOUT-INTERRUPTS binds *ALLOW-WITH-INTERRUPTS* to NIL, and
   establishes ALLOW-WITH-INTERRUPTS and WITH-LOCAL-INTERRUPTS as
   local macros.

   ALLOW-WITH-INTERRUPTS binds *ALLOW-WITH-INTERRUPTS* to the value it
   held before entry to WITHOUT-INTERRUPTS.

   WITH-LOCAL-INTERRUPTS is equivalent to
     (allow-with-interrups (with-interrupts ...))
   but somewhat more efficient.

 * Use the above to make WITH-MUTEX &co interrupt-safe, but still
   interruptible: WITH-FOO becomes
     (without-interrupts
       (unwind-protect
           (when (setf foo (allow-with-interrupts (get-foo)))
             (with-local-interrupts ...))
         (when foo
           (release-foo foo))))
   and GET-FOO wraps it's waiting section inside a WITH-INTERRUPTS.

 * While at it, rewrite WITH-MUTEX &co to use CALL-WITH-FOO style
   expansions.

 * Write CALL-WITH-SYSTEM-MUTEX as a more efficient alternative to:

     (without-interrupt (with-mutex ...)) ; and
     (without-gcing (with-mutex ...))

   Similarly for CALL-WITH-RECURSIVE-SYSTEM-SPINLOCK, for the benefit
   of PCL.

 * No need to signal a WARNING for WITH-INTERRUPTS inside a WITHOUT-GCING,
   as *ALLOW-WITH-INTERRUPTS* is always false there, so interrupts will
   not be enabled.

1.0.6.35: slightly bigger +cache-vector-max-length+

1.0.6.34: AVER that the GF lock is held during SET-DFUN

 ...and adjust commentary in UPDATE-DFUN.

1.0.6.33: small CLOS cache improvements

 * General PCL cleanups:
   -- Get rid of FUNCTION-FUNCALL and FUNCTION-APPLY: instead just
      declare the argument type. ETOOMANYLAYERSOFABSTRACTION.
   -- Implement the unused GET-FUN in terms of GET-FUN1 for clarity.

 * Use a single bitmask instead of multiply and mask to compute the
   cache index (like the original implementation).

 * Slower probe depth limit growth: caches with 1024 lines used to
   have probe depth 16, which is starting to be on the slow side, and
   some fairly common generics like PRINT-OBJECT have caches with
   enough entries that they will be large no matter what. Instead of
   (ceiling (sqrt lines) 2) make it (ceiling (sqrt (sqrt lines))).

 * Better CACHE-HAS-INVALID-ENTRIES-P (does less work, picks up
   incomplete lines.)

 * MAP-ALL-CACHES and CHECK-CACHE-CONSISTENCY for debugging and
   analysis.

 * Typo in the format string in PRINT-OBJECT (CACHE T).

 * A couple of non-CLOS optimization possibilities recorded.

1.0.6.32: printing of layoutless structures

 * This used be conditionalized for SB-SHOW builds, but they come up often
   enough when in the debugger during PCL build that it seems worthwhile
   to keep in core.

1.0.6.31: use proper types for STRING-DISPATCH

* We only want to let one-dimensional character strings through.
  This change will probably produce better code, too.

1.0.6.30: clean up FD-SOUT a little bit

* Apparently the bozos have been dealt with; we now receive strings
  to all calls to this function;
* Declare types appropriately.

1.0.6.29: improved WITH-ARRAY-DATA on simple multi-dimensional arrays

* Instead of looping to find the underlying one-dimensional simple
  array, just return it directly.

1.0.6.28: fix UNWIND-TO-FRAME-AND-CALL for #+SB-THREAD

         * Ensure that *UNWIND-TO-FRAME-FUNCTION* has a TLS index

1.0.6.27: make FD-SOUT slightly faster

* Eliminate spurious call to FIND; POSITION gives us enough info.

1.0.6.26: fix sb-posix build on win32

         * patch from Yaroslav Kavenchuk

1.0.6.25: fix non x86oid build

         * Oops, missing an IGNORE declaration

1.0.6.24: a more sophisticated UNWIND-TO-FRAME-AND-CALL for x86 and x86-64

        * Implement three new VOPs:
          ** UNWIND-TO-FRAME-AND-CALL constructs a fake catch block for a
             given frame pointer, runs all unwinds for that block, sets
             the frame pointer to the new value, and calls a given function.
          ** BIND-SENTINEL (stores a marker on the binding stack, used
             to determine how far the binding stack needs to be unwound
             during a U-T-F-A-C).
          ** UNBIND-SENTINEL (pops one of these markers from the stack).
        * Modify IR2 to use these VOPs when converting suitable functions.
        * Modify the IR1 translation in maybe-insert-debug-catch to only
          ensure that tail recursion doesn't happen (needed to match the
          BIND-SENTINELs with UNBIND-SENTINELs).
        * Use these to implement SB-DEBUG:UNWIND-TO-FRAME-AND-CALL:
          ** Grovel the binding stack, uwp block chain and the catch block
             chain for the values needed to reconstruct the dynamic state.
          ** Call SB-VM:U-T-F-A-C.
        * The new implementation should be substantially the same as the
          old one (minor difference in handling of functions with special
          variables in the lambda list). Some tests added to verify this.
        * New implementation is somewhat faster at runtime (a simple
          function call overhead benchmark on (DEBUG 2) improved from 3.4s
          to 2.9s), and significantly faster at compiling (generally around
          15-30% improvement with (DEBUG 2)).
        * Other platforms still use the old implementation that instruments
          the code with a CATCH during IR1 translation.
        * Based on an earlier hack by Alastair Bridgewater.

1.0.6.23: fix a source location tracking problem in sb-cover

         * The logic for selecting the innermost form that contains
           a given character in the source file did not work correctly in
           cases where an exact location could not be found for some source
           path. This should mainly happen when reader macros are involved.
         * Instead of sorting the source paths by the length of the path,
           sort them by the length of the character range of the source
           location.

1.0.6.22: fix occasional UNBOUND-VARIABLE errors in MAP-REFERENCING-OBJECTS

         * Introduced by the removal of (SAFETY 0) in room.lisp a while ago

1.0.6.21: get rid of a runtime compiler note in the PCL cache code

         * For some reason appeared only on x86-64, not x86.

1.0.6.20: add INSERT-ARRAY-BOUNDS-CHECKS declaration to WITH-PUSH-CHAR

* Part of the fun of having good abstractions is being able to
  throw all caution to the wind inside the abstraction.  This
  gives another little speedup on printing floats.

1.0.6.19: optimize BIGNUM-TRUNCATE'ing by small powers of two

* This is a common case when printing floating-point numbers.  On
  the simple "print a million single-floats" benchmark, this wins
  by about 20-25%;
* Also fold a few i+1 loop variables into their only use; doing so
  is not much worse that what we had before and slightly better if
  the backend supports DATA-VECTOR-REF-WITH-OFFSET.

1.0.6.18: Two fixes from Eric Marsden
... DEFPACKAGE :USE/:IMPORT-FROM takes package designators
... REMOVE-DUPLICATES / :TEST-NOT / vectors
Include test cases, and do a little bit of other tidying
of test case expected failures.

1.0.6.17: Housekeeping from specializer changes
Comments and documentation only.

1.0.6.16: add SB-POSIX:GETCWD

 * Based on patch by Tassilo Horn.

 * Factor out the growing buffer -logic used by both getcwd() and
   readlink(), and make it not leak memory so easily.

1.0.6.15: add SB-POSIX:LOCKF

 * Patch by Zach Beane, also add a CREDITS entry for him.

1.0.6.14: slightly more efficient FLONUM-TO-DIGITS

 * Implement SB-IMPL::WITH-PUSH-CHAR: an efficient way of constructing
   shortish strings one character at a time.

 * Use it instead of a string with fill-pointer in FLONUM-TO-DIGITS:
   Speeds up naive float printing tests by ~10%, and causes them to
   cons approx. 7% less.

1.0.6.13: minor fix to the compiler's interval-arithmetic

 * When calculating the interval of (* some-number constant-zero),
   multiply the signums of the interval endpoints, not the numbers
   themselves: this avoids compile-time breakage when the zero is a
   float and the non-zero number is too large to be represented as a
   float.

1.0.6.12: Improve user-subclassed SB-MOP:SPECIALIZER support
In order to support surface syntax for users in DEFMETHOD,
define and bootstrap a new SB-PCL:MAKE-METHOD-SPECIALIZERS-FORM
(a bit like SB-MOP:MAKE-METHOD-LAMBDA).  This or something like
it is fundamentally necessary to support EQL specializers, which
as syntax have a bit which is syntax and a bit which is
evaluated in the lexical environment of the DEFMETHOD form.

Bootstrapping it is a little tedious, but (eventually) work out
where parsed specializers can be made and where we don't yet
have FIND-CLASS in the bootstrap.  In the course of that, note
that we need to be able to parse and unparse specializers at
runtime: parsing to support FIND-METHOD; unparsing to get nice
names for our method functions in backtraces.  Define an
experimental interface for that, too (see NEWS).

In the process, fix a couple of bugs in NO-NEXT-METHOD handling;
it is not safe to assume that the compile-time method name can
be used to find the method object.  Instead, fight a little bit
with the file compiler to have a cons cell shared between the
method function and the method initargs, and arrange to have the
cell's CAR be set to the method once it is created; then we can
do NO-NEXT-METHOD sanely.

Tests for the no-next-method stuff, and adjust wonky find-method
specializer arguments in other tests.

1.0.6.11: PRINT-OBJECT method adjusted for new caches

 * "Oops" -- missed from the original cache commit.

1.0.6.10: put --disable-debugger back where it belongs

* it was accidentally deleted in a previous commit.

1.0.6.9: micro-optimize portions of the reader

* use the more idiomatic (and better optimized) MAKE-ARRAY/REPLACE
  combination to grow the read buffer;
* host some special variable accesses and eliminate bounds checking
  in CASIFY-READ-BUFFER.

1.0.6.8: improve (SUBSEQ FOO 0 ...) on arrays with elements >= word-size

* check for a constant-valued start parameter and pass its value
  through to the loop-generating machinery.  Before we would have
  compared 'START to 0, which always fails; now we can recognize
  that case and generate better code.

1.0.6.7: thread-safe UPDATE-DFUN

 * Make GET-SPINLOCK detect unwanted recursion. Despite the old
   comments in GET/RELEASE-SPINLOCK, we can store EQ-comperable lisp
   objects in SPINLOCK-VALUE -- just like we do for mutexes.
   (Potentially freshly consed bignums that the old comments referred
   to are not sanely EQ-comperable, of course.)

 * Implement WITH-RECURSIVE-SPINLOCK.

 * Adjust thread.impure.lisp accordingly.

 * Add a per generic function spinlock. (We could use mutexes, but
   since contention is presumed to be rare we don't want to pay the
   wakeup syscall cost for every UPDATE-DFUN call: if and when our
   mutexes get smart doing the wakeup only when there are threads
   waiting we can and should switch this -- and probably almost all
   uses of spinlocks -- to mutexes.) This spinlock is grabbed to
   ensure that the dfun state, fin function, and name are all updated
   atomically.

1.0.6.6: delete remains of the unoptimized-cache function code paths

 * 1.0.6.3 did away with the main body of the code, but actual access
   points to the now-missing code paths were accidentally left in.

1.0.6.5: potential CLOS GC safety issue

 * EMIT-FETCH-WRAPPER needs to emit code that checks that it has a
   real standard instance (as opposed to a structure) before it can
   pull the slots: if the structure eg. has no slots at all we would
   be pulling garbage into a lisp variable, which is not good (TM),
   though it should be non-serious on GENCGC platforms.

   To make this fast we add a new slot to LAYOUT: FOR-STD-CLASS-P,
   which is always NIL for layouts, and T for wrappers.

 * Remove one redundant SET-DFUN, which may have been needed in long-gone
   days when cache vectors were resourced, but not anymore.

1.0.6.4: restore buildability on non-SBCL hosts

 * SB!VM, not SB-VM in genesis.lisp. Reported by Peter Graves on sbcl-devel.

1.0.6.3: thread and interrupt safe CLOS cache

 * New cache implementation. While the patch appears to modify
   src/pcl/cache.lisp, it is really a wholesale reimplementation.

   -- Use compare-and-swap to provide atomicity where necessary.

   -- Layouts are write-once, but cached values can be replaced
      atomically.

   -- Expanding the cache (or dropping invalidated and incomplete
      entries) copies the cache.

   -- Use ..EMPTY.. as a sentinel value to denote unused cache line
      slot.

   -- Cache index zero is no longer special.

   -- Maximum cache size is limited to avoid ridiculously huge caches.

   -- API changes in the cache code: MAKE-CACHE replaces GET-CACHE.
      PROBE-CACHE now returns a primary indicating a hit or a miss,
      and returns the probed value as the second return value.

 * Move remaining non-cache related code from cache.lisp.

 * Delete unused closure-based dispatch code (src/pcl/dlisp2.lisp). If
   we want to support a compilerless build at some future date this
   code can be always resurrected from the CVS -- or better yet, can
   be re-implemented.

 * Delete MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN, inlining it to the
   call-sites for easier understanding. (Yes, there is such a thing as
   too much abstraction.)

1.0.6.2: remove multiple layout-clos-hash slots

 * It seems that despite the claims of the paper "Efficient Method
   Dispatch in PCL" the multiple hash seeds yield a neglible benefit.

 * The soon-to-come thread safe cache also uses only a single hash
   value, so removing these now allows better performance comparisons:
   multiple hash values vs. single hash value vs. new cache.

 Actual work done mostly by Christophe Rhodes.

1.0.6.1: marginally nicer "name" for socket streams

 * "a socket" instead of "a constant string". It might be worth while
   to actually make this based on the socket-name and -peername,
   though.

1.0.6: release, will be tagged as sbcl_1_0_6

1.0.5.56: conditionally re-enable interrupts interrupting current thread

 * New variable: *IN-INTERRUPTION* is true IFF we're being called inside
   *IN-INTERRUPTION* and there are no intervening WITHOUT-INTERRUPTS.

 * INTERRUPT-THREAD calls the interrupt function inside WITH-INTERRUPTS
   when interrupting the current thread IFF *IN-INTERRUPTION* is true.

 * Remove bogus FIXME by yours truly from INVOKE-INTERRUPTION and
   properly explain what is going on -- and add another FIXME in its
   place.

 This makes nested SIGINTs DTRT.

1.0.5.55: interrupt safe REFILL-BUFFER/FD

 * Check for blocking / wait for new input before touching the stream.

 * Check that the SAP is still there after the wait, in case an interrupt
   handler or an FD handler closed the stream from under us.

 * Wrap the main action in WITHOUT-INTERRUPTS to prevent asynch unwinds
   from leaving the stream in an inconsistent state. (Since the read
   is going to be non-blocking it should be over soon enough.)

 * Arrange to signal errors outside the WITHOUT-INTERRUPTS.

1.0.5.54: fix thinko in src/code/array.lisp

* thanks to Eric Marsden

1.0.5.53: cleanup LOAD-TYPE macros

* when the LOAD-TYPE macros in the various backends hardcoded '3',
  they really meant (1- N-WORD-BYTES)--a little reflection on
  widetags, lowtags, and endian orderings should make this clear
  (we don't have a 64-bit big-endian port to drive it home, though);
* catch the spread of magic constants in code/array.lisp.

1.0.5.52: fix #!-sb-unicode build problems on x86-64

* just a few uncopied things from the x86 version...

1.0.5.51: fixed mixed up commit 1.0.5.50

 * SIMPLE-VECTOR-COMPARE-AND-SWAP, not SAFE-SIMPLE-VECTOR-COMPARE-AND-SWAP.

 * Missing tests.

 * Whitespace.

 * foreign.test.sh jugglery

   This path breaks foreign.test.sh on x86/Darwin even without
   touching it, indicative of still lingering Darwin issues. Any
   number of changes can mask this breakage: adding SAFE- prefix to
   SIMPLE-VECTOR-COMPARE-AND-SWAP is enough to make foreign.test.sh
   pass again, but so is adding a sneaky --eval nil in there as well
   -- among other things.

   Pain. Hate. Pain. See commentary in foreign.test.sh

   This time the issue doesn't seem to be foreign stack alignment
   related, though: forcing the compiler to use the fast call-out path
   always doesn't make the "small" case pass.

1.0.5.50: some compare-and-swap changes

 * Since we have a non-threaded %INSTANCE-COMPARE-AND-SWAP on all
   platforms, define DEFINE-STRUCTURE-SLOT-COMPARE-AND-SWAP on
   non-threaded builds as well.

 * Bounds checking SIMPLE-VECTOR-COMPARE-AND-SWAP, plus tests.

1.0.5.49: interrupt & GC & PA handling

 * On all FOREIGN_FUNCTION_CALL_FLAG platforms arch_pseudo_atomic_atomic is
   always accompanied by !foreign_function_call_active.

   For clarity move checking it to the a_p_a_a definitions on platforms that
   need it.

   TEST ALERT: This touches all the non-x86oid platforms, but I have
   not been able to test on them -- so a thinko/typo build-breakage is
   not impossible.

 * If we somehow ended up in interrupt_handle_pending in the middle of a PA
   section we might GC in the middle of it, or lose PA interrupted flags.

   Now we punt straight up if we get there in the middle of PA.

 * If we handled a pending interrupt outside GC-INHIBIT, but inside a PA
   section, with both GC_PENDING and SIG_STOP_FOR_GC_PENDING was true, we
   would be left running with GC_PENDING cleared without actually taking any
   action.

   The previous item actually fixes this, but for clarity make
   sig_stop_for_gc_handler clear the GC_PENDING and SIG_STOP_FOR_GC_PENDING
   iff it actually stops the thread.

 * The single UWP implementation for WITHOUT-GCING was incorrect: if
   we had a GC but no interrupts pending when checking for pending
   interrupts and GCs, and caught an asynch unwind at that point we
   could be left running with the GC pending (and/or related signals
   blocked).

   Due to the increased cost of WITHOUT-GCING, check first if GC is
   already disabled before taking the UWP code path.

1.0.5.48: Git friendly clean.sh

 * Ignore .git.

1.0.5.47: cacheability of EMFs from methods with non-standard specializers
... the second return value from
COMPUTE-APPLICABLE-METHODS-USING-CLASSES promises that the
first return value can be cached.  It doesn't promise that an
arbitrary computation on the specializers will work, so we need
not to go down that codepath.
... so refuse to build dispatch discriminating functions if any
method of the generic function has a non-standard
        (non-PCL-native) specializer, as operations such as
SB-PCL::SPECIALIZER-CLASS and SB-PCL::TYPE-FROM-SPECIALIZER
will fail on such specializers
... rework SPECIALIZER-CLASS-OR-NIL to call the new function
STANDARD-SPECIALIZER-P.
... test case.

1.0.5.46: improve handling of non-standard subclasses of SB-MOP:SPECIALIZER
... define SPECIALIZER-CLASS-OR-NIL for use in RAISE-METATYPE,
and adjust RAISE-METATYPE to handle NIL return values.
... add commentary around RAISE-METATYPE to explain what all the
metatypes actually mean.
... EMIT-FETCH-WRAPPER was missing a CONDITION-INSTANCE case,
and further drew fine distinctions where there were none...
... so delete BUILT-IN-OR-STRUCTURE-WRAPPER, and call WRAPPER-OF
instead.  (But leave in the GC safety bug reported sbcl-devel
2007-05-10.)
... one more fix to PARAMETER-SPECIALIZER-DECLARATION-IN-DEFMETHOD
for CLASS-EQ specializers on built-in-classes.

1.0.5.45: metatypes-related refactor
Many of the dlisp functions took (metatypes applyp) arguments,
when in fact all they were using was the length of the metatypes
argument and the applyp boolean.  Make this explicit, to assist
in understanding when the identity of metatypes actually
matters.

1.0.5.44: fix reading of a suppressed #. in sb-cover

         * Suppressing of #. in the source location recording read-table was
           implemented incorrectly. (Reported by James Knight)
         * Don't silently ignore read errors.
         * Use a dummy source location map for top level forms for which
           an error was signaled, rather than NIL. Otherwise the compiler's
           and sb-cover's tlf numbering could get out of sync.

1.0.5.43: change memory layout on FreeBSD

* Move read-only-space and neighbours to lower space to avoid
  potential conflicts with runtime user space.

* Move dynamic-space to higher space so that kern.maxdsiz can be
  increased at least 1GB.

Brief memory layout of FreeBSD:

+------------+ -- 0x00000000
|    free    |
+------------+ -- 0x08000000
| user space |
+------------+ -- brk (grows downward)
~            ~
+------------+ -- 0x28000000 (0x08000000 + maxdsiz)
| mmap,shlib |
~            ~
+----------- + -- stack top (grows upward)
| stack space|
+------------+ -- 0xC0000000
|   kernel   |
+------------+ -- 0xFFFFFFFF

1.0.5.42: fix (setf aref) on single-float vectors

          Obvious patch by Christophe, reported by Eric Marsden.

10.\7f\7fCVS: ----------------------------------------------------------------------

1.0.5.40: probably fix win32 build

         * sb!unix::micro-seconds-per-internal-time-unit was defined in a
           #-win32 block
         * Reported by Yaroslav Kavenchuk

1.0.5.39: sb-sprof call counting

         * Add support for deterministically tracking the amount of times
           that certain functions were called during a sb-sprof profiling
           run.
         * The goal is to allow people to easily see whether a lot of time
           is spent in function X due to it being called often, or due to
           the average call being slow.
         * The benefit over using sb-profile is that a) the reporting
           of the call counts is integrated into the normal sb-sprof
           interface and b) there's a lot less overhead, since we're just
           counting calls, not tracking cpu usage / consing.

1.0.5.38: PCL cache-lookup code emission refactoring

 * Pass cache-variable name explicitly to EMIT-DLAP.

 * Use a gensym for the miss-tag.

 * Factor cache lookup code emission to a separate function EMIT-CACHE-LOOKUP.

1.0.5.37: cleanup a small thinko from previous x86-assem.S refactoring

 * EBP is available to use in ALLOC, so use it.

1.0.5.36: x86 allocation cleanup

 * Ensure stack alignmenment on calls to alloc() on Darwin.

 * Ensure that DF is cleared on calls to alloc().

 * Preprocessorize the alloc_foo definitions.

1.0.5.35: stack alignment on x86/Darwin, once more

 * Stack alignment cannot be changed after arguments have been pushed
   on stack: ALLOCATE-NUMBER-STACK-SPACE is the place to do this, and
   nowhere else.

 * Use the RESET-STACK-POINTER logic on all x86 platforms for
   simplicity.

 * Factor out the alignment logic to ALIGN-STACK-POINTER.

 * Clear DF unconditionally when calling out, which means that Solaris
   doesn't need to switch it back and forth. (Darwin, Solaris, and Win32
   all need DF cleared for call-out.)

1.0.5.34: faster STRING-TO-OCTETS for unibyte and UTF-8 encodings

* redo DEFINE-UNIBYTE-MAPPER to use a lookup table instead of
  a big CASE statement (optimizes for the common (?) case of
  mostly ASCII characters and gives smaller code);
* STRING->LATIN% now optimistically assumes that there are
  no encoding errors in the string and allocates an
  appropriately-sized octet vector upfront, falling back to
  the slower path if an encoding error is detected;
* do more or less the same thing for UTF-8 encoding, except
  that there is no slow path (since UTF-8 can encode all
  characters, unlike unibyte encodings)
* we have a ton of external formats; use a hash table for
  *EXTERNAL-FORMAT-FUNCTIONS* rather than a list to cut down
  on lookup time (this alone is worth ~10% without the other
  optimizations above...).

Code cleanups:

* use string package names like every other source file;
* properly separate function names from arglists;
* don't pass END parameters when we don't use them.

End result is ~20-30x speedup for unibyte encodings (depending
        on the encoding--LATIN-1 is ~20x, whereas something like CP857
        is ~30x) when encoding ASCII strings; smaller but still
        significant speedups when encoding non-ASCII strings.  UTF-8
        encoding is ~5-6x faster, which also means that we're faster
        than TRIVIAL-UTF-8 for encoding now (decoding is an entirely
        different matter).

1.0.5.33: fix botched commit 1.0.5.32: partial fix for DISASSEMBLE buglet

  * Test for >= length, not > length.

  * Record the remaining WARNING in BUGS.

1.0.5.32: partial fix for DISASSEMBLE bug reported by Peter Graves

  * Test for >= length, not > length.

  * Record the remaining WARNING in BUGS.

1.0.5.31: Make sb-introspect's FUNCTION-ARGLIST safer
... less likely to read off some random word in memory
as an arglist.

1.0.5.30: small PCL re-organization
 * Move some non-cache code from src/pcl/cache.lisp to wrapper.lisp and
   dlisp.lisp.

 No functional changes.

1.0.5.29: fix a race-condition in deadline.impure.lisp
 * The thread that is supposed to hold the mutex might no yet have
   grabbed it.

1.0.5.28: new contrib: sb-cover, a code coverage tool

         Still somewhat experimental, so it might be changed incompatibly once
         people start actually using it. Or maybe even removed, if it's not
         found to be useful in practice. More documentation on interpreting
         the output and on the limitations of the coverage tool will be
         committed later.

         * Compiler
           * Instrument all forms found in the original source code
             when the store-coverage-data optimization quality is larger
             than 1.
           * The instrumentation is fairly lightweight; just literal conses that
             are modified when the form is executed.
           * This requires hacking the compiler to allow modifying literals
             when we know what we're doing.
           * Add some extra source location tracking capabilities to handle
             non-cons source forms better (though still not perfectly).
         * Contrib
           * Get the instrumentation data from the compiler, and create
             a aggregate report + pretty annotate source code reports
             (as html) from it.
           * The latter uses a modified version of the source code tracking
             read-table from Swank, written by Helmut Eller.

1.0.5.27: Stepper support for MIPS.

1.0.5.26: Whitespacing.

1.0.5.25:
Fix argument signedness format.

1.0.5.24:
Silence compiler warning.

1.0.5.23:
Fix spelling.

1.0.5.22:
Delete obsolete depends: dummy target.

1.0.5.21:
Code formatting.

1.0.5.20: make class-eq specializers work in defmethods
Mostly for consistency: this is not an exported extension or
anything.  But it was gratuitously broken before, and it was
also broken in ways preventing user-defined specializers from
working.  So fix it and test it, with a comment saying that it's
OK to break it deliberately.

(User-defined specializers do not currently work, even after
this change.)

1.0.5.19: restore building on cmucl 19a-ish
... sb!xc:macroexpand in code seen by the host compiler.  (Said
code was never executed by the host compiler, because of
the return value of fopcompileable-p)

1.0.5.18: trapping-based stepper on the Sparc
... implement instrumentation for :before and :around cases;
... as suggested by Juho, use NTH-INTERRUPT-CONTEXT rather than
allocating a SAP in a signal handler;
... actually run the tests on sparc too.

1.0.5.17: Top-level DECLARE signals an error
... probably the user meant a top-level DECLAIM, but in the
absence of proof an error is a decent choice for undefined
behaviour.