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

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

 * The VOPs for indexed access with constant offset take a fixnum
   index. Adjust fndb entries to reflect that.

 * Fix FOLD-INDEX-ADDRESSING: don't convert if the resulting index
   would be wider than a fixnum, and compute the new offset correctly
   for subtractions.

 * Test case by Douglas Katzman.

tweak so that block-delete-p is findable by grep for 'def.*block-delete-p'

search_for_executable() fails to process last part of PATH if PATH does not end with ':'

fix build with #!-SB-UNICODE

Don't build a hash table with high-codepoint characters as values under
those circumstances.

Improved SIMD-PACK manipulation VOPs on x86-64

 * Tighten naive (and, in one case, wrong-looking) lifetime
   specifications to enable more register coalescing.

 * Exploit the coalescing by replacing explicit move instructions
   with MOVE, and specify the SC to get MOVAPS for float data.

 * Microoptimise away some PSRLDQ by 0.

Specialised VOPs for EQ of fixnum values on x86oids

 Steal fixnum EQL VOPs to implement EQ, like we already do for
 characters, words and signed-words: otherwise they're converted
 as signed-word EQ.

Preserve types when swapping constant arguments and commute LOGTEST

 * Add a transform to ensure any constant argument to LOGTEST is in
   second position.

 * Commutative-arg-swap used to often cause suboptimal code: subsequent
   transforms fire before constraint propagation has tightened types
   back to their original value.  Hack with TRULY-THE for now. A more
   general fix (e.g. by declaring the type of arguments in spliced-in
   lambda expressions) would be even better.

Update/clarify the status of FUNCTIONP and COMPILED-FUNCTION-P

The two functions aren't collapsed anymore on #!+sb-eval builds.

Optimize (- (* x constant)) into (* x (- constant))

Another marginal lvar-fun-name/splice-fun-arg hack.

Closes lp#1065770.

More efficient move-from-signed on x86-64 with 63-bit fixnums

We can SHL instead of IMUL to check for overflow, and only have to
RCR the sign bit back in to recover the original value.

Simpler word-sized variable right shifts on x86 and x86-64

 * Known negative shifts are converted to another function that
   only handles machine-friendly right shifts.

 * The transforms and VOPs are conditionalised on ash-right-vops,
   so other platforms aren't penalised.

 * The new transforms trigger a lot of notes; this is suboptimal,
   and one test had to be adjusted.

Simplify (- (- x)) for rationals

 The transform is trivial enough to execute without a real pattern
 matching framework, but we're close to the limit.

Evaluate global inline functions via their fdefinition

 * When inlinable global functions are evaluated for value, emit
   code to refer to their fdefinition, rather than to a bogus
   entry point.

 * Make sure we only generate code to refer to XEPs and fail early
   otherwise, rather than after backpatching.

 * Fixes lp#1035721.

Truthful error reporting for complicated compile-time type mismatches

Type mismatches for multiple-use LVARs (i.e. resulting from conditional
expressions) can't be pinpointed to a single source for the value(s).

Such expressions used to be reported as type mismatches with the constant
NIL. Instead, switch to a more complex format with the lowest common source
form, if any (hopefully the conditional), and the nodes that may deliver
the form's value.

Do the same when warning about non-EQ-comparable CATCH tags.

Implement EQ of unboxed characters and small integers on x86oids

 More important now that we actually weaken EQL of EQ-comparable
 types into EQ.  We just have to re-purpose pre-existing EQL and
 CHAR= templates (and adjust the generic test's cost to be less
 attractive), but I can't test on !x86oids.

 Spotted by Douglas Katzman.

Complete SSE instruction definitions for x86-64

 * New instruction formats:
  - 2-byte instructions with GP/mem source and XMM destination.
  - 1- and 2-byte instructions with XMM source and GP/mem destination.
  - F3-escape instructions GP/mem source and GP destination.
  - 2-byte instructions with GP/mem source and GP destination.

 * Complete support for SSE instruction sets:
  - SSE3
  - SSSE3
  - SSE4.1
  - SSE4.2

 * Fix definition of pblendvb, blendvps, blendvpd: These require a third operand,
   implicitly in XMM0.

 * PEXTRW has a new 2-byte encoding in SSE4.1 which allows a memory address as
   the destination operand. The new encoding is only used when dst is a memory
   address, otherwise the old backward-compatible encoding is used.

 * Fix 64-bit popcnt (F3 still comes REX.W), and make it check for operand sizes,
   like the new CRC32.

 * Slightly adapted from Jonathan Armond to work with Douglas Katzman's F3-specific
   r, r/m instruction format.

Export SB-SIMD-PACK symbols from SB-EXT

 Export the SIMD-PACK type, the SIMD-PACK-P predicate,
 %make-simd-pack-{ub32,ub64,single,double}, and
 %simd-pack-{ub32s,ub64s,singles,doubles}.

 These are far from useful yet, but at least future extensions
 can work with SB-EXT instead of SB-KERNEL.

 Also, says so in NEWS.

SB-SIMD-PACK on x86-64

 * Enable them by default on x86-64;

 * And run some smoke tests, at least.

Additional niceties and middle end support for short vector SIMD packs

 * Allow FASL loading/dumping of (boxed) SIMD packs, and mark them as
   trivially (i.e. without going through make-load-form) dumpable.

 * SIMD packs print nicely, and take the element type into account while
   doing so.

 * (C)TYPE-OF is more accurate for SIMD packs; this enables IR2 conversion
   to choose the right primitive type and storage class for constants.

The FASL code was kept on life support by Alexander Gavrilov for too many years,
and the printing logic is a very light adaptation of the output code he developed
for his branch.

Back end work for short vector SIMD packs

 * Platform-agnostic changes:
   - Declare type testing/checking routines.
   - Define three primitive types: simd-pack-double for packs
     of doubles, simd-pack-single for packs of singles, and
     simd-pack-int for packs of integer/unknown.
   - Define a heap-representation for 128-bit SIMD packs,
     along with reserving a widetag and filling the corresponding
     entries in gencgc's tables.
   - Make the simd-pack class definition fully concrete.
   - Teach IR1 how to expand SIMD-PACK type checks.
   - IR2-conversion maps SIMD-PACK types to the right primitive type.
   - Increase the limit on the number of storage classes: SIMD packs
     went way past the previous (arbitrary?) limit of 40.

 * Platform-specific changes, in src/compiler/target/simd-pack:
   - Create new storage classes (that are backed by the float-reg [i.e. SSE]
     storage base): one for each of double, single and integer sse packs.
   - Also create the corresponding immediate-constant and stack storage
     classes.
   - Teach the assembler and the inline constant code about this new kind
     of registers/constants, and how to map constant SIMD-PACKs to which SC.
   - Define movement/conversion VOPs for SSE packs, along with VOP routines
     needed for basic creation/manipulation of SSE packs.
   - The type-checking VOP in generic/late-type-vops is extremely
     x86-64-specific... IIRC, there are ordering issues I do not
     want to tangle with.

 * Implementation idiosyncrasy: while type *tests* (i.e. TYPEP calls) consider
   the element type, type *checks* (e.g. THE or DECLARE) only check for
   SIMD-PACKness, without looking at the element type.  This is allowed by the
   standard, is similar to what Python does for FUNCTION types, and helps
   code remain efficient even when type checks can't be fully elided.

The vast majority of the code is verbatim or heavily inspired by Alexander
Gavrilov's branch.

Front end infrastructure for short vector SIMD packs

 * new feature, sb-simd-pack.

 * define a new IR1 type for SIMD packs:
   - (SB!KERNEL:SIMD-PACK [eltype]), where [eltype] is a subtype
     of the plaform-specific SIMD element type universe, or * (default),
     the union of all these possibilities;
   - Element types are always upgraded to the platform's element type
     (small) universe, so we can easily manipulate unions of SIMD-PACK
     types by working in terms of the element types.

 * immediately specify the universe of SIMD pack element types
   (sb!kernel:*simd-pack-element-types*) for x86-64, to ensure
   #!+sb-simd-pack buildability.

 * declare basic functions to create/manipulate SIMD packs:
   - simd-pack-p is the basic type predicate;
   - %simd-pack-tag returns a fixnum tag associated with each SIMD-PACK;
     currently, we suppose it only encodes the element type, as the
     position of the element type in *simd-pack-element-types*;
   - %make-simd-pack creates a 128-bit SIMD pack from a tag and two
     64 bit integers;
   - %make-simd-pack-double creates an appropriately-tagged pack from
     two double floats;
   - %make-simd-pack-single creates a tagged pack from four single
     floats;
   - %make-simd-pack-ub{32,64} creates a tagged pack from four 32 bit
     or two 64 bit integers;
   - %simd-pack-{low,high} returns the low/high integer half of a
     128 bit pack;
   - %simd-pack-ub{32,64}s returns the four integer quarters or two
     integer halves of a 128 bit pack;
   - %simd-pack-singles returns the four singles in a 128 bit pack;
   - %simd-pack-doubles returns the two doubles in a 128 bit pack.

Alexander Gavrilov kept a branch alive for the last couple years. The
creation/manipulation primitives are largely taken from that branch,
or informed by the branch's usage.

Fix foreign-symbol-address transform on +sb-dynamic-core.

Badly placed ` was resulting in a wrong result.

Make some instances of IF/IF conversion more direct

When faced with CFGs that look like (if (if ...) ...), we duplicate
the outer NULL test forward in the branches (and jump to the correct
branch, so very little code is duplicated).  However, this transform
depends on later ir1 optimisation to handle patterns like
(if (if ... nil t) ...).  Try and get them right with a specialised
rewrite to get good code even when ir1opt doesn't run until fixpoint.

Also, refactored the code a bit while working on it.

Exploit specialised VOPs for EQL of anything/constant fixnum

 By swapping constant arguments to the right ourselves before
 strength reducing EQL into EQ, rather than erroneously using
 commutative-arg-swap.

 Spotted by Douglas Katzman.

More efficient integer=>word conversion and fixnump tests on x86-64

 * Special-case on 63-bit fixnums to detect non-zero fixnum tag bits
   with a shift right when converting fixnum-or-bignum to ub64.

 * In fixnump/unsigned-byte-64, use MOVE to avoid useless mov x, x.

 * In fixnump/signed-byte-64, use the conversion's left shift to
   detect overflows.

 * Based on a patch by Douglas Katzman.

Cleverer handling of medium (32 < bit width <= 64) constants on x86-64

 * Exploit sign-extension for large unsigned constants.

 * Always force the remaining operand and the result in a register:
   in the worst case, we use a RIP-relative unboxed constant.

 * Based on a patch by Douglas Katzman.

POPCNT instruction on x86-64

 Patch by Douglas Katzman.

Fix disassembly for BT* instructions on x86oids

 * A dedicated instruction format gets the details right.

 * Patch by Douglas Katzman.

Annotate disassembly with unboxed constant values

 * Only on x86-64, for qword-sized values.

 * Patch by Douglas Katzman.

Improved local call analysis for inlined higher-order functions

Locall analysis greatly benefits from forwarding function arguments to
their use site.  Do that in locall and hopefully trigger further rewrites,
rather than waiting for a separate ir1opt phase to do its magic.

Constant-fold backquote of constant expressions

 * There is no guarantee that backquote expressions cons up fresh
   storage, so we are free to allocate (sub)lists or vectors at
   compile-time. In addition to regular constant-folding, perform
   part of LIST/LIST*/APPEND at compile-time.

 * Fix one instance of CL:SORT of now-literal data.

 * Implement SB!IMPL:PROPER-LIST-P because BACKQ-APPEND needed that.

 * Based on a patch by James Y Knight; closes lp#1026439.

Enable (type-directed) constant folding for LOGTEST on x86oids and PPC

 * COMBINATION-IMPLEMENTATION-STYLE can return :maybe. Like :default,
   it enables transforms, but transforms can call C-I-S themselves to
   selectively disable rewrites.

 * Implement type-directed constant folding for LOGTEST. !x86oids/PPC
   platforms get that for free via inlining.

 * Use :maybe to enable all LOGTEST transforms except inlining.

Exploit associativity to fold more constants

 * Implement transforms for logand, logior, logxor and logtest to
   detect patterns like (f (f x k1) k2) => (f x (f k1 k2)).

 * Same for + and * of rational values.

 * Similar logic for mask-signed-field: we only need to keep the
   narrowest width.

room: Fix reconstituting CONS cells with unbound-marker in the CAR.

  * When I originally rewrote ROOM in terms of RECONSTITUTE-OBJECT,
I looked at what constitutes a valid CONS according to the runtime.
I noticed that one of the immediate types was an unbound marker
and said to myself "nobody's going to put one of those in a list".
This turned out to be a mistake.

  * x86 systems (and plausibly not any others) put unbound-markers
in lists when loading FASLs.  I have no real idea how or why, but
they do.  This would lead to an error, "Unrecognized widetag #x4A
in reconstitute-object".

  * Fix, by recording unbound-marker-widetag as being valid as the
first word of a CONS cell.

  * Issue reported by "scymtym" on #sbcl.

gencgc: Decide earlier about pinning large object pages.

  * The old logic here called maybe_adjust_large_object(), and
then re-checked the pointer to preserve for validity.  This is
non-optimal, as it means that maybe_adjust_large_object can't
promote pages to newspace directly, it instead merely adjusts the
page allocation to fit the possibly-shrunken object.

  * It turns out that large_object pages can contain bignums,
vectors, code-objects, or in unusual cases instances.  Neither
bignums, vectors, nor instances can contain embedded objects.
Code-objects can contain only functions or LRAs.  None of these
objects have list-pointer-lowtag on their references.  The "tail"
of a shrunken object is comprised of conses with both cells as
fixnum zero.  The minor catch is that we allow untagged pointers
to pin code-allocated pages, but the saving grace here is that
code-objects don't shrink.

  * Alter preserve_pointer() to test the lowtag and page type to
check for invalid pointers to large-object pages before calling
maybe_adjust_large_object() instead of bounds-checking the pointer
after the fact.

gencgc: Fix potential out-of-bounds access in page_ends_contiguous_block_p().

  * If we're testing to see if the LAST page in dynamic space is
the end of a contiguous block, and it is a full page (bytes_used
is GENCGC_CARD_BYTES), we turn around and start investigating the
next page table entry... but there isn't one, it's beyond the end
of the allocation.

  * Fix, by bounds-testing the page index against the index of the
high-water mark for dynamic space.  This is guaranteed to be no
more than the total maximum for the page table, and is slightly
more micro-efficient than using the actual maximum, as any page
after the high-water mark will be page_free_p().

gencgc: Introduce a new predicate, page_ends_contiguous_block_p().

  * There are a number of places in gencgc where a number of
attributes of a page and possibly the subsequent page are tested
for various values.  Invariably, this is actually testing to see
if a page ends a contiguous block.

  * Extract the various tests to a new inlined predicate function,
page_ends_contiguous_block_p(), thus revealing the intent of
what's going on far better than the bare tests, and coalescing the
code to a single copy to make it easier to fix if there is a bug
in it (and there is, but this is a refactoring commit, not a
behavior change commit).

gencgc: Introduce a new predicate, page_starts_contiguous_block_p().

  * There are a number of places in gencgc where scan_start_offset
for a page is tested for zero.  Invariably, this is actually
testing to see if a page starts a contiguous block...  Or starts
on an object boundary.

  * Extract the various tests for a zero scan_start_offset to a
new inlined predicate function, page_starts_contiguous_block_p(),
thus revealing the intent of what's going on far better than the
bare test.

gencgc: Rename page_table field region_start_offset to scan_start_offset.

  * Let's call it what it is: The offset from where to start any
scan through the page to the start of the page.  The only relation
this field has to an alloc_region is the way it is initialized.

gencgc: Commentary fix for struct page, field region_start_offset.

  * Simply describing region_start_offset as being related to an
allocation region which contains a page is disingenuous at best,
and misleading at worst.  Its relation with an alloc_region is due
to its initialization strategy, and has nothing to do with what
the value is for.

  * Say it like it is, it's an offset to a known object boundary,
from where we can start a call to gc_search_space() or scavenge().
That's what it's for, not for keeping track of alloc_regions.

gencgc: Defer moving pinned pages to newspace as late as possible.

  * Rather than moving pinned pages to newspace immediately, defer
moving them until just before we start to scavenge (evacuate) all
of the oldpsace pages.

  * This, in theory, makes it easier to move pages to newspace if
they are mostly-live, rather than having to allocate new pages for
the data (increasing peak address-space use during GC), assuming
that we know that some page meets such criteria.

  * While we're here, commentary updates also replace an "XX I'd
rather not do this but the GC logic can't cope with not doing it"
with an actual explanation of WHY it needs to be done.  In fact,
commentary updates explain it twice, in two different locations.

gencgc: Fix commentary for page table allocation field.

  * The commentary for the page table allocation field was
misleading, presumably not updated when the definitions for the
constants used for its actual contents were last changed, and cost
me a bit of surprise and time spent trying to figure out why core
file saving and loading worked at all.

  * Updated the commentary on the allocation field to match
current reality, and added cross-references between the field
itself and the definitions for its contents, so that a future
desync between commentary and reality is less likely.

More robust function-name testing in CUT-TO-WIDTH

 Let's use lvar-fun-name instead of replicating half the logic; as
 a bonus, modularity transforms now heeds NOTINLINE.

Fix (CONCATENATE 'null ...) for generic sequences

 * (CONCATENATE 'NULL SEQUENCE1 SEQUENCE2 ...) ensures that SEQUENCE1,
   SEQUENCE2, ... are empty, but only did so for lists and
   vectors. Instead, use new function EMPTYP which works for all
   sequences. EMPTYP is not exported.

 * Add generic function SEQUENCE:EMPTYP to which EMPTYP dispatches for
   generic sequences. Methods for lists, vectors and generic sequences
   use NULL or (ZEROP (LENGTH ...)).

 * Test cases in seq.impure.lisp.

 * Patch by Jan Moringen; fixes lp#1162301.

Print intermediate evaluation results for some ASSERTed expressions

* The reports of errors signaled by ASSERT now print intermediate
  evaluation results under the following conditions:
   1. The ASSERTed expression is known to be a function call.
   2. Arguments in the call are not constants.

* Test the new feature in condition.impure.lisp.

* Original patch from Alexandra Barchunova; closes lp#789497.

Take bitwidth into account in BOOLEAN alien type

Some ABIs (x86/x86-64) allow garbage in unused upper bits of return
values; take that into account when converting BOOLEAN return types
to CL BOOLEANs.

Declare the argument type for float-radix

 Otherwise, inlined copies sometimes skip the type check.

Enable dumping huge (> 64k) pages in genesis

bvectors for a page can be smaller than the page size; zero-padding
explicitly as needed lets the build proceed further along before
failing, when configured with large GC card size.

Make ir1-convert-hairy-lambda safe for non-local exits.

The function it calls may throw a tag, locall-already-let-converted,
which will leave a partially initialized optional-dispatch structure
in new-functionals of the current component, which may cause problems
down the line.

Fixes lp#1180992.

Also add a test-case for f3a2cd.. "Add a stub for %other-pointer-p.".

Free-er form FILTER-LVAR

The DUMMY argument can now be in any argument position.  Use that
in CUT-TO-WIDTH instead of ((lambda (...) ...) ...) hack.

More robust FILTER-LVAR through CASTs

 * IR1-conversion can insert casts between a combination and its
   arguments. Handle that case via principal-lvar{-use}.

 * Fixes a regression in b111015 (lp#1181684).