1.0.26.1: Modify uploading instructions in release checklist

1.0.26: release, will be tagged as sbcl_1_0_26

1.0.25.58: HPPA fixes from Larry Valkama

1.0.25.57: fix compilation on win32

1.0.25.56: SUB-GC: don't observe deadlines

- because the condition that's signalled can cause arbitrary code to
  run catching us with pants down

- and we should not skip gc if it was triggerred

1.0.25.55: x86 disassembler fixes.

  Made operand-size-prefix bytes disassemble correctly, using the same
approach used in the x86-64 backend (extra instruction formats for
reading the prefix byte).

  Fixed movzx and movsx instructions to indicate the size of the source
data when moving from memory.

  Added printers for cbw, cwde and cwd instructions.

1.0.25.54: centralize scattered arch_os_get_context() calls

... to the six signal handlers trampolines. These are now the only
places where void_context appears, the rest of the runtime uses
os_context_t.

Also, the &void_context+37 hack was removed. On Sparc/Linux the third
parameter of SA_SIGINFO signal handlers is a pointer to sigcontext,
which happens to be the same as &void_context+37 most of the time,
though.

I have tested two on Sparc/Linux boxes, one running 2.6.26 that
randomly segfaulted compiling itself with 1.0.25.12, and another
runnin 2.6.24 that worked fine before at that version.

Thanks to Bruce O'Neel for the shell access.

1.0.25.53: fix gencgc_handle_wp_violation on multicpu systems

Acquire free_pages_lock around page_table accesses to be sure that the
changes actually propagate to other CPUs and we don't end up losing in
the else branch and also to prevent problems caused by the compiler or
the processor reordering stuff.

1.0.25.52: go through lisp_memory_fault_error on all platforms

... so that the corruption mechanism can kick in.

1.0.25.51: use WITH-RECURSIVE-SYSTEM-SPINLOCK

... instead of WITH-RECURSIVE-SPINLOCK because it's possible to
deadlock due to lock ordering with sufficiently unlucky interrupts as
demonstrated by test (:timer :parallel-unschedule) with low
probability.

This affects hash tables and some pcl locks.

Also, use WITH-RECURSIVE-MUTEX for packages.

Not a spinlock becuase it can be held for a long time and not a system
lock (i.e. with WITHOUT-INTERRUPTS) because conflicts are signalled
while holding the lock which I think this warrants a FIXME.

1.0.25.50: detect binding and alien stack exhaustion

Alien stack exhaustion machinery only works on x86oids.

1.0.25.49: x86/x86-64 unithread: use the allocated alien stack

... in struct thread and not the original control stack that we switch
away from in call_into_lisp_first_time.

1.0.25.48: signals internals doc

1.0.25.47: OOAO restoring fp control word

Do it in all signal handlers, no matter what, on platforms that
require it.

1.0.25.46: restore errno in signal handlers

1.0.25.45: fix futex_wait deadlines when interrupted

When the syscall returned with EINTR futex_wait called again with the
same timeout. Now it lets Lisp recalculate the relative timeout from
the deadline.

1.0.25.44: INTERRUPT-THREAD and timer improvements

The main thing accomplished by this commit is that it's finally
possible to use INTERRUPT-THREAD and TIMERS sanely:

- there is a per thread interruption queue, interruption are executed
  in order of arrival

- the interruption has to explicitly enable interrupts with
  WITH-INTERRUPTS if needed. In the absence of WITH-INTERRUPTS the
  interruption itself is not interrupted and running out of stack is
  not a problem.

- timers have an improved repeat mechanism

Implementation notes:

- INTERRUPT-THREAD is implemented on all platforms and builds (that
  is, even without :SB-THREAD) by sending a signal to the current
  thread (or process without thread). This allows us to hook into the
  normal, interrupt deferral mechanism without having to commit OAOO
  violations on the Lisp side. And it makes threaded, non-threaded
  builds closer, hopefully easing testing.

- SIG_INTERRUPT_THREAD is SIGPIPE on all platforms. SIGPIPE is not
  used in SBCL for its original purpose, instead it's for signalling a
  thread that it should look at its interruption queue. The handler
  (RUN_INTERRUPTION) just returns if there is nothing to do so it's
  safe to receive spurious SIGPIPEs coming from the kernel.

- IN-INTERRUPTION does not unblock deferrables anymore, but arranges
  for them to be unblocked when interrupts are enabled (see
  *UNBLOCK-DEFERRABLES-ON-ENABLING-INTERRUPTS-P*).

- Thread interruption run wrapped in a (WITHOUT-INTERRUPTS
  (ALLOW-WITH-INTERRUPTS ...)).

- Repeating timers reschedule themselves when they finished to the
  current expiry time + repeat interval even if that's in the past.
  Hence, a timer's schedule does not get shifted if it takes a long
  time to run. If it takes more time than the repeat interval then it
  may catch up on later invokations.

- Timers run wrapped in a (WITHOUT-INTERRUPTS (ALLOW-WITH-INTERRUPTS
  ...)) even in run in a new thread.

- Enable previously failing tests.

- Add more tests.

- Automatically unschedule repeating timers if they take up all the
  CPU.

1.0.25.43: alpha interrupt context fixes

- interrupt contexts pointers are 64 bit

- add padding to DEFINE-PRIMITIVE-OBJECT THREAD, because the C
  compiler aligns interrupt_contexts on a double word boundary

1.0.25.42: make os_thread 0 on unithread builds

... because storing the pid there (two places really, thread.os_thread
and THREAD-OS-THREAD) complicates SB-POSIX:FORK, and makes a simple
fork() lose.

1.0.25.41: only call pthread_kill with valid thread ids

... else it segfaults (at least on Linux). Fixes sporadic "Unhandled
memory fault" running timer, INTERRUPT-THREAD heavy code. And block
signals while calling pthread_kill because it is not async signal
safe.

1.0.25.40: fix JOIN-THREAD

If the thread has not returned normally signal the error when not
holding the mutex anymore. Disable interrupt for the duration of
holding the mutex. Fix test.

1.0.25.39: thread start/stop fixes

- disable interrupts during create_thread

  ... to protect against signals (async unwinds, reentrancy, ...)
  during malloc, pthread code and to make the pinning of
  INITIAL-FUNCTION effective. Also add checks to
  new_thread_trampoline.

- make-thread: assert gc enabled (to prevent deadlocks)

- block blockables while holding LOCK_CREATE_THREAD lock

- make dying threads safe from interrupts

1.0.25.38: fix maybe_gc

1.0.25.37: block deferrables when gc pending in PA

Consider this:

  set_pseudo_atomic_atomic()
  alloc and set pseudo_atomic_interrupted and GC_PENDING
  clear_pseudo_atomic_atomic()
  if (get_pseudo_atomic_interrupted())
    gc();

If an async interrupt happens and unwinds between
clear_pseudo_atomic_atomic and gc() we have lost a gc trigger until
the next alloc. Same with SIG_STOP_FOR_GC instead of alloc.

This patch addresses the above problem by blocking deferrables when a
gc is requested in a pseudo atomic section. On exit from the protected
section there is no race because no async unwinding interrupts can
happen.

1.0.25.36: unblock signals on low level errors

Low level errors (control stack exhausted, memory fault) may trigger
at inconvenient times such as in signal handlers still running with
deferrables blocked. Due to the condition handling mechanism this
leads to executing user code at unsafe places and the image may very
well become corrupted. To allow continuing anyway with fingers crossed
to diagnose the problem, deferrable and/or gc signals are unblocked
before arranging for returning to the Lisp function that signals the
appropriate condition. Before that is done, however, a warning is
fprintf'ed to stderr to that this important piece of information is
not lost in some generic condition handler (or in a interrupt handler
async unwinding before anyone gets a chance to handle the condition)
which makes diagnosis of subsequent problems very hard.

This was brought to light by the checks added in the previous commit.

1.0.25.35: check that gc signals are unblocked

... when alloc() is called and when calling into Lisp.

1.0.25.34: gc trigger improvements

- Make sure that gc never runs user code (after gc hooks and
  finalizers) if interrupts are disabled and they cannot be enabled
  (i.e. *ALLOW-WITH-INTERRUPTS* is NIL).

- clean up maybe_gc: we know that in the interrupted context gc
  signals are unblocked (see "check that gc signals are unblocked"
  commit) so it's safe to simply enable them and call SUB-GC

1.0.25.33: protect against recursive gcs

... while holding the *already-in-gc* lock instead of allowing gc to
trigger and then punting.

1.0.25.32: improvements to WITHOUT-GCING

- implement it with only one UNWIND-PROTECT (about 30% faster)
- add *IN-WITHOUT-GCING*
- in maybe_defer_handler defer interrupts if we are in the racy part
  of WITHOUT-GCING, that is with interrupts enabled, gc allowed but
  still *IN-WITHOUT-GCING*
- check more invariants

1.0.25.31: axe GC-{ON,OFF}

... because they are broken, nobody uses them (?), and complicated to
fix.

Rationale:

- There is no way to safely allow gc in a WITHOUT-GCING without making
it entirely useless (nothing like the interrupt protocol with
ALLOW-WITH-INTERRUPTS).

- WITHOUT-GCING implies WITHOUT-INTERRUPTS because interrupts running
with gc disabled may lead to deadlocks (see internals manual on lock
ordering and WITHOUT-GCING) or running out of memory. To adhere to
this contract GC-{ON,OFF} would need to enable/disable interrupts by
setting *INTERRUPTS-ENABLED*, comlicated business for little gain.

1.0.25.30: INTERRUPT-THREAD without RT signals

All non-win32 platforms converted to use normal signals
(SIGINFO/SIGPWR) to implement INTERRUPT-THREAD.

Remove mention of RT signals from the internals manual.

1.0.25.29: thread state visibility and synchronization

C does not guarantee that changes made to a volatile variable in one
thread are visibile to other threads. Use locking primitives (that
have memory barrier semantics) for that purpose.

Thus, all_threads need not be volatile: it's always accessed while
holding all_threads_lock. Thread state does not need volatile either,
as signal a handlers don't change it (save for sig_stop_for_gc_handler
but that sets it restores its value). But visibility issues can arise
and potentially deadlock in stop_the_world, so the thread state is
given a lock. And to reduce busy looping while waiting for the state
to change to STATE_SUSPENDED a condition variable is added as well.

Also convert sig_stop_for_gc_handler to use
wait_for_thread_state_change which frees up SIG_RESUME_FROM_GC. I
think this also guarantees that the changes made by the gc are visible
in other threads on non x86 platforms (on x86 it's already the case).

With these changes threads.impure.lisp runs 10% a faster in real time.

1.0.25.28: always use SIG_RESUME_FROM_GC

The other mechanism relied on real time signals which made it freeze
when the sysystem wide real time signal queue got full on Linux. A
full queue spells trouble for other processes using rt signals.

All platforms are changed to use SIGUSR1 and SIGUSR2 for
SIG_STOP_FOR_GC and SIG_RESUME_FROM_GC.

Check that SIG_RESUME_FROM_GC is never signalled without a
corresponding sigwait.

1.0.25.27: codify interrupt handling invariants

1.0.25.26: less interrupt handling leftovers

- less clear_pseudo_atomic_interrupted

  Remove it from the beginning of the protected sections in the
  runtime to match what we do in Lisp.

- less resetting of signal mask

  Don't call reset-signal-mask from the toplevel, I don't think it's
  useful anymore and quite likely it was never more than duct tape.

  Even when unmasking of signals is called for (in
  INVOKE-INTERRUPTION), only unblock the deferrable ones: gc signals
  are unblocked in Lisp anyway.

- removed unneeded sigemptyset on pending mask

- move MIPS SIGTRAP workaround to the runtime

1.0.25.25: sig_stop_for_gc_handler looks at GC_INHIBIT first

... else we'd trap on every single pseudo atomic until gc is finally
allowed.

1.0.25.24: x86/x86-64 runtime pseudo atomic fixes

Make sure that {clear,set}_pseudo_atomic_{atomic,interrupted} boil
down to a single assembly intruction. And that the compiler does not
reorder them.

I think the ppc bits in pseudo-atomic.h are still broken on both
accounts.

1.0.25.23: more allocation checks

- in gencgc alloc() check that we are in pseudo atomic
- assert that interrupt_handle_pending does not happen in pseudo atomic
- assert that cheneygc pa_alloc() runs with deferrable signals blocked
- add test code to trigger gc from pa_alloc to help testing how the
  runtime deals with such rare events

1.0.25.22: SIGTERM and SIGABRT

- add SIGTERM to deferrables, because it has a Lisp handler and it
  cannot run in some contexts (on the alt stack, gc signals blocked,
  ...)

- move SIGABRT/SIGIOT handling to C to abort without possibly
  triggering Lisp errors due to the same problems as in the previous
  point

1.0.25.21: handling of potential corruptions

- add corruption_warning_and_maybe_lose that prints a warning and
  loses depending on lose_on_corruption_p (false by default)
- use corruption_warning_and_maybe_lose when the control stack is
  exhausted and on memory faults
- use corruption_warning_and_maybe_lose on the lisp handlers of
  SIGILL, SIGBUS and SIGEMT, as invoking them is surely not a good
  sign.
- add --lose-on-corruption as a runtime option
- add --disable-ldb as a runtime option
- update the man page and the user manual
- HEAP-EXHAUSTED fixes:
  - exit pseduo atomic properly and do pending interrupt if needed
  - signalling HEAP-EXHAUSTED in a WITHOUT-INTERRUPTS is dangerous
- use --lose-on-corruption in make-target*.sh

Also, block blockable signals on lose() to prevent other threads,
timers and such from interfering. If only all threads could be stopped
somehow.

1.0.25.20: test util: print names, status

1.0.25.19: small test fixes

- mop-6 test: use keywords in test name

  ... because symbols from the mop-6 package cannot read later from
  the file containing test results.

- fix gc deadlock test

  Instead of with-all-threads-lock, it was using with-mutex that
  enables interrupts.

1.0.25.18: it's only SHOW

- fix compilation with QSHOW

- SHOW prints thread id on threaded builds

- SHOWing os_threads

  - do not print pthread_self() that's the job of SHOW
  - always print thread ids with %lu
  - states with %x

- add more SHOW to ease debugging

- gc_stop_the_world: don't flood with FSHOW_SIGNAL when waiting for
  another thread to change states

- signal safe SHOW

  (if QSHOW_SAFE is defined)

1.0.25.17: kill runtime warnings

1.0.25.16: minor stylistics changes in the runtime

1.0.25.15: less compilation warnings

1.0.25.14: comments

1.0.25.13: 80 chars, trailing space

1.0.25.12: fix debugger on non-x86oids

  (regression from 1.0.25.9 that broke TOP-FRAME)

1.0.25.11: Remove unused SIZE slot from catch-block structure.

1.0.25.10: Commit version.lisp-expr, missed in last commit. (Oops.)

1.0.25.10: Fix package locks checks for local functions in the interpeter.

* Package lock checks were being performed in the function binding form's
  body's lexical environment, causing lossage for forms like

  (locally (declare (disable-package-locks foo:bar))
    (flet ((foo:bar ...))
      (declare (enable-package-locks foo:bar))
      ...))

  In particular, this broke some TRACE extensions.

1.0.25.9: INVOKE-WITH-SAVED-FP-AND-PC changes

On x86/x86-64 we stash away the fp and the pc when calling an alien
function in order to allow the debugger to get back at the lisp frames
even if the alien frames confuse the frame parsing heuristics.

This commit optimizes INVOKE-WITH-SAVED-FP-AND-PC to cancel much of
the slowdown caused by 1.0.21.32 and it makes its use conditional on
(<= speed debug).

1.0.25.8: fix sxhash bug

... brought to light by 1.0.20.27. Declare hashes to be of type HASH
(not INDEX).

Note that INDEX still is used to mean different things:

- a valid index: (integer 0 (array-dimension-limit))

- a "bound" such as the :START arguments: (integer 0 array-dimension-limit)

- a "dimension" as in (make-array 10): (integer 0 array-dimension-limit)

which leads to all kinds of nastiness with array near the limit.

1.0.25.7: Muffle style-warnings around lambda list parsing in the interpeter.

1.0.25.6: Reunite x86oid and non-x86oid sub-{access,set}-debug-var-slot

Merged the x86oid and non-x86oid versions of sub-access-debug-var-slot
and sub-set-debug-var-slot, reducing the size of debug-int.lisp but
arguably making the conditionalization worse.

1.0.25.5: genesis descriptor-intuit-gspace cleanups

Minor refactoring and major commentary updates to
descriptor-intuit-gspace.

1.0.25.4: genesis load-time-value cleanup

  * Added a :load-time-value pseudo-gspace for use by descriptors
    created by fop-funcall instead of the existing (undocumented)
    scheme of using a null gspace and a not-null offset within a gspace
    to indicate such descriptors.

  * Fixed up some comments.

1.0.25.3: earlier x86 code-object fixup envectorization

In order to be able to relocate code-objects, the x86 port has to keep
track of the locations of certain fixups within the objects (these
fixups being relative fixups pointing to addresses outside the
code-object and absolute fixups pointing to addresses within the
code-object).  Since time immemorial, the build process involved having
genesis dump a record of each fixup to be recorded as a cold-toplevel,
and cold-init passing such cold-toplevel information to
!envector-load-time-code-fixup.

  * Change genesis to create fixup-vectors directly, instead of dumping
    the fixup information as cold-toplevels.

  * Strip out the (now dead) code for envectoring cold-toplevels during
    cold-init.

1.0.25.2: Eliminate untagged pointers to heap space in cold-init

Load-time value fixups encountered by genesis are added as a kind of
toplevel form to be patched during cold-init.  The reference to the
location to fix up was being dumped as a SAP pointing to the correct
point in heap space.  Instead of dumping a SAP, we now dump the
containing object and an offset within the object, thus removing one
obstacle to running the GC or doing other heap-space relocation prior
to running the cold-toplevels.

1.0.25.1: x86-64 code fixup recording for gc / slash-and-burn

x86-64 code segments do not have absolute references to within
themselves, nor do they have relative references to without themselves,
making them relocatable without patching.  The GC has long since been
updated to reflect this, but the fixup recording code originally part
of the x86 port had been retained.

  * Removed x86-64 code-object fixup recording code everywhere.

  * Added some commentary to x86iod fixup handling in genesis.

1.0.25: release, will be tagged as sbcl_1_0_25

1.0.24.48: Do explicit sign-extension of small signed alien return values

        * gcc 4.3 has a different interpretation of the ABI, and
          zero-extends signed chars, shorts and (on x86-64) ints.

1.0.24.47: Fix 1.0.21.29 regression with enums in structs.

This is not the most elegant of fixes, but arrange to return the old
structure where applicable, and make incompatible mentions cause a
CERROR with clobber continue semantics, to parallel what I think is the
logic in the union/struct case.

1.0.24.46: SB-BSD-SOCKETS workingness from saved cores on Windows

 * Need to call WSA-STARTUP on init.

 * Reported by Stephen Westfold, fix by Rudi Schlatte.

1.0.24.45: handle IO errors in LDB and when saving the core

 * In LDB, if users response cannot be read, assume y.

 * Check fwrite() called when saving the core, and report the error.

 * Patch by Daniel Lowe.

1.0.24.44: bug in INVALID-ARRAY-INDEX-ERROR, leaving EXPECTED-TYPE slot unbound

 * It's :EXPECTED-TYPE, not :TYPE. ...having compiler check calls to ERROR like
   this would be nice.

 * Marginally better test to catch this.

1.0.24.43: DEFTYPE to accept bodies consisting a single symbol

 * Regression from 1.0.22.8, reported by Ariel Badichi.

1.0.24.42: fix bug 235a

 AKA https://bugs.launchpad.net/sbcl/+bug/309141

 * Replace DEFINED-FUN-FUNCTIONAL with DEFINED-FUN-FUNCTIONALS, and reuse
   the functional only if policy matches.

1.0.24.41: add necessary disambiguating curly braces to runtime

 * When QSHOW is undefined FSHOW(...) expands into nothing, leading to unexpected
   results for code like

     if (gencgc_verbose)
       FSHOW(...)

   as the conditional will then apply to the next syntactic element.

 * Patch by Daniel Lowe.

1.0.24.40: fix regression from 1.0.24.37

 * TNs with KIND :CONSTANT don't have leaves if they represent load
   time values.

 * Reported by Attila Lendvai.

1.0.24.39: mutex changes

- do what a FIXME suggests and rename MUTEX-VALUE to MUTEX-OWNER
- in the process, make sure that the value returned is less stale
- keep MUTEX-VALUE around for compatibility for a while
- also add HOLDING-MUTEX-P
- to make MUTEX-OWNER and HOLDING-MUTEX-P useful make unithread builds
  keep track of the owner of mutex

1.0.24.38: improve test scripts

- robustify threads.test.sh even more
- fix the same bug related to $! in finalize.test.sh
- make condition-wait-sigcont.lisp work unithread builds

1.0.24.37: full raw-instance-slot support on HPPA

 * Patch by Larry Valkama.

1.0.24.36: don't print the array object when reporting index out of bounds

 * Report the type of the array instead, and encapsulate the array object in the
   condition object so that it can still be inspected manually.

 * Suggested by Stas Boukarev.

1.0.24.35: Flag-setting VOPs on x86[-64] and conditional moves

 * Most :CONDITIONAL VOPs only specify which condition flags they set

 * GENERIC-{EQL,=,<,>} are :CONDITIONAL VOPs, but don't show up as
   calls anymore

 * Values may be selected with CMOVcc if applicable (and :CMOV is
   in *backend-subfeatures*, for x86):
    - Values that are represented, unboxed, in GPRs are CMOVed using
      custom VOPs
    - Unboxed float and complex types aren't converted
    - Other types are assumed to be boxed and CMOVed as descriptors

 * A test to try and to cover an interesting cross-section of flags
   and values to move conditionally.

1.0.24.34: IR2: additional representation for predicates, conditional moves

 * :CONDITIONAL VOPs can now specify how to interpret the test
   they compute without performing the branch directly. How the
   test is specified is completely platform-dependent and only
   affects new-style :CONDITIONAL VOPs and a new BRANCH-IF VOP
   (src/compiler/$ARCH/pred.lisp).

 * Candidates for conversion to conditional moves are found
   and may be converted, depending on CONVERT-CONDITIONAL-MOVE-P,
   a new VM support routine. C-C-M-P returns NIL to punt on the
   conversion, or 5 values:
    1. name of the VOP to use
    2. TN for the first argument (NIL if none)
    3. TN for the second argument (NIL if none)
    4. TN for the result
    5. A list of info data, which will be appended to the flags

   The correct values will be MOVEd in the argument TNs if needed
   before computing the condition, and the result MOVEd to the right
   TN after the conditional move VOP.

1.0.24.33: fix bug 316075

 https://bugs.launchpad.net/sbcl/+bug/316075

 * In DEFINE-ALIEN-ROUTINE, if the return-type is VOID, don't return
   the result of ALIEN-FUNCALL but a literal NIL instead.

1.0.24.32: undo parts of 1.0.24.26

No need for memory barriers when unlocking a spinlock on x86/x86-64.
The ordering rules and the cache coherency mechanism together
guarantee this. However, the compiler must be prevented from
reordering instructions with the unlock (at least in one direction).
This is now done in the runtime, but not in Lisp as the Lisp compiler
does no reordering.

1.0.24.31: robustify threads.test.sh some more

 * Missed --no-userinit --no-sysinit --disable-debugger, causing it to
   fail for some setups.

1.0.24.30: fixed and tested some more cleanups on hppa-hpux

 * Fix a stray #+ -> #!+.

 * Removed unneeded nops.

 * Explanation of magic numbers (but not yet substituted.)

   (Above changes in patch by Larry Valkama)

 * Fix a bunch of comments in the HPPA backend to use the right number
   of semicolons, and use FIXME-lav instead of FIX-lav to mark things
   (better grepping for the rest of us.)

1.0.24.29: fix a typo in documentation

1.0.24.28: make unbind in the runtime zero the value of the binding

... to parallel what the Lisp side does. As far as I see the rationale
for doing that (in doc/internals/specials.texinfo) does not apply here
since signals are blocked when the dynbind functions are called. That
said, instead of adding documentation let's fix it.

1.0.24.27: target-thread cosmetics

- in the docstring of CONDITION-NOTIFY document that the mutex must be held
- remove and explain fixme in CONDITION-WAIT
- respect 80 char limit
- use ; ;; ;;; and ;;;; where appropriate
- fill the comment paragraphs
- add form feeds (^L) to separate pages

1.0.24.26: fix release spinlock

Both in the runtime and in Lisp releasing a spinlock was a simple
assignment. That doesn't work because the new value may not make it to
main memory by the time another CPU wants to acquire it making it
needlessly slow. Worse, it also allows the CPU to reorder instructions
from the critical section after the release.

There is a spinlock implementation for MIPS in the runtime, but it's
not used as we don't have threads on that platform. I don't know if
it's broken too.

1.0.24.25: add volatile after asm in spinlock and swap_lispobjs

... to prevent the compiler from optimizing away certain calls or
maybe reorder them. Test for swap_lispobj.

1.0.24.24: fix threads.test.sh

... so that it doesn't leave stray sbcl child processes around and it
actually tests what it wants to test.

1.0.24.23: fix alien struct struct member offset bug

No-one uses struct struct members, right?  Well, academics are
notoriously bad at keeping up to dat with good practice...

1.0.24.22: mudball of VOP updates for HPPA

 * Based on a mix of the old hppa-code and the mips backend.

 * Patch by Larry Valkama.

1.0.24.21: call stub needed to switch between hpux heap-spaces

 * Patch by Larry Valkama.

1.0.24.20: misc HPPA & HPUX updates

 * "To make it compile and run".

 * Config.hppa-hpux missed from 1.0.24.18.

 * Patch by Larry Valkama.

1.0.24.19: COMPILE-TIME reports timings at millisecond accuracy

 * Patch by Luis Oliveira.

1.0.24.18: new HPUX specific files

 * Also more separation of linux stuff versus common stuff (hpux vs linux).

 * Patch by Larry Valkama.

1.0.24.17: grab-bag of fixes to make hpux-os smile

 * Patch by Larry Valkama.

1.0.24.16: updates on how we deal with fixup on HPPA

 * Patch by Larry Valkama.

1.0.24.15: contrib fixes for HPPA

 * Fix or disable what breaks in contribs, so not everything breaks.

 * Patch by Larry Valkama.

1.0.24.14: fix what seems to be namespace collision by HPUX headers

 * Patch by Larry Valkama.

1.0.24.13: solve overlapping mmap and munmap slices on HPUX

 * Patch by Larry Valkama.

1.0.24.12: adding and fixing the HPUX/HPPA build target

 * Patch by Larry Valkama.

1.0.24.11: stack allocation support for HPPA

 * Thiemo Seufer's MIPS stack allocation work and other things by him
   ported over to HPPA.

 * Patch by Larry Valkama.