Fix NEWS

sbcl-1.0.58: will be tagged as "sbcl-sbcl-1.0.58"

Fix threads on Darwin 10.8

 * We used to pun (64-bit) addresses into 32-bit mach_port_name.

 * We used to assume arbitrary 32-bit addresses were always
   acceptable mach port names.

 * Stop doing that. Instead, allocate small descriptors until one's
   address is an acceptable port name (inspired by CCL).

 * Also, keep a lock-free free-list of descriptors to skip the previous
   loop in common cases.

 * There are still some strange issues, but I can't tell if they're new,
   and they seem preferable to consistently lose-ing when spawning threads.

Miscellaneous cleanups for threaded darwin platforms

 * Gather some related declarations in fewer (conditionalised) places

 * Lay down some infrastructure for mach port different from threads'
   addresses

 * Slightly modified by Paul Khuong

Fix build of contribs on Windows.

Set CC variable in make-target-contrib.sh, not in asdf-module.mk, Make
defaults CC to "cc" making it impossible to conditionally set CC to gcc
if it's unset.

Update to asdf 2.23

run-program: Don't make pty the process's controlling terminal.

When called without an existing pty, for example in Slime, run-program
will make the created pty as the process's controlling.

(process-close (run-program "cat" () :pty t :search t :wait nil))
was terminated with SIGHUP when called under Slime.

Restore buildability of run-program.impure on win32

... which had, unfortunately, been affected negatively by the previous
commit.

win32: Mark all currently failing tests as such

This change is not to be taken as an indication that these tests are not
going to be fixed.  Instead, it establishes a baseline against which to
measure future improvements, and it guards against further regression.

Please let's mark any newly added, problematic tests in the same fashion.

Temporarily disable problematic exhaust tests on Windows

Use preprocessor includes for link_or_copy on Windows

Declare types for sb-kernel:coerce-to-condition.

Add
(defknown coerce-to-condition ((or condition symbol string function)
                               list type-specifier symbol)
    condition
    (explicit-check))
Which helps to remove optimization notes in some cases with
restart-case.

Fixes lp#1025416.

Correct the info directory entry in sbcl-internals.texinfo.

The file name was wrong so that the info directory link wasn't working.
LP #1023175, thanks to Orivej Desh for the report and the fix.

Improve docstrings of MAKE-RANDOM-STATE and SEED-RANDOM-STATE.

The formatting of some item lists in the docstring of SEED-RANDOM-STATE
was broken in the manual. Fix the indentation of the docstring so that
the conversion to texinfo can correctly collect multiple lines belonging
to the same bullet points, and drop a "- " intended to indicate a
single-item list as that doesn't work (according to comments in
docstrings.lisp item lists must consist of at least two items).

Fix some small grammatical errors.

While MAKE-RANDOM-STATE's docstring is not in the manual, it consists
mostly of a part of SEED-RANDOM-STATE's docstring, so apply the fixes
there, too.

Simplify %symbol-value-in-thread further

Since Alastair Bridgewater fixed the race conditions in this function,
there is no need to loop anymore.

Use %p for pthread pointers in debugging output

brief_print: reset cur_lines

Otherwise, when running with QSHOW, the runtime stops printing
after 5000 objects (for example for traps).

Make run-sbcl.sh executable

Improved merge-sort implementation for lists

 The new implementation is simpler and more efficient than the previous
 bottom-up sort.  It only differs from the original patch aesthetically.

 STABLE-SORT-LIST is also now MAYBE-INLINE, to enable selective inlining.

 Thanks to Takeru Ohta for the code and for his patience.

fix long-standing debug-name confusion

  The calls to IR1-CONVERT-LAMBDA-BODY with the a VARARGS-ENTRY and
  HAIRY-ARG-PROCESSOR debug-names were no such things.

  These calls produces the actual lambda for the main body of the function,
  and as such should have the original source-name and debug-name.

  As proof of the pudding, we previously failed to detect several known
  function that are recursive but aren't marked as such in the DEFKNOWNs. With
  this that changes, so fix the DEFKNOWNs.

Fix typo in whitespacely-canonical-filenames

Thanks to Lutz Euler.

a few more .mailmap entries

  Trying to pick a canonical email for each, so that

    git shortlog -se

  shows only one line per person.

add .mailmap so "git shortlog -ns" counts properly

Add tests for two bugs that were incidentally fixed some time ago.

Commit b894cb41d869bda6ba0c54a491becc7bb58375c1 (make FORMAT signal
errors with illegal COLINC etc. parameters) happened to fix bug 905817
(endless loop in FORMAT with zero COLINC), then unnoticed, so add a
regression test and NEWS now.

Commit 96c62c30ec9164419c790b2fbea953da2193620f (ensure that GCD returns
positive values) besides the one intended also fixed bug 516750 (type
error when trying to convert a sum of rationals to a float). Add the
failing expression from that bug to the existing test.

test backtrace-interrupted-condition-wait works on Darwin/x86 as well

a few more tests to skip on unithreaded builds

fix :DEBUGGER :SOURCE 2 test on unithreaded builds

  Trivial layout different on debugger entry cause it to break.

test backtrace-interrupted-condition-wait works on Darwin/x86-64

adjust compiler-macro expansion and lambda-list parsing

 * Don't convert errors during compiler-macro expansion into runtime
   PROGRAM-ERRORs: signal a compile-time warning, and simply decline to expand
   the compiler-macro.

   This lives in CAREFUL-EXPAND-MACRO.

 * Make compiler not expand compiler-macros if there are arguments in keyword
   positions that are not self-evaluating constant symbols.

   This lives in two places:

    (1) VERIFY-KEYWORDS signals a COMPILER-MACRO-KEYWORD-PROBLEM when it
        encounters either an unknown keyword or anything except a
        self-evaluating symbol in a keyword position when parsing
        compiler-macro keywords.

    (2) IR1-CONVERT-FUNCTOID handles this condition by unwinding from the
        compiler-macro expansion, printing a note about the problem, and
        returning the original form.

    Calling COMPILER-MACRO-FUNCTION directly behaves exactly as before, for
    both good and ill: good in the sense that it is compliant, ill in the
    sense that doing things that way may expand things the compiler would
    decline to expand:

      (define-compiler-macro foo (&key ((a ax) t)) (format nil "a=~S" ax))

    The compiler would refuse to expand (foo a 42) unless

      (defconstant a 'a)

    had been done beforehand, but calling the COMPILER-MACRO-FUNCTION directly
    would expand it even without that -- as the spec unfortuntely requires.

sb-alien: some alien refactoring

  * Rename EXTRACT-ALIEN-VALUE & DEPOSIT-ALIEN-VALUE to %ALIEN-VALUE and
    (SETF %ALIEN-VALUE).

  * Split HEAP-ALIEN-INFO-SAP-FORM field into HEAP-ALIEN-INFO-ALIEN-NAME and
    -DATAP. HEAP-ALIEN-INFO-SAP-FORM becomes a function that conses up the form
    for the compiler, and HEAP-ALIEN-INFO-SAP replaces EVAL of the form.

  * Better error checking in PICK-LISP-AND-ALIEN-NAMES, and an error message
    that explains the correct form.

sb-alien-internals: ALIEN-VALUE to extract value of a symbol bound to an alien

  Used in the evaluators. Also allows the simple evaluator to process alien
  variables without invoking the compiler.

Micro-optimization: Avoid byte register writes on x86-64 in LOAD-TYPE.

The optimization guide for AMD's x86-64 processors recommends not
to write a partial register but instead to use MOVZX to write the
corresponding 32/64-bit register. Otherwise the instruction would have
an unnecessary dependency on the most recent write to the register,
reducing the available instruction level parallelism. On Intel's
processors this is not necessary but doesn't hurt.

To follow this recommendation, modify LOAD-TYPE to use MOVZX instead of
a byte MOV and adapt the VOPs that call it: FUN-SUBTYPE, SET-FDEFN-FUN,
and WIDETAG-OF. This additionally spares a temporary register in
FUN-SUBTYPE and allows to shorten all paths through WIDETAG-OF by one
instruction.

The effect on code size is small and mixed.

Update NEWS

Minor SPARC and PPC fixes.

turn off *PRINT-PRETTY* when reporting test results, want line per result

This new format is easier to parse than the old line-wrapped output.

Relax an implicit restriction on the number of code constants on SPARC

Previously, LOAD-CONSTANT was restricted by SPARC's particularly small
13 bit immediate field, allowing fewer constants than on other platforms.

Fixes lp#1008996.

In whitespace canonicalization, find a suitable make automatically

Simplify ppc's MOVE-TO-WORD/INTEGER

Fix inline fixnum LDB on PowerPC for certain bytespecs

Previously, the inline fixnum version of (ldb (byte 8 24) -1) would
return #x3f instead of #ff.

Fix test character.pure.lisp / BUG-994487 on non-unicode.

Replace a literal 1114111 with (1- CHAR-CODE-LIMIT) so that the test
works on #-sb-unicode, too.

Add a test for range reduction of trigonometric functions on non-x86.

Trigonometric functions of large float arguments yield differing results
depending on how range reduction is done. There is already a test for
the results expected on x86, float.pure.lisp/(:range-reduction :x87).

Add a test for the results expected from GNU libm and enable it for
all platforms except x86. The new test is impure and therefore added
to "float.impure.lisp". Move the x86 test there, too, to reduce the
potential for future confusion.

Skip the float.pure.lisp/RANGE-REDUCTION test outside x86.

The test was and is meant only to be used on x86 as it tests for results
the x87 FPU computes, which can differ from those on other platforms.
It was accidentally enabled for all platforms with commit
4c81c652cdc32faefee1bccb84c3c9a7854e3edd.

Revert this by skipping the test on everything except x86. Augment
the test's name and improve its comment so that it hopefully won't be
enabled again everywhere so easily.

Small enhancements to ISQRT

Replace MULTIPLE-VALUE-LIST with MULTIPLE-VALUE-BIND which conses less
and is slightly faster.

Correct the docstring.

Add a test for correctness.

Restore build on sparc/solaris.

gc-internal.h: include interr.h before `lose' is used.

Fixes lp#1008506.

emit compiler notes of NLX value-cells when (> SPEED SAFETY)

  People have a right to know: it's NEWS.

elide value cells for NLXs when it seems like the right thing

  Previously we only did this for unsafe code.

  Now we also elide them for

   (1) exits from DX functions: if a DX function escapes its proper context,
       trying to perform NLX to a stale tag is the least of our worries.

   (2) functions that cannot escape. Since the escape analysis isn't yet very
       tested, disable it for safe code, though. If this raises hairs on your
       neck, consider this: even if our analysis is wrong, and a function we
       didn't think could escape does, we're in the land of "undefined
       consequences" anyways.

       If you're wondering if this is worth it, compare

         (defun feh (x)
           (flet ((meh () (return-from feh 'meh)))
             (typecase x
              (cons (or (car x) (meh)))
              (t (meh)))))

         (time (loop repeat 10000 do (feh t)))

       with and without the escape analysis.

update NEWS

  MAP-INTO improvements.

  DOSEQUENCE improvement.

  Move optimizations above bugs.

add DO-VECTOR-DATA, remove special case from VECTOR-MAP-INTO

  DO-VECTOR-DATA is like DOVECTOR, but uses WITH-ARRAY-DATA and grabs the
  right reffer function so there's no per-element dispatch.

  Since MAP used DOSEQUENCE for for-effect/arity-1 case, and DOSEQEUNCE in
  turn uses DOVECTOR, replacing DOVECTOR there with DO-VECTOR-DATA we get the
  a performance boost while being able to drop the special case in
  VECTOR-MAP-INTO.

  Add a test for which the special case was broken: mapping a list into a
  vector.

move vm-array.lisp earlier in the build, remove %%SAETP-INFO%%

  This way DEFINE-ARRAY-DISPATCH can use *S-A-E-T-P* directly.

widetag dispatch for MAP-INTO

automate widetag dispatching

* add DEFINE-ARRAY-DISPATCH

* replace the VECTOR-SUBSEQ* dispatch scaffolding
  with a DEFINE-ARRAY-DISPATCH call

fix MAP-INTO performance

* remove the O(n^2) algorithm for lists

* use (MAP NIL ...) for all sequence types

* avoid unnecessary LENGTH calls

* update fill pointer after mapping succeeds, not before

* add tests for MAP-INTO (there were none!)

* add some WITH-TESTs to tests/map-tests.impure.lisp

Add a missing launchpad reference to NEWS.

Use multi-byte NOPs for code alignment on x86-64.

This is intended to speed up execution of such code sequences. It makes
the disassembly output somewhat more readable, too. The multi-byte NOP
instructions are chosen according to the recommendations of both AMD and
Intel. All existing x86-64 processors should support the "0f 1f" opcode
used.

This adds the needed infrastructure to the backend-independent compiler
parts and uses it from x86-64. Backends not using this functionality are
left unchanged.

Extend EMIT-ALIGNMENT to allow to specify multi-byte NOPs to be used
instead of repetitions of the single-byte NOP and change the call in
EMIT-BLOCK-HEADER on x86-64 to trigger this. Extend EMIT-SKIP to call
EMIT-LONG-NOP in this case.

On x86-64, add EMIT-LONG-NOP as the instruction emitter and extend the
disassembler entry for NOP to understand the multi-byte forms, too.

Make EMIT-FILLER decide more carefully whether to join fillers that are
adjacent in the list of segment annotations: Only join them if they are
immediately adjacent in the segment, too. (Otherwise the joined filler
would cover the wrong parts of a shortened alignment sequence.)

In certain circumstances %EMIT-ALIGNMENT splits an alignment into two
parts. This may not be necessary but has not yet been changed, so
sometimes one more long NOP than needed is assembled.

gensym: Don't restrict numerical argument to fixnum.

(gensym number) was restricted to fixnums, restrict it to
unsigned-byte, as per the standard.

better SIGNAL

  Add *STACK-TOP-HINT*.

  Move out the *BREAK-ON-SIGNALS* stuff to a separate function for
  clarity. Conditionalize the call there, meaning those restarts don't need to
  be allocated unless we actually need them -- making SIGNAL faster and a lot
  less consy. (TYPEP calls still cons, though. Can't have everything...)

run-program: Don't use /tmp unconditionally.

* Use TEMP on win32 and TMPDIR on non-win32.
* Don't delete just opened temporary files on windows, because opened
  files cannot be unlinked on windows.

Fixes lp#968837.

run-program: Don't decode and re-encode environ.

Leave environ unchanged when no :environment argument is provided.
Closes lp#985904.

implicit generic function warning improvement

 the warning now prints out the package of the symbol that corresponds
 to the newly created generic function.

some nincompoop broke the build

  *blush*

make ENSURE-GENERIC-FUNCTION accept method combination arguments

  Previously we only accepted a list designating the method combination, but
  since MOP also specifies a way to grab the actual method combination, we
  should really accept that as well.

  Fixes bug 936513.

fix source information for functions from EVAL

 * Removed the breathtaking (NAMED-LAMBDA (EVAL (DEFUN FOO)) ...) hack, which
   caused inconsistent source locations, and broke the built-in debugger
   source command for evaluated functions.

   Replace it with *SOURCE-FORM-CONTEXT-ALIST*, which allows the simple
   evaluator to communicate the original context to the compiler without
   messing with the function source.

   This also means we no longer have to wrap named-lambdas and lambdas in
   another lambda, but can instead compile them directly -- which in turn
   allows FUNCTION-LAMBDA-EXPRESSION to work correctly for definitions from
   EVAL and LOAD.

 * Additionally, use a handler to muffle any compiler notes from EVAL instead
   of using a declaration: those can leak to the user via F-L-E.

 * Change ACTUALLY-COMPILE to return a function signaling an error instead of
   returning NIL when compilation fails fatally. Doing this in
   ACTUALLY-COMPILE allows us to rely on COMPILE-IN-LEXENV always returning a
   function, and gives easy access to a better error message.

 * Properly associate COMPILER-ERRORS with their SIGNAL-ERROR restart.

 * Adjust debug.impure.lisp to be less dependent on the details of
   %SIMPLE-EVAL.

 * Test cases. Pay special attention to TEST-DEBUGGER in debug.impure.lisp.

 * New docstring for COMPILE. Added a sneaky teaser about COMPILE being able
   to recompile things, which is new starting to look feasible.

refactor GET-TOPLEVEL-FORM &co between debugger and disassembler

  * Merge the implementations in debug.lisp and target-disassembler.lisp.

  * Get rid of most of the cacheing.

  * Prefer the DEBUG-SOURCE-FORM if it exists: thanks to *SOURCE-NAMESTRING*
    we can have misleading namestrings for functions generated by calls to
    EVAL during LOAD, etc.

robustify COUNT-FULL-CALLS in the test suite

 Move it to compiler-test-utils.lisp, while at it.

lazy *STACK-TOP-HINT*s

  Allow binding it to a symbol, which is resolved when entering the debugger:
  it denotes the name of the first uninteresting frame.

  This simplifies ERROR, CERROR, BREAK, %BREAK, and makes interrupts more
  efficient as we no longer need to find the interrupted frame when entering
  an interupt handler.

  It also makes (handler-bind ((error #'invoke-debugger)) ...) once again gain
  the benefits of the stack top hint, which we lost when we ceased the provide
  the hint around the call to SIGNAL for efficiency reasons. Best of both
  worlds, one hopes.

factor debug-name cleaning into a separate function

  We will need it elsewhere too.

COMPILED-PROGRAM-ERROR source form needs *PRINT-ESCAPE*

  PRINC-TO-STRING is not what we want here.

implement ATOMIC-UPDATE

  Nicer than having to write explicit CAS loops.

  Also improve COMPARE-AND-SWAP docstring, and remove the EXPERIMENTAL label
  from it.

break infinite recursion in GENERATE-SLOTD-TYPECHECK

  Compilation of a typecheck can cause class finalization, which in turn can
  cause calls to GENERATE-SLOTD-TYPECHECK.

  Given the right sort of dependency graph, this can cause a cycle which needs
  to be broken.

  Regression from 1.0.46.11, fixed bug 1001799.

1.0.57: will be tagged as "sbcl-1.0.57"

Fix build on windows.

* Include sbcl.h before LISP_FEATURE_WIN32 is used in coreparse.c
* Include stub for _exit.

define-condition: return the name of the defined condition.

Better error for malformed type declarations.

Give proper error messages for things like
(declare (type (integer 1 . 2) a)).

Better error message for malformed IGNORE declarations.

Give better errors for things like (ignore (a)) and
(ignore (function . b)).

Fixes lp#1000239.

Optimize copy-tree.

copy-tree used to always call itself, even on linear lists, which
caused stack exhaustion on long lists. Make it copy linear lists
linearly, and recur only when necessary. This also makes it somewhat
faster.
Fixes lp#98926.

open intervals and type derivation

When dealing with open intervals, preserving the openness of a bound in
a result depends on the operation being strictly monotonic, rather than
merely monotonic.  However, many operations which at first sight seem
strictly monotonic are in fact not, including:
- squaring (expt least-positive-double-float 2) = (expt 0d0 2)
- coercion (coerce (1+ double-float-epsilon) 'single-float)
  = (coerce 1d0 'single-float)

Modify various coercion and interval functions to include conservatism
in these situations.  (Fixes lp#997528)

Fix --dynamic-space-size 1GB on x86.

Use unsigned longs instead of signed longs for handling
--dynamic-space-size, on x86 it can easily be exhausted.

Optimize truncate, ceiling and friends when divisor is 1 or -1.

If divisor is 1, return (values x 0), if it's -1 (values (- x) 0). If
it's a floating point truncation, like ftruncate or fceiling,
(values (- (float x)) 0).

Update ASDF to 2.21.

Fixes lp#982286.

don't unconditionally unparse CHARACTER-SET types into MEMBER types

  Doing so means dumping a list containing most of unicode for each
  function that return something like

    (code-char (+ <const> <(integer 0)>))

  which has a derived type (CHARACTER-SET ((<const> . 1114111))).

  Instead, pick whichever is more compact, using number of characters
  vs number of character code ranges as the deciding factor.

  This means that users can see SB-KERNEL:CHARACTER-SET types in
  eg. output from DESCRIBE or as return values from
  SB-INTROSPECT:FUNCTION-TYPE -- which is suboptimal, but less bad
  than such types slowing us down as horribly as they do prior to this
  change.

  At some point, however, we should document and export SB-EXT:CHARSET
  or something -- but I don't want to think of the issues associated
  with a public interface right now.

better timeout handling in EXIT and %EXIT-OTHER-THREADS

  Account the timeout against all the threads being joined, not each
  separately.

  Also move handling of "main thread exiting even though another
  thread got the call" handling to %EXIT.

  ...and one missing #!+sb-doc

more deprecation

 * Add "Deprecated Interfaces" chapter to the manual.

 * Add list of deprecated interfaces along with a policy note to a
   comment near DEFINE-DEPRECATED-FUNCTION.

 * Add a proper deprecation warning for SB-C::MERGE-TAIL-CALLS.

 * Fix the deprecation warning for WITH-SPINLOCK. (Accidentally
   referred to WITH-RECURSIVE-SPINLOCK before.)

sb-posix: abort(3), exit(3), and _exit(2)

  Also fix docstring of SB-EXT:EXIT, which referred to exit as being section 2.

runtime clean up.

coreparse.c: Move #define _BSD_SOURCE up, so that it won't conflict
with subsequent files, and #undef it after it's used to
include sys/mman.h

search.c(search_for_type): Remove unused variable addr.

interrupt.c: Remove double parentheses in if((x==y)).

run-program.c: Include sys/wait.h

Better equidistributed and faster/less consing integer RANDOM.

Up to now the implementation of RANDOM with an integer argument just
generated a few more random bits than the length of the argument and
took this value MOD the argument. This led to a slightly uneven
distribution of the possible values unless the argument was a power of
two. Moreover, for bignums, the algorithm was quadratic both in time and
space dependent on the number of bits of the argument.

Instead generate random integers using an accept-reject loop and change
the bignum implementation to an algorithm that is linear in time and
space.

I took some inspiration from WHN's attempt at an accept-reject loop
implementation in commit 0a7604d54581d2c846838c26ce6a7993629586fa and
following.

Thanks to Christophe Rhodes for reviewing this patch!

Some details:

The implementation works correctly with both a random chunk size equal
to the word size and equal to half the word size. This is currently
necessary as a 32-bit pseudo random generator is used both under 32 and
under 64 bit word size.

In the generic RANDOM case, fixnum and bignum limits are differentiated:

With a fixnum limit an accept-reject loop on a masked random chunk is
always used. Under 64 bit word size two random chunks are used only if
the limit is so large that one doesn't suffice. This never conses.

With a bignum limit four cases are differentiated to minimize consing.
If just one random chunk is needed to supply a sufficient number of bits
the implementation only conses if the result is indeed a bignum:
* If the limit is a power of two, a chunk is generated and shifted to
  get the correct number of bits.
* If the limit is not a power of two an accept-reject loop with shifting
  is used.
If more than one random chunk is needed, a bignum is always consed even
if it happens to normalize to a fixnum:
* If the limit is a power of two a straightforward algorithm is used to
  fill a newly created bignum with random bits.
* If the limit is not a power of two an accept-reject loop is used that
  detects rejection early by starting from the most significant bits,
  thus generating on the average only one random chunk more than needed
  to fill the result once.
The test for power of two is non-consing, too.

In the case of a compile-time constant integer argument (of at most word
size) a DEFTRANSFORM triggers, that, in the general case, compiles an
accept-reject loop. For values of the limit where this sufficiently
reduces the rejection probability the largest multiple of the limit
fitting in one or two random chunks is used instead inside the loop.
To bring the result in the correct range a division is then necessary
(which the compiler converts into a multiplication). Powers of two are
optimized by leaving out the rejection test. In those cases where a word
has more bits than a random chunk, the generated expression uses two
chunks only if necessary.

Add some tests for basic RANDOM functionality.

There are currently few, if any, such tests, so ahead of profound
changes to integer RANDOM add some. They are neither systematic nor
comprehensive but should be better than nothing.

Fix the DEFTRANSFORM of RANDOM for hairy integer types.

With integer types that are neither an interval nor a single known value
the DEFTRANSFORM used to generate an expression that had two problems:
First, it yielded very uneven distributions of random values for most
arguments to RANDOM that are not very small. Second, it used a too small
RANDOM-CHUNK under 64 bits word size thus never generating numbers
larger than (1- (EXPT 2 32)) even if RANDOM's argument was larger than
(EXPT 2 32).

Fix this by giving up the transform in these cases.

Add a new file "tests/random.pure.lisp" containing tests for this.

add SB-UNIX:UNIX-EXIT back, use the deprecation framwork for it and SB-EXT:QUIT

  Also extend the deprecation framwork to support multiple replacements:
  SB-EXT:QUIT should be replaced either by SB-EXT:EXIT or SB-EXT:ABORT-THREAD,
  depending on the way it was being used.

redesign exiting SBCL

 Deprecate QUIT. It occupies an uncomfortable niche between processes
 and threads, and doesn't actually do what it says on the tin unless
 you call it from the main thread.

 SIGTERM now uses EXIT, and doesn't depend on sessions.

 WITH-DEADLINE (:SECONDS NIL :OVERRIDE T) can now be used to ignore
 deadlines.

 JOIN-THREAD on the main thread now blocks indefinitely instead of
 claiming the thread did not exit normally.

 New functions:

  * SB-EXT:EXIT. Always exits the process. Takes keywords :CODE,
    :ABORT, and :TIMEOUT. Code is the exit status. Abort controls if
    the exit is clean (unwind, exit-hooks, terminate other threads) or
    dirty. Timeout controls how long to wait for other threads to
    finish.

  * SB-THREAD:RETURN-FROM-THREAD. Normal termination for current
    thread -- equivalent to return from the thread function with the
    specified values. Takes keyword :ALLOW-EXIT, which determines if
    returning from the main thread is an error, or equivalent to
    calling EXIT :CODE 0.

  * SB-THREAD:ABORT-THREAD. Abnormal termination for current thread --
    equivalent to invoking the initial ABORT restart estabilished by
    MAKE-THREAD (previously known as TERMINATE-THREAD, but ANSI
    recommends there to always be an ABORT restart.) Takes keyword
    :ALLOW-EXIT, which determines if aborting the main thread is an
    error, or equivalent to calling EXIT :CODE 1.

  * SB-THREAD:MAIN-THREAD-P. Let's you determine if a given thread is
    the main thread of the process. This is important for some
    functions on some operating systems -- and RETURN-FROM-THREAD and
    ABORT-THREAD also need it.

  * SB-THREAD:MAIN-THREAD. Returns the main thread object. Convenient
    for when you need to eg. load a foreign library in the main
    thread.

tune bug-981106 test based on the heap size

  Fixes lp#983807.

gencgc: scale generation.bytes_consed_between_gc to number of gens

  This means we have by default 5% of total heap usable in the nursery
  between GCs, and another 5% of the total heap split between all the
  generations -- and roughly matches the nursery/old generation sizes
  relations from before the dynamic-space-size based scaling.

  Fixes lp#991293, regression since
  6848a92fd4af23d0695eeaaed9efcbdfd9e1d9e5.

Better error messages to condition signalling functions.

gencgc: i in add_new_area needs to be signed

  Regression from 7be8d1462a207bda809cd7553c5d76c6ebc4dda2,
  broke finalize.test.sh on x86 builds.

  Fixes lp#989958.

fix compiler reader error reporting

  Stream slot was left unbound along one leg, which is bad because
  READER-ERROR is a subtype of STREAM-ERROR.

Micro-optimizations in MOVE-IMMEDIATE and MOVE-ARG on x86-64

In MOVE-IMMEDIATE, when the target is in memory, avoid using a temporary
register for more values than currently: The MOV instruction can move
immediate values of type (SIGNED-BYTE 32) into 64-bit memory locations,
not only (SIGNED-BYTE 31).

Simplify a TYPE-CASE in MOVE-ARG: merge two clauses that generated
exactly the same MOV instruction; spare a call to MOVE-IMMEDIATE and
get rid of two ugly literal 29s thereby.

Add a test.

Better arglists for some package accessors.

package-nicknames, package-use-list, package-used-by-list,
package-shadowing-symbols now have `package-designator' instead of `x'
in their arlgists.

Closes lp#854314.

Clean up: remove a duplicate definition from tests/compiler-test-util.lisp

remove world-lock from around FASL loading

  The fasl loader itself is thread safe these days, but what about the stuff
  we do at load time?

  In principle it /should/ be, so let the shakeout cruise start.

globaldb: remove ENV-LIST arguments from INFO functions

  Unused except by %DEFKNOWN, which passed in *INFO-ENVIRONMENT* anyways.

globaldb: add source-transforms for INFO functions on host

 Regular compiler macros defined on host do not take effect when XC is
 building the target -- so INFO calls in the build before globaldb got the
 slow path up to now. Using source-transforms we get the fast path for all
 INFO calls on target.

 Speeds up globaldb bound functions like FDEFINITION by 20% or so.

move ABOUT-TO-MODIFY-SYMBOL-VALUE to symbol.lisp

  Doesn't really belong in early-extensions.lisp.

better reader-errors for COMPILE-FILE

 * Make SIMPLE-READER-PACKAGE-ERROR a subclass of PACKAGE-ERROR.

 * Make reader signal a SIMPLE-READER-PACKAGE-ERROR for missing packages,
   instead of a vanilla PACKAGE-ERROR: that way get the position reported as
   well.

 * Factor out line and column reporting logic for reader-errors into a
   separate function, and allow using other than current file position.

 * READ-FOR-COMPILE-FILE needs to use COMPILER-ERROR, and
   INPUT-ERROR-IN-COMPILE-FILE is a subclass of READER-ERROR, not a
   FATAL-COMPILER-CONDITION.

 * *COMPILER-ERROR-BAILOUT* binding in SUB-COMPILE-FILE was missing the
   condition argument from the lambda-list, and should not mumble to
   *STANDARD-OUTPUT*.

 This patch converts all input errors into COMPILE-FILE failures without
 dropping into the debugger. That might be taking things too far, though --
 but the question of "which errors should we let enter the debugger" has no
 obvious answers to me at least. Perhaps *COMPILER-HANDLED-ERRORS* is the way
 to go?

 Fixes lp#493380