Fix ldb / %%ldb / rlwinm on PowerPC

Thanks to Bruce O'Neel for confirming the validity of the fix.

Typo fixes in comments

Fix typos in docstrings.

In DEF-IR1-TRANSLATOR of TAGBODY and MACROLET.
LP #958931, thanks to Juanma Barranquero.

teach IR1-TRANSFORM-TYPE-PREDICATE about alien types

  Convert to ALIEN-VALUE-TYPEP (new function). Avoids both the need to do the
  whole type parsing rigamarole at runtime, and checking for lisp-rep-type.

  Need to do this as late in the game as possible, because after we convert to
  ALIEN-VALUE-TYPEP, the rest of the system stops understanding it as a type
  test. (We really should have some sort of annotation for this sort of stuff,
  so we could convert whenever.)

show correct number of arguments for arg-count error frames

  Or at least pretend harder. Ie. if the frame is a XEP frame,
  and the actual argument count is > number of parsed arguments,
  make up unprintable ersatz objects for the rest.

sanitize one of the recent c-string decoding tests

  No out-of-bounds accesses, thanks!

  ...and thanks to Nathan who spotted my bogosity.

prettier encoding/decoding error messages

  ":ASCII stream encoding error on #<FD-STREAM ...>"

  ":ASCII stream decoding error on #<FD-STREAM ...>"

  ":ASCII c-string encoding error ...>"

  ":ASCII c-string decoding error ...>"

wrap a couple of long lines

associate stream decoding and encoding errors with their restarts

  ERROR call needs to appear inline for that to happen without
  extra acrobatics.

correct octets in c-string decoding errors

  Also add SAP-REF-OCTETS for grabbing a vector of bytes from
  memory. We'll need it elsewhere as well.

  Fixes lp#985505

Micro-optimize machine code for some register tests on x86[-64].

Replace all occurrences of (INST OR REG REG) with (INST TEST REG REG)
in VOPs and assembly routines. This removes, for the next read of REG,
the dependency on this instruction, allowing more instruction-level
parallelism, so is potentially faster. Moreover, most of the time the
next instruction is a conditional branch, which allows processors that
support macro-op fusion to fuse the TEST (but not the OR) with this
branch instruction, reducing the resources needed to decode and execute
the two instructions, which again is potentially faster.

Micro-optimization: Shorter encoding of MOVZX in more cases on x86-64

The assembler instruction MOVZX is already assembled as a straight
32-bit MOV when it is used to zero-extend a 32-bit source into a 64-bit
register, taking advantage of the processor's implicit zero extension,
sparing the REX prefix (if it was only needed to indicate the 64-bit
size) and thus reducing code size. Towards the same goal, change
zero-extensions of 8- or 16-bit sources into a 64-bit register to use
the corresponding 32-bit register as the destination instead, in the
process refactoring EMIT-MOVE-WITH-EXTENSION for more OAOO-ness.

Micro-optimize some type tests on x86-64 for code size.

In SIGNED-BYTE-64-P and CHECK-SIGNED-BYTE-64, if possible, spare a REX
prefix by using a 32-bit instead of a 64-bit register move instruction.

In UNSIGNED-BYTE-64-P and CHECK-UNSIGNED-BYTE-64 use AL instead of RAX
to test the lowtag.

Micro-optimize LENGTH/LIST and VALUES-LIST on x86-64 for code size.

As already common in several other places prefer a 32-bit temporary over
a 64-bit one for type checking in these VOPs to possibly spare a REX
prefix.

Micro-optimize type tests using widetag on x86-64.

Change %TEST-HEADERS not to load the widetag of the value to be tested
into AL if only a single comparison is needed on it, instead do the
comparison directly with the memory operand. This is smaller and needs
fewer execution ressources.

This is a port of what is done on x86 already, with two modifications:

 * Widetag ranges starting with the smallest widetag or ending with the
   largest widetag use the memory operand here but go through AL on x86.

 * x86 exploits the specially choosen widetag values of components of
   compound types (like BASE-STRING) to test for these types with only
   an additional "and" operation but still only a single comparison.
   This can't be done on x86-64 currently as under 64-bit wordsize the
   widetag values are different and don't have the necessary property
   (namely to differ in only a single bit).

Additionally, when AL needs to be loaded, use EAX instead so as not to
write a partial register (as recommended by the processors' optimization
guides). Same code size, potentially faster.

Silence a "deleting unreachable code" warning during build by removing
an IF and the corresponding unreachable expression.

use fixnums for x86-64 array accessor VOPs when possible

Now that we have fixnums with 1-bit tags on x86-64, we can use them
directly for accessing arrays with 16- and 32-bit elements, rather
than converting to unsigned words first.

This patch is originally from Paul Khuong:

http://paste.lisp.org/display/128545

Correct disassembly of some SSE instructions on x86-64.

CVTSD2SI, CVTSS2SI, CVTTSD2SI and CVTTSS2SI used to print a source
memory operand with a size indicator wrongly indicating the size of
the destination, for example "CVTTSS2SI RDX, QWORD PTR [RBP-8]".
Correct this by printing the memory reference without a size indicator
as the size of the source is implicit in the instruction. Remove an
argument type and a print function that were used only for these
instructions.

gencgc: tune the recent "more aggressive GC" changes

 * Don't account fresh objects against auto_gc_trigger unless they're larger
   than bytes_consed_between_gcs: smaller objects don't mess up the logic so
   badly, and it's better not to force early promotion of fresh objects unless
   we have to.

 * Put the unqueality in setting auto_gc_trigger the right way around...

 Fixes lp#981106 (regression from 6b1b11a6c51e1c29aee947f1fde7f91651ca3763)

micro-optimize allocation sequences, special variable binding on x86-64

Move the ALLOC-REGION, PSEUDO-ATOMIC-BITS, and BINDING-STACK-* slots
closer to the beginning of the thread structure.  This change ensures
that the offsets for those slots are < 128 bytes, which in turns enables
shorter encodings for all accesses to this structure from Lisp code.

Code size of the C runtime was negligibly affected by this change.

s/8/n-word-bytes/ in x86-64's macros.lisp where appropriate

micro-optimize FIXNUMP on known (signed-byte 64) quantities on x86-64

Also attempt to keep things working for those who want smaller fixnums.

use LEA Y, [X+X] instead of LEA Y, [X*2] where appropriate on x86-64

The former instruction is slightly smaller.  Keep the old form around
for people who want to compile x86-64 with smaller fixnums.

format: Signal errors when colinc and mincol are not positive integers.

Various directives have colinc and mincol parameters, which should be
> 0 and >= 0 respectively.

support funcallable-instances in ROOM/map-allocated-objects

Fix bug in unsigned modular arithmetic using a signed implementation

If we aim to be clever by implementing an unsigned modular arithmetic
computation using signed arithmetic, we need to make sure that we
don't accidentally contaminate the computation with any extraneous
high bits.  This means that we must be sure to cut constants to the
appropriate width, as well as computations, so do so; this fixes
bug #974406 from Paul Dietz.  (In addition the change from cutting
to the requested width to the implementation width fixes #903821,
so Go Team!)

Test cases.  Minimally horrible test case for #903821; far worse
suggestions were made on #sbcl IRC...

minor fix to alien.impure.lisp test

Don't signal a compiler-note with ERROR to indicate failure; it bypasses
the handlers and aborts the entire file.  Use (error "bad note: ~A" note)
instead

run-program: proper handling of :if-input-does-not-exist NIL.

:output existing-file :if-output-exists NIL and
:input non-existing-file :if-input-does-not-exist NIL signalled errors
instead of just returning NIL as specified.

Fixes lp#968836

pprint: Make sure that lists like (loop . 10) can be printed.

pprint signaled an error when called on improper lists with
a car being a symbol from CL (loop, macrolet, flet, and some others).

ensure-directory-exists: didn't work when *d-p-d* had NAME or TYPE components.

(let ((*default-pathname-defaults* #p"/tmp/foo"))
     (ensure-directories-exist "/"))
signalled an error that "/" doesn't exist because it was checking for "/foo".

robustify (deadlock-detection interrupts) test

    1. Make sure the desired "tricky" ordering happens.
    2. Make sure threads can't exit before they're intrerupted.

  Next time I commit a test that relies on SLEEP without a comment explaining
  (1) why it is necessary and there isn't a better alternative (2) what the
  ordering the tests is trying to achieve actually ise... please hit me with a
  stick. Hard.

cleanup: remove cast to (unsigned long) from print_ptr()

cleanup: partial long cleanup in sniff_code_object and gencgc_apply_code_fixups

  Feels more like an address arithmetic cleanup, though. :)

  Slowly...

cleanup: gencgc copy_unboxed_object and shared gc_general_copy_object

  Implement the first in terms of the second: they're identical except for the
  calling convention. Move the second to gc-internal.h as an inline function.

  Also eliminates a couple of longs.

cleanup: use size_t for new_areas_index and max_new_areas

  Two longs down, umpteen to go.

gencgc: reclaim space more aggressively

 * When considering auto_gc_trigger, take the number of bytes about to be
   allocated into account.

 * If bytes_consed_between_gcs is more than the amount of free heap, set next
   GC to occur when half of the remaining free heap has been consumed.

 * Keep track of the size of the largest object allocated between two GCs.
   When collecting garbage, if there isn't enough space to allocate at least
   two such objects before collecting the last generation due a collection,
   extend the collection by one extra generation.

   This works around our tendency to immediately promote large objects to
   generation 1, due to auto_gc_trigger causing a GC _after_ the allocation.

 Fixes lp#936304.

MAKE-LEXENV used NCONC on its arguments, which callers did not expect

  Fixes lp#924276.

more conservative classoid-name clearing

  (SETF (FIND-CLASS X) NIL) should not clear the classoid name if X is
  not the proper name of the class.

  lp#941102

plain T and OTHERWISE not allowed in CASE normal-clauses

  lp#959687

don't refer to unix namestrings on windows

sb-simple-streams: signal an error for bad stream classes in OPEN

  Instead of silently returning NIL, signal an error if the class does not
  exist (if argument :class is a symbol) or is not a stream class.

  lp#969352

better REPLACE docstring

  lp#965592

1.0.56: will be tagged as "sbcl-1.0.56"

Add workaround to a flaky semaphore timeout test.

Add an entry for ASDF upgrade to NEWS

clarify the make.sh --with-feature and --without-feature syntax in INSTALL

  Documentation-only, so going in despite the freeze.

contrib/asdf: Import asdf 2.20 from upstream.

   * lp#933112

Fix build on PPC/Darwin

Fixup fewer complaints about hairy lexical environments

In particular, if the function has been requested NOTINLINE, and that name
has never been INLINE or MAYBE-INLINE, there should be no compiler note.
Include a test case and a NEWS entry for posterity.

Don't signal a note on NOTINLINE non-toplevel functions.

When a function was declared NOTINLINE, and later defined not at the
toplevel, SBCL signaled a note saying that it can't inline it.

Fixes lp#963530.

Closes https://bugs.launchpad.net/sbcl/+bug/911027

Fix copy-structure.  When copying from stack to heap, garbage could
end up in the heap making GC unhappy.  Thanks to James Knight.

Make SBCL buildable by Clang.

The only changes needed were a modification to use $CC when building
contribs, and inline declaration incompatibility for a couple of
functions.

Closes lp#658414.

ensure-directories-exist: Signal an error when trying to create a
directory with the same name as an existing file.

Previously (ensure-directories-exist "/foo/bar/"), where /foo/bar is a
regular file, just silently returned "/foo/bar/", NIL.

Clean up OpenBSD makefile fragments a little.

It seems -export-dynamic is no longer necessary for
tools-for-build. Perhaps it never was, and I was just confused.

Remove an OpenBSD note in the README which is no longer necessary.

OpenBSD's behavior has not changed, but the default SBCL allocation
size was changed some time ago to work with the default OpenBSD
resource limits.

coreparse.c: Fix a typo WORD_FTMX -> WORD_FMTX.

getf: Correct docstring.

Use `PLACE' instead of `Place' when referring to the variable.

Fixes lp#930751

weakening hairy integer types

 Fixes lp#913232.

 Deal with intersection types and unions including non-integer component
 types, such as:

   (OR (INTEGER * -1) (AND (SATISFIES ODDP) (INTEGER 1)))

maybe-update-info-for-gf: Use KEYWORD-SPEC-NAME for keyword parameters.

Use KEYWORD-SPEC-NAME instead of KEYWORDICATE to handle keyword
parameter definitions like ((:keyword var) default).

Patch by Andy Hefner.

Add patches from Aymeric Vincent to fix sb-posix on recentish NetBSD.

There is some possibility that this will break one of the sb-posix tests on FreeBSD:

  The "rmdir" patch needs some input from FreeBSD users.
  "rmdir /" returns EBUSY on NetBSD. Given the recent commit
  2a9b33fc45842ec0335fef2988e07337ae8f1fc7 on october, 17. 2011, it looks
  like OpenBSD and Darwin return EISDIR, but it's clearly not the case of
  NetBSD with a (usual) FFS file system.

  In short, either sbcl is currently broken on FreeBSD wrt the rmdir test
  and my patch will fix it, or my patch will break it and we need to include
  freebsd in the list of OSes producing EISDIR upon "rmdir /".

1.0.55: will be tagged as "sbcl-1.0.55"

Mark :no-consing :specialized-dx-vectors as failing on x86.

git: add missing git hook scripts from SourceForge

  We've been using these for a while now, but I neglected to stash copies in
  the repository.

  Also instructions for updating them, since it isn't the most intuitive thing
  in the world.

twiddle script.test.sh

  Can't open /dev/stdout on all platforms -- but happily for the behaviour we
  want to test we don't have to.

  Also add a compile of variations on the theme.

runtime: handle KERN_ABORTED in the darwin semaphore implementation

  Analogous to EINTR.

defknown SC-NUMBER-OR-LOSE as foldable

  No point calling it all the time with constant arguments.

use %VECTOR-RAW-BITS in %BIT-POSITION/[0|1]

 No need to pin, and it even performs a tiny bit better than using explicit
 word -> byte address computations.

package locks and compile-time effects of DEFCLASS

  DEFCLASS FTYPE used to break SBCL, but package locks didn't catch it.

stack-allocatable fill-initialized specialized arrays, part tres

 lp#902351

 Mark %CHECK-BOUND as DX-SAFE, so that vectors of unknown size can be stack
 allocated.

faster FIND and POSITION on bit-vectors

 Read data a word at a time for efficiency's sake.

 Could do even better with VOPs, but this already wins hugely on sparse
 vectors -- and works on all backends. (Tested on both little- and big-endian
 hosts.)

 This also makes constraint propagation in sparse universes a bit less sucky.

Fix control stack scavenging for dynamic-extent allocation.

  * Non-CONS objects on the control stack can cause... problems
in scavenge().  Rewrite scavenge_control_stack() to contain the
appropriate (simpler) scavenge code directly.

Move control-stack scavenging to gc-common.c.

  * Instead of having slightly-divergent copies of the control
stack scavenging logic for both GENCGC and CHENEYGC, move the
GENCGC version (which is a separate function) to gc-common.c,
and alter CHENEYGC to use it instead of doing its own thing
inline.

tests: Raw instances shouldn't stack-allocate on most targets.

  * We possibly should be testing to make sure that they /do/
cons, but we can live with not having an expected failure
message for a situation that would take a lot of careful work
on the compiler and GC to improve.

DX structs with raw slots only allowed on conservative gencgc.

  * Unless the control stack is conservatively scavenged, any
unboxed data could lead the GC to either corrupt the stack,
corrupt the heap, or just die screaming.

  * Thus, all unboxed data must be stored on the number stack
on such systems.  However, the number stack isn't scavenged
for boxed data, so we can't store any object that contains
both boxed and unboxed words if the unboxed words can appear
to the GC as anything other than a FIXNUM (thus, aligned
pointers are safe to store on the control stack).

  * All INSTANCE objects have a boxed slot, the LAYOUT slot.
If an instance also has raw slots then it cannot go on either
stack, and must be heap-allocated.

  * And none of this applies if the stack is conservatively
scavenged, which means (and gencgc c-stack-is-control-stack).
On such targets, we can dump whatever we want to the control
stack, and the GC won't complain at all.

Fix build on non-GENCGC targets.

  * Commit 8ee61a7761181511d15690246eb52d100e233935 introduced a
function with a parameter that is only used on gencgc targets.
Declare it to be ignored on non-gencgc targets.

x86: Better disassembly of segment-prefixes.

Thanks to Alastair Bridgewater who originally provided these changes
(and the headline above). I adapted his work to fit into the prefix
instruction infrastructure now available. Of his original comments
the following three still apply:

  * Establish a SEG prefix for segment overrides similar
to the X66 data-width prefix.

  * Have the SEG prefilter set an instruction property
for the specific segment being used.

  * Alter PRINT-MEM-ACCESS to output a suitable prefix
for memory addresses when the appropriate instruction
property has been set.

I have abstracted out the segment prefix printing into the new function
MAYBE-PRINT-SEGMENT-OVERRIDE, called from PRINT-MEM-ACCESS, not to make
the latter more lengthy.

Here is an example to show the difference in disassembler output:

Old:

;      0E6:       64               FS-SEGMENT-PREFIX
;      0E7:       8910             MOV [EAX], EDX
;      0E9:       64               FS-SEGMENT-PREFIX
;      0EA:       8B0528000000     MOV EAX, [#x28]

New:

;      0E6:       648910           MOV FS:[EAX], EDX
;      0E9:       648B0528000000   MOV EAX, FS:[#x28]

Improve handling of x86[-64] prefix instructions in the disassembler.

Make LOCK, REP, REX and #x66 true prefix instructions on x86[-64].
This changes only the disassembler part of the instruction definitions;
with respect to assembly LOCK already was a true prefix instruction and
REP/REPE/REPNE remain instructions in their own right.

Delete the scores of instruction formats and printer clauses that are
made obsolete by this change. Two printer clauses are still needed for
each of those SSE instructions that use the REX prefix in an infix
position.

An example of the changes in the disassembler output (on x86-64):
Old:

;     5FFC:       F0               LOCK
;     5FFD:       480FB171F9       CMPXCHG [RCX-7], RSI

New:

;       4C:       F0480FB171F9     LOCK CMPXCHG [RCX-7], RSI

Corrections to disassembly of SHLD, SHRD and LEA on x86[-64].

The double shifts were wrongly matching the bit pattern of some CMOV
variants. Corrected by using another instruction format on x86-64 and
by adding a constraint on the WIDTH field on x86. This made it possible
to enable the variant with an immediate shift count. On x86-64, changed
the maximum immediate shift count from 31 to 63.

Also, on x86-64, one of the printers for LEA was missing a WIDTH field
restriction, thus wrongly matching a "MOV to segment register", too.

Make some disassembler parameters effectual.

In the context of changing the treatment of prefix instructions in the
disassembler I came across somewhat broken code to parametrize it.
This might as well be repaired, so:

Correct the calculation of the DSTATE's ARGUMENT-COLUMN which is
intended to set a minimal field width for the opcode column. It needs
to take *DISASSEM-INST-COLUMN-WIDTH* and a few more column separators
into account. So as not to confuse users, restore the previous behaviour
by setting *DISASSEM-OPCODE-COLUMN-WIDTH* to 0.

Don't emit instruction bytes when *DISASSEM-INST-COLUMN-WIDTH* is 0.

Whitespace correction in ALIGNMENT-HOOK.

Playing with these two parameters allows to select different disassembly
formats (example from x86-64):

Current:

;      E11: L7:   4881FB17001020   CMP RBX, 537919511
;      E18:       0F8480000000     JEQ L13

(setf SB-DISASSEM::*DISASSEM-INST-COLUMN-WIDTH* 0)

;      E11: L7:   CMP RBX, 537919511
;      E18:       JEQ L13

(setf SB-DISASSEM:*DISASSEM-OPCODE-COLUMN-WIDTH* 8)

;      E11: L7:   CMP     RBX, 537919511
;      E18:       JEQ     L13

Make the disassembler understand instruction prefixes.

Instructions having NIL as their printer are treated as prefixes,
meaning that they are printed on the same line as the following
instruction. If an instruction's PRINT-NAME is NIL, too, this prefix
is not printed (but prefilters etc. are run). Any number of prefix
instructions can occur in immediate succession before a non-prefix
instruction.

This commit only provides the infrastructure; its impact is currently
limited as there aren't any instructions having NIL as their printer.

The motivation for this change comes from x86[-64]: One goal is to make
instructions using prefixes like LOCK and REP print nicer, the other
to reduce the combinatorial explosion of instruction formats in the
disassembler that is currently needed to deal with the possible
combinations of the REX and the operand size override (#x66) prefixes
and that would become unbearable once the aforementioned and the segment
override prefixes are added.

Extend the existing beginnings of support for prefix instructions in
MAP-SEGMENT-INSTRUCTIONS to collect prefix names and to print them at
the right time, which is at the next non-prefix instruction, when a
non-decodable instruction is encountered or at the end of the segment.
Change the semantics of DSTATE-INST-PROPERTIES: This list is now emptied
only after a non-prefix instruction has been processed.

Abstract out the filling of the column containing the instruction bytes
into the new function PAD-INST-COLUMN and use it in several places.

Clean up whitespace and improve line breaks.

Fix EQL constraint propagation on constant assigned closure variables

 * Constant lvars can now be references to assigned-to closure-
   converted lambda-vars, which don't have consets.  Just always use
   lvar-value, at the cost of a slight potential slowdown due to more
   calls to find-constant.

   Reported by Eric Marsden on sbcl-devel.

 * Also, canonicalize whitespace in dynamic-extent tests.

 Fixes lp#903838.

(NO-CONSING SPECIALIZED-DX-VECTORS) fails on sunos/x86.  Mark this.

protect against read-time package-lock circumvention from LOCKED::(BAR)

  Instead of binding *PACKAGE*, bind *READER-PACKAGE* which only
  affects the package READ-TOKEN interns into in the absence of a
  prefix.

  lp#902806

remove etags as a build-time dependency

  Do try to build TAGS by default, but if etags isn't there, don't
  make a fuss.

  lp#903145

Fix clisp-hosted build.

stack-allocatable fill-initialized specialized arrays, take 2

  Really fix lp#902537.

  Turns out multiple references to the stack allocated vector complicate
  things /just/ sufficiently the that DX machinery can't keep up. (I because
  the code that allocates and initializes the vector isn't substituted at the
  use-site due to multiple references.)

  While it would be nice to make it smart enough to deal with
  non-let-converted WITH-ARRAY-DATA, that looks a bit tricky... so instead
  simplify things in the FILL transform when the vector is a simple-array.

faster VECTOR-SUBSEQ*

  Use a WITH-ARRAY-DATA to get to the underlying vector, and use a widetag
  dispatch table to pick the correct SUBSEQ implementation for the underlying
  type.

  This is actually just as fast even for simple strings as STRING-SUBSEQ*, so
  throw it out.

  Also make inlining SUBSEQ conditional on SPEED > SPACE now that the
  out-of-line version doesn't suck so much.

  Fixes lp#902537.

stack-allocatable fill-initialized specialized arrays

 I *think* we had this working earlier already, but it's been broken at least
 for a while now since there were no tests for it.

 Add a DEFKNOWN to the array byte bashers, providing the RESULT-ARG -- and
 make them return the sequence.

 Replace the unused and bitrotted UNSAFE IR1 attribute with its inverse:
 DX-SAFE, and use that togather with RESULT-ARG to allow multiple refs to
 potentially DX leafs. Still accept UNSAFE in DEFKNOWNs occurring in
 user-code, but ignore it and give a style-warning.

 For now, add DX-SAFE to LENGTH and VECTOR-LENGTH, which is enough for our
 purposes.

 Fixes lp#902351.

remove MUFFLE-CONDITION from the FILL transform

  It hides failure to stack allocate results of a MAKE-ARRAY with non-zero
  initial-element and non-T element-type.

  Part of lp#902351.

make DESCRIBE report IR1 attributes for known functions

fix errors from stack allocation compiler notes

  AKA, error reporting is hard.

WITH-SPINLOCK compatibility layer was broken

  Copy-paste damage from WITH-RECURSIVE-LOCK, looks like.  We don't have a
  WITH-LOCK and never did, should be WITH-MUTEX.

refactor FOP table and stack handling

 Just two special variables *FOP-TABLE* and *FOP-STACK*.

 Both hold a simple-vector, whose first index holds the index of the last
 element. These are always freshly allocated -- no more *FREE-FOP-TABLES*
 dirtying up the old generations.

 Define a semi-opaque interface for manipulating the stack and the
 table. (Mainly replacing explicit SVREF's with REF-FOP-TABLE.)

 ...and lo! Our fasl-loading speed sucks 5-10% less.

delete *FASL-SYMBOL-BUFFER*

  Instead allocate the right-sized string every time, and add
  :NO-COPY option to INTERN* and use it in AUX-FOP-INTERN to
  avoid copying when interning.

rename FOP-INTERN AUX-FOP-INTERN for clarity

  ...so as not to confuse it with actual FOPs.

use FAST-READ-BYTE in LOAD-S-INTEGER

  No reason not to.

optimize READ-STRING-AS-[BYTES|UNSIGNED-BYTE-32]

  Use FAST-READ-BYTE / FAST-READ-U-INTEGER, and add a separate
  READ-BASE-STRING-AS-BYTES.

  This actually makes a difference in FASL-loading speed.

easier to read FAST-READ-U-INTEGER expansion

FAST-READ-BYTE refactoring

  Change PREPARE-FOR-FAST-READ-BYTE into WITH-FAST-READ-BYTE.

  DONE-WITH-FAST-READ-BYTE is gone.

  FAST-READ-BYTE is a local inline function instead of a macro.

Make COERCE on characters more standard-conforming.

Characters could be coerced to subtypes of CHARACTER to which they
don't belong. Also, character designators that are not characters
could be coerced to proper subtypes of CHARACTER. Make all of these
instead signal an error as required by CLHS COERCE.

Add test cases, both for unicode-enabled and non-unicode-enabled SBCL.

Fixes lp#841312.

Add tools-for-build/determine-endianness to .gitignore.

  * Nothing more need be said.