Smaller stack frames on x86oids

Start at 4 slots (for some reason, it seems that 3 isn't really
the minimum, and grows by one slot at a time.

Disentangle storage base initial size from growth increments

Before, an initial stack frame size of 8 meant that the stack frame
always grew in increments of 8. Not only is a large initial size bad
for GC (it leaves more dead references untouched), but a large increment
is even worse.

Insert explicit cut to width when needed

 When modular arithmetic operations are replaced with specialised
 modular variants, the result's bitwidth is determined by the variant,
 and might be wider than expected. If necessary, insert an explicit
 cut to the exact bitwidth before returning a value in a non-modular
 context.

 Spotted by pfdietz's random tester.

 Fixes lp#1199428.

Avoid uselessly re-scanning modular arithmetic expressions

When modular arithmetic transforms have already fired for a
subexpression, and that subexpression's width is at most as wide
as the bitwidth we're cutting to, there is no need to re-traverse
the subexpression.

There was already some code to detect that case. Make it more general,
and, more importantly, sound.

No more destructive MERGE of shared data in best-modular-version

The old code worked by accident: few/no platform implements
untagged signed modular arithmetic VOPs.

The new code handles that common case to avoid consing a fresh list
when the MERGE will be an identity.

Optimize TYPEP of (MOD X) on x86/x86-64.

Optimize type-tests in the same vein as type-checks previously, and
implement type-checks by means of type-tests. Further optimize it by
avoiding doing fixnum tests on known fixnums and boxing of
signed/unsigned numbers.

Handle unbounded integer types in INTEGER-TYPE-NUMERIC-BOUNDS

If any of the integer type in the union lack upper or lower bounds,
immediately abort with unknown bounds (rather than taking the MIN
of NIL and an integer).

Thanks to pfdietz for his random testing.

Fixes lp#1199127.

Add a regression test for lp#1194673.

restore CLISP cross-compilability

s is the marker for short-float, not single-float.  Use f instead.

Update ASDF to 3.0.2.

1.1.9: will be tagged as "sbcl-1.1.9"

fix typo in FFI chapter

noted by Michael Crouch (lp#1197129)

Revert to binding *package* in bootstrappy code

 I see no sane way to use sb!ext:print-symbol-with-prefix or
 sb-ext:... in ~//. Bind *package* to :keyword instead, for
 undefined function conditions.

 Reported by adeth on #lisp.

Fix SLEEP on 32-bit platforms.

Fix a typo in the block comment on encoding/decoding universal times

 Might as well, while we're updating URLs.

 Spotted by Luis Oliveira.

s/32/n-word-bits/ in bignum-index

 For some reason we missed that during all the work on x86-64. Then
 again, our static inference is good enough that no runtime check
 seem to be left to detect that the declaration is wrong.

Store FP values from x87 to the heap outside pseudo-atomic

 It suffices to get the header right, and that way we avoid signaling
 FPEs in PA, when, as is bound to happen, a value is only truncated
 when it's boxed.

double->single float conversion isn't a no-op on x87 anymore

 The conversion can result in overflow, so pass through a stack
 temporary to force a truncation.

 Test case by Peter Keller on sbcl-devel, 2013-06-26.

New contrib: SB-GMP

 This contrib was developed by Stephan Frank to replace some of our
 bignum and rational arithmetic code with calls to libgmp.  Simply
 loading the contrib will transparently accelerate arithmetic on
 large rationals when libgmp is available; if libgmp cannot be found,
 the contrib should change nothing.

 The contrib also wraps additional functions in GNU MP, so that they
 accept and return SBCL-native integers or ratios.  See GNU MP's manual
 for more information.

Defer some sanity checks to after testing for value refence to inline functions

 The functional corresponding to an inline function can be marked as dead when
 there remains references in for-value contexts.  Detect such references before
 making sure the function is still live.

 Reported with a reduced test case by Teemu Likonen to sbcl-devel on 2013-06-24.

In MAKE-THREAD, use WITH-SYSTEM-MUTEX for locking *MAKE-THREAD-LOCK*

Otherwise MAKE-THREAD could be interrupted after having
locked *MAKE-THREAD-LOCK*. If the interrupting code also called
MAKE-THREAD, a recursive lock attempt for *MAKE-THREAD-LOCK* would
occur.

The problem could be easily triggered by

  (MAKE-TIMER ... :THREAD <T or a thread>)

Also move let bindings of SETUP-SEM, REAL-FUNCTION, ARGUMENTS and
INITIAL-FUNCTION and the NOT *GC-INHIBIT* assertion out of the
critical section.

Tests have been added in threads.pure.lisp and timer.impure.lisp.

fixes lp#1180102.

Wrap the body of sb-debug:backtrace with with-debug-io-syntax.

 Added with-debug-io-syntax macro.

 Some whitespace changes as well.

Provide more info in debugger-disabled-hook.

Before this change if there was an error printing the condition object,
then we didn't even try printing the backtrace afterwards, which can be
a useful source of information even if the condition printing has failed.

Some modifications by Paul Khuong.

Make the printing of a slot-unbound error more error tolerant.

Especially against errors coming from custom PRINT-OBJECT methods, in which
case only print the TYPE-OF the instance. Also, print fully qualified
symbol names.

Slightly modified by Paul Khuong.

Use sb!ext:print-symbol-with-prefix in implicit-generic-function-warning.

 and export this useful function from sb-exr.

 Slight mangling by Paul Khuong.

Update URL of "Long, Painful History of Time"

Previous URL was not available anymore (404 error)
Also rewrapped the paragraph to the same width as the others

Simplify EMIT-VOP further.

EMIT-VOP is only ever used in conjunction with INSERT-VOP-SEQUENCE, by
returning two values: first and last VOPs, all linked together,
INSERT-VOP-SEQUENCE then inserts them into the block. But nowadays
EMIT-VOP always returns the same VOP as the second value.
* EMIT-VOP now returns one value, the emitted VOP.
* INSERT-VOP-SEQUENCE is renamed to INSERT-VOP, accepts only one VOP.
* A new function EMIT-AND-INSERT-VOP is added, which combines them,
  and is used anywhere where EMIT-VOP was used.

This makes things less complicated, and reduces core size by 32KB, the
same as the previous commit, for a total of 64KB of savings
essentially for free.

(Also squeeze a couple of line-break fixes)

Simplify EMIT-GENERIC-VOP.

Since there's only one kind of templates now, there's no need for
indirection. Rename EMIT-GENERIC-VOP to EMIT-VOP, remove EMIT-FUNCTION
slot from TEMPLATE, call EMIT-VOP directly.

backtrace: don't cons large lists when RCX is overwritten inside XEPs.

To present a list with the actual number of passed arguments in the
backtrace, clean-xep used the arg-count register and added missing
arguments in the form of #<unknown>, but if the register is
overwritten by other code, it could cons very large lists, exhausting
heap. Do such arg-list clean up only upon INVALID-ARG-COUNT-ERROR.
Fixes lp#1192929.

Hopefully fix the windows build to grovel time structures correctly.

It is a little misleading to say "correctly" since struct timespec
doesn't really exist on windows. Groveling the definition that we
define in our own pthreads wrapper seems the most consistent choice.

The grovel-headers.c changes have only been tested in isolation, not
with a real build. Thanks to Kyle Isom for testing, any resulting
build problems are entirely my fault.

Grovel timeval and timespec struct definitions rather than hard-coding.

Fix instruction encoding for XMM shifts with immediate count

 x86 keeps getting more and more devious: the source/dest operand
 is in the r/m field for these instructions, so REX.B must be set,
 rather than REX.R, to access > xmm7. Intel's new documentation
 seems clearer about these issues, at least.

check-mod-fixnum: correct the test for power-of-two.

Testing for the power of two was performed on a fixnumized number,
causing the optimization for power-of-two to be never applied.

Add a missing :suppress-errors keyword for WRITE defknown.

Note removal of post-receive-email in NEWS

remove git/ directory

The scripts therein weren't directly relevant for SBCL development,
only for infrastructure to assist that development; additionally,
they are derived from git examples licensed under the GPL, and it
was difficult to explain the effects of this in a short paragraph
in the master COPYING file.  A new sbcl-git-hooks repository is
available on SourceForge for these and any other infrastructure
customizations.

Micro-optimize DOUBLE-FLOAT-LOW-BITS on x68-64.

Instead of loading a 64-bit register from memory and zeroing the upper
32 bits of it by the sequence SHL reg, 32; SHR reg, 32 simply load the
corresponding 32-bit register from memory, relying on the implicit
zero-extension to 64 bits this does. This is smaller and faster.

For example, if the input to the VOP is a descriptor register, the old
instruction sequence is:

  MOV RDX, [RDX-7]
  SHL RDX, 32
  SHR RDX, 32

and the new one:

  MOV EDX, [RDX-7]

Regarding store-to-load forwarding this change should make no
difference: Most current processors can forward a 64-bit store to a
32-bit load from the same address. The exception is Intel's Atom which
can forward only to a load of the same size as the store; but it also
supports this only between integer registers, and DOUBLE-FLOAT-LOW-BITS
mostly or even always acts on memory slots written from an XMM register
(of the three storage classes it supports as input, for the first it
does the store itself from an XMM register; for the other two I have
investigated some disassemblies and always found the prior store to be
from am XMM register).

Make clean.sh clean up doc/internals, too.

For completeness and equal treatment with doc/manual.

git: Add entries for the HTML manual to doc/internals/.gitignore.

These are the files and directories generated by "make html" in
doc/internals.

git: New file doc/internals/.gitignore.

Ignore the files generated by building the internals manual.
Copied and adapted from doc/manual/.gitignore.

Insert error traps after full calls inferred not to return

 An explicit error trap after full calls to known functions helps
 understand type derivation errors at runtime; it's certainly better
 than executing arbitrary bytes.

 Only do this when the return type was tightened to NIL via type
 derivation; if a function is defknowned not to return, it really
 shouldn't.

Only use MASK-SIGNED-FIELD VOPs as last resorts

 The MOVE hack usually leads to better code when it can be used.

Handle (aref v (+ i k)), with i negative

 * Update the fndb to allow negative index values for foo-ref-with-offset
   and foo-set-with-offset.

 * Adjust VOPs accordingly.

 * Fix fold-index-addressing: only fold constant offsets if the resulting
   index argument would be a fixnum, and compute the new offset correctly
   for subtractions.

 * Unmark the corresponding test as an expected feailure, and add a test
   to make sure VOPs for data-vector-{ref,set}-with-offset  accept negative
   index values (unless the element size is too small
   to fold offsets in an EA).

 * Un-package-qualify a few spurious test-util:with-test.

Fix a typo in bignum--ref-with-offset

Consistently force (double) rounding of foreign x87 values

 SBCL always functions in 64 bit mode, but switches to 80 bit for
 foreign calls.  Return values might be unexpectedly precise.

 Force a round-trip from the x87 unit and the stack to make sure
 FP return values are rounded to the correct width.

Look for left-over dead code when *check-consistency*

 If ir1opt leaves dead code around, later parts of the compilation
 pipeline can become seriously confused.  Detect such issues earlier,
 rather than as mysterious failures.

Simplify RATIONAL/constant FLOAT and INTEGER/constant RATIO comparisons

 The spec says that rationals and floats are compared by first calling
 RATIONAL on the float. Constant fold the call to RATIONAL, and round
 to an integer if applicable.

Silence notes about being specialised EQ templates on x86oids

 During LTN, we emit notes when the final chosen template costs
 at least 6 more units than an unapplicable template.  Adjust the
 costs of EQ VOPs to avoid triggering this logic.

Silence the transforms that detect rightward arithmetic shift

 It seems most of the time, the notes complained about clear left
 shifts.

Mark DATA-VECTOR-REF[-WITH-OFFSET] as unsafely flushable

 Unsafe code will be able to eliminate array reads as dead code.

Adjust internal encoding for TN location for larger SC count limit

 We need one more bit to encode values up to 62.

New VOP for LOGAND of bignum and word-sized constant on x86-64

 We can directly read the first bignum digit and AND it.

MASK-SIGNED-FIELD VOPs on x86-64

 Other platforms go through the MOVE hack like before.

More identity folding for LOGAND and LOGIOR with constants

 * Handle more complex cases than only powers of two:
   compare the variant argument with a power-of-two-sized
   prefix of the constant bit pattern.

 * Add parallel logic for LOGIOR: if all the ones we're ORing in
   are already set because the variant argument is a small enough
   negative integer, we've got an identity.

 * This is a bit hairy, so exhaustively check the logic with small
   values.

More associativity-based constant-folding

 Detect patterns like (+ (- x k1) k2) and (* (/ x k1) k2).

Enable signed modular arithmetic for LOGIOR

 When the result of a bitwise or is known to be negative, we don't
 need to compute the most significant bits (they're all ones).

Enable more modular arithmetic

 The rewrites now trigger when the result type for LOGAND or
 MASK-SIGNED-FIELD is an union of integer types.

Complete cut-to-width for modular arithmetic

 For each modular argument, go through the nodes that provide its
 value and try to narrow down their bitwidth. If we fail on any and
 the result might be too wide, splice in an explicit call to LOGAND
 or MASK-SIGNED-FIELD. Skip that last step if the value is an argument
 to an equivalent LOGAND or MASK-SIGNED-FIELD.

 Test case by Eric Marsden.

Fix negation of SIMD-PACK types

 type-union2 can punt and return NIL.

Simplify getting the contents of assembler segments.

Extend FINALIZE-SEGMENT to compact the segment's buffer and provide an
exported function to get at this buffer. This resolves an old KLUDGE
noted at ON-SEGMENT-CONTENTS-VECTORLY, making this function unnecessary.

There are several benefits to this change: First, the consumers of
assembler segment's contents, like WRITE-SEGMENT-CONTENTS which is used
for example during FASL dumping, or MAKE-CORE-COMPONENT, now call
WRITE-SEQUENCE respectively COPY-BYTE-VECTOR-TO-SYSTEM-AREA only once
per segment and not once per the pieces of the segment's contents that
ON-SEGMENT-CONTENTS-VECTORLY provided, which makes for less overhead.

Second, this allows to greatly simplify the whole operation of
DISASSEMBLE-ASSEM-SEGMENT, in the course deleting several helpers of it.
So far this repartitioned the pieces of the segment's contents from
ON-SEGMENT-CONTENTS-VECTORLY, while caring not to split the contents
inside instructions, which needed a sizable amount of code. Now the
segment's contents are simply disassembled as a whole. Also, the old
code (specifically SEGMENT-OVERFLOW) didn't take prefix instructions
into account correctly which surfaced as the bug in lp#1085729.

Fixes lp#1085729.

Also, fix an unrelated typo in NEWS.

Stop exporting unused symbols.

Factor out read-var-integer into a function.

read-var-integer macro is used quite a number of times, expand the
macro into a SETF, which calls %read-var-integer, which does actual
reading. Reduces the core size by 65KB on x86-64.

sb-bsd-sockets: More robust inet-socket-bind test on Windows.

Nested unwind-protects aren't supported on Windows.

Get rid of vm-support-routines indirection.

VM routines were defined using two functions, one calling another
through structure slots. This is unnecessary, removing leads to a
~200KB core size reduction on x86-64.

Optimize (mod FIXNUM) type-checks on x86oids.

Instead of two (and (>= x 0) (< x FIXNUM)) comparisons, do one
unsigned.
(mod power-of-two) is further optimized by doing one mask test
determine the range and fixnumness in one go.

sb-bsd-socket tests: don't listen on a predefined port.

Listening on 1974 prevents from building contribs in parallel.

fix CL case conversions of characters involving iota subscript

Oh boy.  Judging by the length of the web page explaining the issue
(at <http://www.tlg.uci.edu/~opoudjis/unicode/unicode_adscript.html>)
this is a bit of a minefield.  I hope that this doesn't contribute
further to the trouble...

Although the combined _WITH_PROSGEGRAMMENI characters are of
general class "Lt" (i.e. titlecase), for CL purposes we treat them
as the uppercase equivalent of the lowercase _WITH_YPOGEGRAMMENI
characters (as directly specified by the case mapping data in
UnicodeData.txt).  This is a little awkward, and involves a bit
of rearrangement in the indices of the misc table entries to make
the (CL) uppercase/lowercase tests efficient, but seems to be the
best of all possible worlds given that we must comply with CL's
character-to-character case mappings -- the alternative of not
providing an uppercase version of LOWERCASE_OMEGA_WITH_YPOGEGRAMMENI
seems even weirder.

The way this is done in ucd.lisp is a little bit kludgy, because we
have to avoid giving the same exception to the serbian titlecase
digraphs (Dz and friends) which mustn't map to anything, or else
we'd break invertibility.  (The lowercase dz and uppercase DZ are
already (CL) case mappings of each other).  Probably the thing which
will confuse future readers is that some (Unicode) titlecase
characters are (CL) upper-case-p.

Simpler and more precise type derivation for APPEND/NCONC

 We can suppose that all but the last argument are lists when
 deriving the return type... and the logic to compute the return
 type can be much simpler: it's either a CONS, the last argument,
 or we don't know which (yet).

Uninitialized type-error conditions can now be printed.

(print (make-condition 'simple-type-error)) signalled an unbound slot
error.

Reported by Eric Marsden, fixes lp#1184586.

sb-bsd-sockets: Fix type of canonname in addrinfo.

Should be c-string-pointer, not c-string.

Fixes lp#1187041, patch by Jerry James.

Fix APPEND/NCONC type derivation properly this time.

Use type-intersection for checking types, it's more robust than what
was there before.

And a slight improvement. When argument in the middle can't be a NIL,
then the end result is guaranteed to be a CONS. Previously, the
assumption was if the type is a CONS, but that doesn't work with types
like (or cons vector).

fixes in EXPT type derivation

It was possible to construct mostly (but not completely) unobservable
bogus floating-point types when deriving the type of functions
returning the value of calls to EXPT.  Noticed by Vsevolod Dyomkin,
who found a way to observe it by redefining methods.

Fix NCONC type derivation.

Properly check the types of arguments, instead of testing for subtypes
or supertypes of LIST, check for arguments to be subtypes of NULL or CONS.

Reported by Jerry James.

sleep: Add more precautions to avoid consing on x86.

Fix sleep on ratios, avoiding consing.

Enable sleep tests for some platforms.

some tests of SLEEP with ratios

fix sleep on most ratios

really really ensure that the second argument to nanosleep is an
integer

delete ye olde FIXME relating to unbound variable warnings

Testing the code in the real system gives a full warning

fix (again) the handling of read errors in the debugger

Actually the read errors were doing what we wanted, but EOF was no
longer popping one debugger level.  The control transfer is a bit
gnarly, so explicitly grab the restart we might want to use and pass
it as an argument to DEBUG-READ.

Avoid consing in SLEEP.

Try to compute seconds without consing, when the arguments are small
enough (in the fixnum range).

Add a transform to go directly to sb-unix:nanosleep when possible.

Make %coerce-callable-to-fun static on x86oids.

It's called a lot when doing funcall or apply.

Don't go through fdefn when referencing #'known-functions.

Known functions are know to be always present, save on indirection by
using them directly.

slightly better handling of read errors in the debugger

wrap the read as well as the eval in the WITH-SIMPLE-RESTART ABORT
so that the user can return to the existing debugger level on read
errors.

Correct call-indirect for >32-bit addresses.

Better calls to static functions on x86-64.

Encode the calls to static functions as an immediate argument to the
CALL instruction when possible.

Better calls to static functions on x86-64.

Encode the calls to static functions as an immediate argument to the
CALL instruction when possible.

Better initialization of ir2-component-constants on x86-64.

x86 uses the first constant for the fixup vector, x86-64 doesn't.
Don't leave empty space in ir2-component-constants.

On the C side, call gencgc_apply_code_fixups only on x86, and not on
x86_64 as well, since its body is conditionalized for x86_64 anyway.

Remove unused variables in the compiler.

*code-vector* *next-location* *result-fixups* were last seen being
used on 24 Aug 1990.

disassemble: Better annotation of static functions and safepoints.

Static functions, like LENGTH and some others, weren't annotated in
the disassemble output.
Also add annotations for safepoints.

1.1.8: will be tagged as "sbcl-1.1.8"

Fix expected result for a character comparison test under non-unicode.

The test "character.pure.lisp / :case-insensitive-char-comparisons
:exhaustive" was marked as an expected failure as the unicode
implementation is not yet complete, but on a non-unicode build it
actually already succeeds.

Fix a regression in APPEND type derivation.

Do not just test the arguments for validity by being subtypes or
supertypes of LIST, but also if it's a subytpe of NULL, since ATOM or
SYMBOL won't satisfy the LIST tests.

Regression since f32ee7d.."Better type derivation for APPEND, NCONC,
LIST.", reported by Eric Marsden.

Stricter precondition when strength reducing variable right shifts

 Looking at the node's derived type is safer than a result type
 constraint, which seems to consider the LVAR's derived or
 truly-declared type.

 Remove a redundant AVER too. If people call %ash/right directly and
 incorrectly, they're looking for trouble. Moreover, the call's
 type will be derived only if the argument types are correct.

 Reported by Eric Marsden on sbcl-devel; further reduced test cases
 by Christophe Rhodes.

Compute single-value-type correctly in the absence of required values

 * For the longest time (at least 2003), we didn't take defaulting
   into account and did not union the single-value type with NULL.
   For some reason, the issue didn't manigest itself until we improved
   code generation for EQ/EQL this month.

   Thanks to Attila Lendvai for the reasonable test case.

 * Also, fix a typo in a VOP name for EQ of fixnum values.

fix CHAR-EQUALity of non-ascii caseful characters

Or at least mostly fix it.  There are issues surrounding iota subscript and
titlecase, which aren't regressions in the current release and will require
some more investigation to fix.

Skip unicode normalization tests on non-unicode builds.

This was accidentally missed when the tests were introduced.

Revert "Fix (aref vector (+ i constant)) with i negative on x86oids"

This reverts commit 5d3a728a1d9a91e7218fe53f12f96ab63b846810.

The current code is still wrong, but better the bugs we've always had
than the ones that break currently-working code.

Kept the test case, and added the one we failed on.

Even safer substitution of constants in CUT-TO-WIDTH

 * Fix another aspect of the modular arithmetic bug that was only
   partially fixed by ccd2a1d (Substitute constants with modular
   equivalents more safely); detected by the previous fix not
   working on !x86oids.

Robustify specialised IF/IF conversion introduced in 729ce57

 * When unlinking a node from its destination LVAR, always mark
   the node as potentially up for dead code elimination. IR2 can
   become really confused when converting dead code; a more
   systematic cleanup pass might provide a useful safety net.

 * The changes make a widely-used ir1-manipulation function safer,
   so this might also fix some other obscure compiler bug.

 * Reported by James Y Knight on IRC and Fila Kolodny on Launchpad
   (fixes lp#1183496).

Silence the compiler when (runtime-) compiling PCL innards