1.0.28: release, will be tagged as sbcl_1_0_28

1.0.27.49: update platform table, credit me

1.0.27.48: Win32/Cygwin contrib build fix.

  Recentish cygwin likes to have gcc as a symlink.  SBCL can't handle
that, so, for cygwin only, fully dereference gcc if it's a symlink when
building contribs.

1.0.27.47: fix RUN-PROGRAM on windows

Hopefully. There are mixed reports from users.

1.0.27.46: Fix build on systems with "src" in the path.

  1.0.27.31 introduced an actual check that the path for all source
files is correctly externalized as an LPN at cold-init time.  Due to a
longstanding bug in MAKE-FILE-INFO-NAMESTRING, not fixed with
1.0.27.31, it is possible for the system to create a pathname such as
"SYS:SRC;LISP;SBCL;SBCL-GIT;OUTPUT;STUFF-GROVELED-FROM-HEADERS.LISP".
Once the SYS: logical pathname translations are set up, this path is
not valid, causing a build failure.  Fixed, at the cost of disallowing
paths in SYS:SRC that have a final directory of OUTPUT, not likely to
be an issue in practice.

1.0.27.45: Fix the error signaled in bogus recursive READs.

* CHECK-FOR-RECURSIVE-READ signaled a READER-ERROR without supplying a
  stream initarg.

1.0.27.44: genesis fixes

make genesis of identical fasls produce identical cold cores.

4 messages follow:

documentation handling

CLISP supports documentation for packages now, so remove the read-time
conditional.  However, don't try to use the documentation for the CL or
KEYWORD packages (as they come from the host directly)

LAYOUT clos hash values

Set them in cold-init using the target's RANDOM rather than in genesis
using the host's.

hash table traversal in genesis

MAPHASH will not give repeatable results in general, and certainly won't
between distinct implementations of hash tables.  Sort the contents of
hash tables according to a predicate which completely orders the
contents.  (This is mildly tricky for FDEFN names: we have to assume
that we are only dealing with names of the forms SYMBOL and (SETF
SYMBOL)).

give smallvecs an initial element

Whoops.  The smallvecs (representing the memory image of the core being
constructed) were being constructed without an initial-element.  For the
most part this wouldn't matter, because it will (almost) all be
overwritten by the genesis process itself.  The crux is in that
(almost), though; in some cases it matters, such as producing bogus
values for symbol tls slots.  Mostly implementations seem to zero-fill
newly-constructed (unsigned-byte 8) arrays, but there seem to be some
circumstances under which CLISP will produce one with random data in
it...

1.0.27.43: constant coalescing agreement fixes

Constant coalescing decisions, legitimately differing between different
hosts, can if not very careful propagate into the target, often through
vop-parse structures.  Be explicit in which constants can be shared and
which shouldn't.

5 messages follow:

constant coalescing KLUDGE, part 1 [(any)]

The constant initforms for the vop-parse structure are evaluated on the
host; therefore, their coalescing is at the host's discretion.  This
wouldn't matter except that (why?) vop-parse structures get dumped
at each vop definition.  Make the coalescedness explicit.

constant coalescing KLUDGE, part 2: [(fixnumize n)]

The static function template for at least LENGTH (in subprim.lisp)
contains two instances of (FIXNUMIZE 2), which are coaelesced
differently on different host lisps.  We can KLUDGE around this problem
(and gain a millimetric amount of efficiency, too!) by evaluating the
FIXNUMIZE calls at expansion time.

remove confusing code structure sharing from DEF-MOVE-IF

I can't actually see exactly where the code structure sharing happens
nor why it causes xc fasl contents to differ between hosts, but since
it makes the code clearer to rewrite the macro...

fix two separate issues in compiler/globaldb

One is a hash-table traversal issue; the other is coalescing of
constants.  I *think* what's going on in the latter case is that there
are two separate ways that shared constants can happen.  One is in the
dumping of objects which are EQUAL, where the compiler can dump a
reference to a previous object instead; the other is the dumping of a
single object with circularities, where a nil is dumped along with a
later instruction to backpatch the circularity in.  We need to ensure a
deterministic cold-init-form, so that means we need to control the
coalescing in the _host_ compiler (because the cold-init-form is
generated from introspection), but of course we can't, so we COPY-TREE
instead, which will allow the xc to coalesce and will prevent the form
as compiled from sharing structure.

Static function template vop macro has a common subexpression, factored
out as new-ebp-ea.

1.0.27.42: explicit determinism in the compiler

2 messages follow:

stable-sort the time specifications

Dunno if this is actually necessary for anything.

make unpacking and repacking happen in a determined order

The unpacked blocks were stuffed into a hash table and then maphashed
over; as in other cases, this is host-dependent.  Use a list and pushnew
instead.

1.0.27.41: floating point implementation smoothing

To get floating point stuff exactly right, we should build a complete
IEEE float implementation to do calculations in for the cross-compiler.
Since that's not going to happen this millennium, instead try to be
careful when writing code that looks constant-foldable.  Some other
fixups on the way...

6 messages follow:

fix load-time tests in src/code/pred

It turns out that #c(1.1 0) is not portable: it's a REAL in clisp and a
COMPLEX in sbcl.

begin work on floats

Floats Are Hard.  The issue is that the host's float implementation,
even if it agrees with SBCL that SINGLE-FLOAT is IEEE single and
DOUBLE-FLOAT is IEEE double, may not match sbcl idiosyncracy for
idiosyncracy.  For example, clisp doesn't support denormals, so its
LEAST-FOOATIVE-QUUXLE-FLOAT constants are very different from sbcl's:
and sbcl's can't even be represented within the host.  Ugh.

Defining the print-related MIN-E constants is, however, easy enough.

comment (well, #!+long-float) out some floating point constants

The clauses in question were never taken absent #!+long-float anyway.

-0.0 is not portable: many lisps don't respect negative zeros

Use make-unportable-float instead, and hope that this doesn't matter
during cross-compilation...

host floating point differences

Not all lisps think (log 2d0 10d0) is the same.  Compute it accurately
and use LOAD-TIME-VALUE.

tentative attempt at smoothing over host floating point differences

Compute all the necessary constants as double-float bit patterns using
LOAD-TIME-VALUE.

1.0.27.40: host-invariant string constant coalescing

It took a little time to get right, but here's (I hope) invariant
constant string coalescing in the cross-file-compiler.

3 commit messages follow:

more invariant constant string coalescing

When dumping strings in cross-compilation, we always end up dumping as
base-string.  That means we need to compare all strings of whatever
underlying array type for content equality, not just strings of the same
type.  This shows up when dumping in the same file "BLOCK" and the value
of (symbol-name 'block) under CLISP, which dumps two separate values.

dumping string constants, the other half

Not only do we have to enter entries into the hash table with a known
element-type, we also have to retrieve them... bogosity finally picked
up by use of a CL symbol name (AND) in src/compiler/x86/insts.lisp...

further refinement on constant coalescing

Not only must we coalesce all kinds of strings at fasl dump time, we
must coalesce the constants in our TN representation while we're
compiling, otherwise we will get different lengths of constant vectors
for the same function depending on how many different string
representations there are in the host compiler.

1.0.27.39: SIGCHLD related fixes

- WITH-ACTIVE-PROCESSES-LOCK does not allow WITH-INTERRUPTS because
  that can lead to recursive lock attempts upon receiving a SIGCHLD.

- if fork() in RUN-PROGRAM fails, signal the error outside the lock.

- the SIGCHLD handler only reaps processes started by RUN-PROGRAM in
  order not to interfere with SB-POSIX:WAIT, SB-POSIX:WAITPID and
  their C equivalents (thanks to James Y Knight).

- the SIGCHLD handler is installed once at startup, because on Darwin
  sigaction() seems to do unexpected things to the current sigmask.

1.0.27.38: make FAILED-AVER use a list form of code

Previously, we constructed a printed version of the code and used that,
but it seems remarkably hard to get identical printed contents from identical
list structure in three different implementations: indentation,
line breaks, QUOTE and FUNCTION, and so on all seem to vary.

2 previous commit messages follow:

bind printer control variables in FAILED-AVER

FAILED-AVER prints source code with ~A.  If printer control variables
are different in different implementations, then the error message will
be different.

Actually at the moment the binding (of *PRINT-PRETTY* to T) is probably
a no-op.  We tried binding *PRINT-PRETTY* to NIL to get the same output
as XCL, but apparently, other implementations (CLISP, reportedly ECL)
don't obey CLHS 22.1.3.5 for printing conses when the pretty printer is
off.

another attempt to tame AVER

binding printer control variables is all well and good, but linebreaks
cause problems.  We could probably deal with that with a suitable value
for *pprint-right-margin*, but... instead, just save the form, not its
printed representation.

1.0.27.37: fix host constant leaks

Various ways in which a host constant can leak through the
cross-compiler into the target are plugged.

5 commit messages follow:

fix host most-positive-fixnum leak in declaration

Found by comparing object code for SORT-VECTOR between clisp and sbcl xc
hosts.

Fix most-fooative-fixnum leak in number-psxhash

Gah, floats.  Most cases will be more complicated to fix than this one.
(Fixing things absolutely properly would be hugely difficult; this fix
should do for now...)

more careful cross-compiler constant-form-value

We need to take values from the xc info database in preference to using
SYMBOL-VALUE, otherwise we'll leak from the host.  (In particular, this
one was for function in debug.lisp with lambda lists of the
form (&optional (n most-positive-fixnum))

deal with another host fixnum-related constant leak

This time it's in the definition of the integer constants which are both
fixnums and exactly representable as floats.  Amazingly, just above
these definitions are the ones for SB!XC:MOST-POSITIVE-FIXNUM and
friends; no alarm bells were ringing...

fix a fixnum leak in unix-fd type

This mistake [ (deftype foo () `(integer 0 ,most-positive-fixnum)) ]
seems distressingly easy to make.  Not easy to guard against, either.
(Aside: is it sensible to define FDs as positive fixnums?)

1.0.27.36: host CL symbols with other home packages

Genesis already knew about the case of a symbol exported from the CL
package with a different home package.  For repeatable FASLs, the dumper
and the xref internals detector also need to know.

2 commit messages follow:

special case dumping of CL symbols with other home packages

Just like in genesis, we need to deal with CL symbols which are
permitted to have a home package that's not CL.  SBCL doesn't do that,
but other implementations legitimately can and do; nevertheless, dump
as though it were a CL symbol.

xref cross-compilation consistency fixes

Treat as internal symbols (a) symbols with home package being "SB-XC",
and (b) symbols which are external in the CL package but whose home
package is elsewhere.

1.0.27.35: minimize the potential for presenting hosts with choices

By having minimal debug names for toplevel forms and component names, we
avoid having arbitrary gensyms or, horror of horror, QUOTE: which is
printed differently in different implementations...

2 commit messages follow:

minimal debug names for cross-compiled top-level forms

Otherwise we run the risk of getting arbitrary gensyms dumped as part of
the debug name.

bandage for ' vs QUOTE in two files

Make FIND-COMPONENT-NAME in the XC (which names components, whose names
are dumped in xc fasls) use only the first symbol in the context.  That
will be generally lame but avoids any current instances of QUOTE, which
prints differently in different implementations when pretty-printing is
off.

1.0.27.34: various trivial fixups for portability / repeatability

The only one that is potentially controversial is the use of
READ-PRESERVING-WHITESPACE...

3 commit messages follow:

don't print array SB!KERNEL:TYPE in internal error strings

Use the specifier instead.  (This is a long-standing bug; FIXME: try to
find a test case).

Use read-preserving-whitespace rather than just read in the compiler

With just CL:READ, at least CLISP and SBCL differ on the source
locations dumped in the fasls; with READ-PRESERVING-WHITESPACE, things
are consistent.

disassembler / printer names.

The compiler wants to generate names based on all sorts of information,
including byte specs, and attempts to make those names by printing all
that information into one big string.  Unfortunately, that allows the
host to insert line breaks, which it will do with maximal perversity.
Bind *PRINT-RIGHT-MARGIN* around the printing call in an attempt to
minimize this problem.

1.0.27.33: make various form orders deterministic

Usually involves sorting the output of a hash-table loop or set
operation.

3 commit messages follow:

make the order of (setf cl:foo) defining forms deterministic

alphabetize the automated out-of-line definitions of modular functions

Otherwise we go in hash-table order, which is not noticeably the same
between clisp and sbcl hosts.

UNION can return entries in arbitrary order

So SORT [a copy of: don't mutate the source code!] the UNION of
signed-num and unsigned-num by symbol name.

1.0.27.32: implement and use SB!XC:GENSYM

We need a gensym variant that doesn't share state with *GENSYM-COUNTER*,
so that host macroexpansions don't affect us.  (We also need to bind our
counter variant in the INFO compiler macro, because compiler macros
might or might not be expanded...)

11 individual commit messages follow:

Implement SB!XC:GENSYM

Host implementations can, even during cross-compilation, expand macros
(including arbitrary host macros such as CL:DEFUN) in :compile-toplevel
function definitions different numbers of times.  This is a problem
because some gensyms end up in function arglists (e.g. from
MULTIPLE-VALUE-BIND as well as from explicit FLETs or LAMBDAs in macro
expansions).  Our own SB!XC:GENSYM allows us to control the gensym
counter we use and hence the symbol names that are dumped.

Use SB!XC:GENSYM in BLOCK-GENSYM

remove a needless gensym

Nothing wrong with a regular symbol here.

Bind SB!XC:*GENSYM-COUNTER* in DEFINE-COMPILER-MACRO INFO

The compiler-macro for INFO now uses SB!XC:GENSYM, which is OK except
that the compiler macro gets used during cross-compilation; some
implementations expand compiler macros, while others (e.g. clisp)
interpret the relevant code and so don't.  Binding the counter
variable renders the effect of the compiler macro on the counter
invariant.

various reworks of macros to use SB!XC:GENSYM

In some cases radically decrease vertical space use by judicious use of
MAKE-GENSYM-LIST or WITH-UNIQUE-NAMES, both of which go through
BLOCK-GENSYM.

more reworks of macros to use SB!XC:GENSYM

Nothing vastly interesting here.

yet more reworks of macros to use SB!XC:GENSYM

Nothing much of interest.

even more reworks of macros to use SB!XC:GENSYM

more reworks of macros for SB!XC:GENSYM goodness.

one more SB!XC:GENSYM fix

Use WITH-UNIQUE-NAMES in FD-FOO macros.

One more gensym

1.0.27.31: repeatable fasl header and debug-source

The fasl header is easy to deal with; writing "at cross-compile time"
instead of something depending on the host is easy.  The debug-source is
harder; we set the structure slots to 0 in the cross-compiler, and
arrange for cold-init to patch sensible values in (by inventing a new
FOP to note the debug-source's arrival).

made up of 5 commits, whose individual messages follow:

deal with trivial volatile contents of fasl files

Don't try to preserve, even in the header, information about which
implementation or machine was used for the compilation.

Similarly, don't emit the timestamps in the debug-source into the fasls.

comments: delete a FIXME and explain a bare `2'

consistent source pathname for output/stuff-groveled-from-headers.lisp

At the moment it's the only compiled file not in src/; code defensively
around that fact.

fix a longstanding KLUDGE

Find the index of the source slot by introspection rather than using a
baffling literal `2'.  Unfortunately, in doing so we run into bug #117.

patch in the source created/compiled information in cold-init

We can't do it before without making our fasls or cold-sbcl.core
dependent on filesystem timestamps or current time.  The way we do it is
perhaps overcomplicated, compared with simply assuming that the file
timestamps are right, but has the advantage that it's demonstrably
correct: we implement a new FOP specifically for noting our
DEBUG-SOURCE, dumped only during cross-compilation, and in genesis we
interpret that FOP to build a list of debug-sources, which we can frob
in cold-init.

Everything should now be restored to its previous functionality.

1.0.27.30: minor octets.lisp cleanup

* fix typo to inline result of DEFINE-LATIN->STRING;

* manually inline and remove VARIMAP, since it only had only caller.
  Should result in faster code, although the disassembly on x86 looks
  fairly ugly...

1.0.27.29: funcallable instance source locations

 * Thanks to Paul Khuong.

1.0.27.28: better source paths for malformed declaration errors

 * For Slime and their ilk, thanks to Tobias Rittweiler.

 * Sort NEWS with "more important" items on top.

1.0.27.27: micro-optimize COERCE *->vector and vector->list

* sprinkle type declarations around to avoid checking for general SEQUENCEs;

* use >= in loop exit tests to avoid checks for overflow.

1.0.27.26: fix invalid array index reporting for compiled code

 * Index and bound were swapped around.

 * Also fix the name in the type declamation for INVALID-ARRAY-INDEX-ERROR.

   Thanks to Stas Boukarev.

1.0.27.25: clean up stray close paren

 * Reported by Robin 'Hawkeye' Powell.

1.0.27.24: robustify DEFPACKAGE form pretty-printing

 * Thanks to Sidney Markowitz.

 * A few missing NEWS entries.

1.0.27.23: fix bashism in sbcl-pwd.sh

 * OSTYPE might not be set in a non-bash shell.

1.0.27.22: better signaling from MAKE-STATIC-VECTOR

 * Patch by Daniel Lowe.

1.0.27.21: more careful (SETF DOCUMENTATION) for functions

 * Use VALID-FUNCTION-NAME-P to check if we should store the docstring:
   previously we stored docstrings for anonymous functions under names
   like (LAMBDA (X)) -- Not Good.

1.0.27.20: lutex-wait don't yet support deadlines

 * One test depends that, skip it for now on lutex builds to avoid a
   hang.

1.0.27.19: Restore variable access in debugger REPL.

* Contributed by Alex Plotnick <plotnick@cs.brandeis.edu>

1.0.27.18: Changes to ECHO-STREAMs

* Bugfix: PEEK-CHAR always popped the unread-stuff, leading to
  spurious duplicate echos in some cases.

* Minor incompatible change: UNREAD-CHAR on an ECHO-STREAM now unreads
  onto the echo-stream's input stream.  This is unspecified in the
  CLHS, but makes SBCL compatible with most implementations (AFAICT,
  everybody but CMUCL).

* Minor incompatible change: echo-streams used to buffer arbitrarily
  many characters in UNREAD-CHAR.  Conforming programs can't have
  relied on this, but non-conforming ones might have; users who need
  the old CMUCL/SBCL behavior can do it easily and de-facto-portably
  with Gray Streams.

* Possible bugfix that nobody cares about: ECHO-N-BIN (which
  implements a path through READ-SEQUENCE) can never have worked after
  an UNREAD-CHAR, because it tried to store characters into an octet
  buffer.

1.0.27.17: faster local calls on x86/x86-64

Instead of JMPing to TARGET, CALL a trampoline that saves the return
pc and jumps. Although this is an incredibly stupid trick, the paired
CALL/RET instructions are a big win.

1.0.27.16: slightly smaller LISTIFY-REST-ARGS on x86/x86-64

1.0.27.15: optimize multiple values recievers on x86/x86-64

... by not emitting unreachable instructions.

1.0.27.14: bias x86oid frame pointer

Forward port of Alastair Bridgewater's patch.

Duplicate it on x86-64.

Make it so that fp points to ocfp just as if the call had been made by
CALL to a function with the standard prologue "PUSH EBP; MOV ESP,
EBP".

Fix the debugger.

1.0.27.13: more RET on x86oids

With 0, 2 or 3 values return with idiomatic "POP EBP; RET".

1.0.27.12: x86/x86-64 calling convention comments, refactoring

1.0.27.11: swap ocfp and return-pc slots in x86oid call frames

Forward port of Alastair Bridgewater's patch. Also, port it to x86-64.
Bring x86 and x86-64 sources closer in the process.

Plus cleanups, indentation, remove dead code, comments, more checks.

1.0.27.10: fix call_into_lisp return value on x86-64

1.0.27.9: fix print-object cache handling
1.0.25.50 exposed a bug in the print-object discriminating
function: we need to have the methods for critical printing at
all times, but the implementation allowed other methods into
that initial cache, which was wrong if those methods
were subsequently invalidated.  The fix is to keep the initial
cache pristine and to use only copies in the print-object
generic function itself.

1.0.27.8: slightly faster x86oid pseudo atomic with {e,r}bp

Trusting that within SBCL ebp is even and that it doesn't change
within a pseudo atomic section it's possible to use it to set and
clear pseudo atomic bits. It is ever so slightly faster (about 0.5%
overall on cl-bench on a P4).

1.0.27.7: Win32 build fix

  On Win32, the default cross-compilation host is SBCL with a --sysinit
NUL --userinit NUL.  Unfortunately, SBCL itself doesn't recognize NUL
as a valid filename as it's actually a DOS device name and there's a
separate API to check for them.  The least losing workaround is to use
a real file with known-harmless content for userinit and sysinit, and
the simplest choice is version.lisp-expr.  This changes makes it
possible to build on Win32 without specifying a host lisp.

1.0.27.6: Make alien-type-class definition work from outside sb-alien.

  Added a slot to the alien-type-class structure to hold the name of
the structure for the class.

  Added the class structure name as a parameter to
create-alien-type-class-if-necessary in order to populate the slot in
the new alien-type-class structure.

  Changed define-alien-type-class to look up included alien type
defstruct names in the alien-type-class for the included type rather
than construct it via SYMBOLICATE (thus breaking the requirement that
all uses of define-alien-type-class be in the sb-alien package).

1.0.27.5: fix compilation on windows

Thanks to Bart Botta.

1.0.27.4: x86/x86-64 REP prefix has the same code as REPE (not REPNE)

... although it seems to work either way.

1.0.27.3: fix UNWIND-TO-FRAME-AND-CALL

1.0.27.2: fix bug in heap implementation

... used by timers.

Thanks to Ole Arndt for the patch.

1.0.27.1: Fix binary input after UNREAD-CHAR on bivalent streams.

* After an UNREAD-CHAR, READ-BYTE returned a character, and
  READ-SEQUENCE with an octet buffer failed when trying to store a
  character into the buffer.

release, will be tagged as sbcl_1_0_27

1.0.26.22: Revert 1.0.26.12

        * And add testcase showing why the revert was needed.

1.0.26.21: fix ERROR leaking memory

Make *COMPILED-DEBUG-FUNS* a weak keyed hash table. Add test.

1.0.26.20: tighter VECTOR-PUSH-EXTEND argument type
The optional extension parameter must be a positive integer.
... declare this in fndb;
... fix the erroneous use in constraints (not only ensuring
positivity, but also it's an extension not a new-length
parameter).
Issue brought to light by Peter Graves' XCL.

1.0.26.19: more stack safety

Add another guard page to the control, binding and alien stacks that
will lose() whenever it's touched so that if the handler manages to
recover from stack exhaustion then we can be sure that image is not
corrupted.

1.0.26.18: Solaris x86-64 support

        * Patch by Alex Viskovatoff

1.0.26.17: fix GC/SIG_STOP_FOR_GC race

Consider this: in a PA section GC is requested: GC_PENDING,
pseudo_atomic_interrupted and gc_blocked_deferrables are set,
deferrables are blocked then pseudo_atomic_atomic is cleared, but a
SIG_STOP_FOR_GC arrives before trapping to interrupt_handle_pending.
In sig_stop_for_gc_handler, GC_PENDING is cleared but
pseudo_atomic_interrupted is not and we go on running with
pseudo_atomic_interrupted but without a pending interrupt or GC.
GC_BLOCKED_DEFERRABLES is also left at 1.

Add more checks, fix comments.

1.0.26.16: fix gencgc on ppc

Regression from 1.0.25.37.

Store the context of allocation trap in interrupt_data and frob that
when gencgc wants to block deferrables.

Also: remove unused, buggy get_interrupt_context_for_thread.

1.0.26.15: interrupt.c refactoring

- check that all or none of the deferrable signals are blocked

- make passing NULL for sigset in the right context mean the current
  sigmask: there is only a single block_signals() function that can
  performs sigset arithmetic or change the current mask.

- print pc and sp on memory faults to ease debugging

1.0.26.14: minor portability fixes
Motivated by restarting work on a repeatable-xc-fasl project,
somewhat delayed by Real Life matters...
... use an explicit TYPE declaration for defined types;
... don't redefine host functions when building fasls from the
xc;
... catch one egregiously bad case of a dead clause in TYPECASE
(more lurk);
... don't use host symbols in genesis;
... define a total order for emitting constants.h.
Now clisp on my machine, with the current phase of the moon,
gets as far as dumping the cold core.  More Work Needed.

1.0.26.13: OpenBSD x86-64 support

        * Patch by Josh Elsasser

1.0.26.12: Don't allow (LOOP FOR X ACROSS A ...) where A evaluates to NIL

        * Patch by Daniel Lowe

1.0.26.11: Fix the error message for ENOMEM on mprotect

        * Error message was not updated when the variable was renamed
        * s/size/bytes/, s/parms/backend-parms/

1.0.26.10: darwin interrupt fixes

Work around raise(signal) apparently not raising the signal under some
circumstances. See sbcl-devel thread "Hang in tests on Intel MacOS
10.5.6" starting on 2009-03-14.

Also, block all blockables when in install_handler, having just one of
the signals blocked breaks invariants (not really darwin specific).

Replace abort() after the call mach_msg_server() with more a
informative lose(). It's actually returns after attaching and
detaching gdb.

1.0.26.9: reduce consing in MAP-ALLOCATED-OBJECTS

... on platforms where dynamic space extends past fixnum range

Thanks to Bart Botta for the patch.

1.0.26.8: QSHOW changes, bug reporting guidelines

- change runtime.h so that a simple '#define QSHOW_SIGNAL 1' turns
QSHOW automatically and defaults to blocking signals during printing

- add notes to BUGS on how to report bugs related to signal handling

- kill a warning in thread.c in code conditional on QSHOW_SIGNAL

- add #include <stdio.h> to x86{-64,}-darwin-os.c so that it compiles
  with QSHOW

- add comment explaining the previous commit

1.0.26.7: use a signal for SIG_STOP_FOR_GC > SIGSEGV on Linux

On Linux a signal generated by pthread_kill() with a signum that's
lower than SIGSEGV can be delivered before a synchronously triggered
SIGSEGV. This means that the sigsegv handler will be invoked with its
context pointing to the handler for the signal that pthread_kill()
sent. It's not really specific to SIGSEGV, it's the same for any
synchronously generated signal.

To work around this, we must never pthread_kill() with a signal with a
lower signum than any of the synchronously triggered signals that we
use: SIGTRAP, SIGSEGV, etc. In practice, currently we only send
SIGPIPE to indicate that the thread interruption queue may need to be
looked at and SIG_STOP_FOR_GC that's defined as SIGUSR1 currently.

With SIGUSR1 being 10 and SIGSEGV 11 this can make
handle_guard_page_triggered lose badly if GC wants to stop the thread
at the same time. So let's use SIGUSR2 instead that's 12. Do the same
on other OSes they may have same bug.

See thread "Signal delivery order" from 2009-03-14 on
kernel-devel@vger.kernel.org:

http://groups.google.com/group/fa.linux.kernel/browse_thread/thread/6773ac3dcb867da3#

1.0.26.6: use private operations on futexes

It allows the linux kernel to avoid contention with mmap.

1.0.26.5: improve CONDITION-WAIT, RELEASE-MUTEX

- minimize the window where a CONDITION-WAIT and a CONDITION-NOTIFY
  race to FUTEX-WAIT and FUTEX-WAKE respectively

- make reacquiration of the mutex in CONDITION-WAIT interruptible

- make RELEASE-MUTEX return silently without doing anything if the
  owner is not the current thread. This eliminates spurious warnings
  upon async unwinding from the mutex reacquiration path of
  CONDITION-WAIT.

- add IF-NOT-OWNER parameter to RELEASE-MUTEX with three possible
  values: :PUNT, :WARN, :FORCE (see docstring).

1.0.26.4: less pessimal waitqueues

Readers calling CONDITION-WAIT don't interfere with each other.
CONDITION-WAIT used to set WAITQUEUE-DATA to *CURRENT-THREAD* causing
other readers entering FUTEX-WAIT to return with EWOULDBLOCK.

Set WAITQUEUE-DATA to NIL in readers, and to *CURRENT-THREAD* in
writers.

Also, fix a warning in :SEMAPHORE-MULTIPLE-WAITERS test.

1.0.26.3: cleanup accesses to *STEPPING* on MIPS and HPPA

1.0.26.2: alloc_code_object facelift

- use offsetof trace_table_offset instead of a hard coded constant

- alloc (boxed + unboxed) bytes not words

- check the gc is inhibited because the half initilialized code object
  could trip gc

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.