Disable constant-folding machine-dependent primitives in LIARC.

These are not valid across word size changes, but LIARC does not
expose compiler:cross-compiling?.

One more round of rework for LIARC.

Keep the host actions and target actions separated by a stamp file as
with other cross-compilation.

Name the targets:

- cross-host does the actions on the host (some day, all of them),
  and creates stamp_cross-host

- cross-target does the actions on the target, which all depend on
  the host actions only through stamp_cross-host

- all does cross-host and then cross-target.

With any luck, this should preserve the behaviour of non-cross
builds.

Still missing: Makefile.tools doesn't work _from_ a system with LIARC
yet to cross-compile, because we have no way to build a fresh runtime
or create bundles outside the standard build.

=> We should not depend on a full fresh runtime, only on the macros.

=> We should have a way to link bundles.  (For that matter, we should
   have a notion of shared libraries that can be loaded independently
   and with shared read-only physical memory, rather than as a bodgy
   sequence of bands copying the data around.)

Fix bug: characters with bucky bits not printing right.

Avoid WRITE in URI->STRING.

We use this early on in loading an image -- before we have
initialized all the LIARC objects (indeed, in the course of
initializing LIARC objects), which may themselves have predicates in
the print method dispatcher.

Restore printing strings in #[uri ...].

Simplify pathnames for conversion to standard URIs to avoid dottiness.

Use intermediate stamp for compinit.[ch] to avoid parallel clobber.

Update liarc to modern debugging info/wrapper formats.

Fix up makefile targets for liarc.

NUL-terminate bytevectors too.

This shouldn't be necessary but we use these for primitive names with
routines that expect them to be NUL-terminated, so this is more
convenient until we either length-delimit the primitive names or
explicitly NUL-terminate them or whatever.

Atomic write-to-temporary/rename-to-permanent so liarc is ^Cable.

Use load-option so we get the LIARC bundle.

Disable cross-compilation finishing stage for liarc.

Don't build microcode in cross-host; build in cross-target.

Suppress uninitialized variable warnings.

GCC is easily confused by the code we generate.

Compile and link liarc objects as shared with no fatal warnings.

Need to wait for runtime to compile before building liarc ucode.

Teach stackify about bytevectors.

XXX Really it should use bytevectors as the basic type now, and we
should teach it about strings, but this is more expedient since it
was written when string == bytevector and mostly this works out.

Teach the makefile how to make the .pkd files for liarc rules.

Avoid compiler:cross-compiling? in liarc.

Fix typo: SOS_BUILD_TARGETS, not SOS_TARGETS.  Actually build SOS!

Convert to SCHEME_OBJECT * first before subtracting membase.

This system (with or without the change) requires all addresses that
are tagged to be word-aligned, which expands the address space by a
factor of four on 32-bit systems, but means we can't tag pointers to
unaligned instruction addresses.

This means that i386 compiled code won't be able to take advantage of
membase, but it can't anyway without changes to the compiler, which
doesn't know about membase as is.

However, this _also_ means that multiclosures in SVM won't work
because only the first entry (and every four or eight entries) is
guaranteed to be word-aligned.  We could address this by aligning the
entries, and maybe remove the ENTER-CLOSURE instruction overhead by
using indirection for entries like riastradh-20181220-closentry-v3
does for amd64.

(Don't want to change CC_ENTRY_NEW_ADDRESS or anything because
there's an outstanding branch that changes them already for other
reasons.)

Fix dependency ordering.

Isolate directories for clean-compiler rule.

Don't hang in non-parallel makes waiting for input.

Fix stray backslash that was harmless without LIARC.

Rework makefile to use intermediate variables, not rules.

This gives the opportunity for the variables to be files, not phony
rules, to limit rebuilds.  Disadvantage: must be written in
dependency order because make expands variables in dependencies as it
reads them, not lazily.  But this reduces the size of the makefile
quite a bit.

Use stamp_tools to trigger (incremental) rebuild of toolchain.

Rewrite printing of #[...] forms, for simplicity now and later for sharing.

In order to properly implement datum labels for things inside of bracketed
forms, we need to be able to walk the items that are being printed there.
Previously this would have been very difficult since the insides of these forms
were printed by custom printers.  Now they are exposed as individual objects
that can be walked.

Further work is necessary to include these objects when walking the tree.

Integrate PROMISE?.

Small but measurable speed improvement, getting to diminishing
returns after a nearly 7x speed increase on promise-heavy stream
code.

Try EQ? first before the passed-in equality procedure in MEMV &c.

- EQ? must imply the passed-in equality procedure anyway.
- EQ? is open-coded and quick.
- MEMV turns up hot in profiles of the compiler.
- Small but measurable performance improvement compiling the tests.

Integrate GUARANTEE.

For this to be effective, SF makes the assumption that predicates do
not modify their own definitions, like

(define (foo? x) (set! foo? (lambda (x) x #f)) #t)
(guarantee foo? 42)

Such is the depravity of arbitrary side effects not represented in a
type system...!

Fix format words generated by svm1 compiler for internal procedures.

Continuation parser relies on the next-continuation-offset for
internal procedures in interrupt frames.

Configure outcome should not depend on whether lib/all.com exists!

This meant you got a different (and broken) build if you simply reran
configure, which is awfully confusing.  Now we use the native release
marker to change the default behaviour of configure reliably.

What idiot did this, git blame?  ...oh.

Regenerate configure if out of date, not just if nonexistent.

gitignore cross objects and Makefile.tools.

Clean .nib, .ext, and .dkp too.

Rework makefile for cross-compilation with a toolchain again.

We use Makefile.tools only if --enable-cross-compiling is true.
Everything it builds goes under tools/, or should if there are no
bugs -- even intermediate .bin, .com, &c., files.

New usage model does not require any external trees:

% ./configure --enable-cross-compiling --enable-native-code=i386
% make cross-host

% make all

However, the host must be a recent master with new CREF and SF
features for separate source and object roots, so we can't rely on
this to work until we cut a new release with those features.

(It shouldn't be necessary to run _anything_ on the target system,
but we're a ways away from that: we need the cross-compiler to be
able to cope with macros across subsystem dependencies, and we need a
`static' linker, not just a fasloader-and-disk-save.)

Generate the trivial constructor in the objdir, not srcdir.

Define cref/source-root and cref/object-root in host-adapter.scm so
we can still load compiler.sf into old Schemes, which will never have
this distinction.

Teach cref and sf about separate source and object directories.

Expose fasl-format:x86-64 as another name for the amd64 format.

Relevant because MIT_SCHEME_NATIVE_CODE gets set to x86-64, and gets
plopped into `fasl-format:@MIT_SCHEME_NATIVE_CODE' in the makefile.

Change identify-world to show a very brief summary.

* Remove versions from all of the subsystems, except the release.
* Remove microcode and runtime subsystems entirely.

Generalize list-like printing, and support list-breadth limit properly.

Clean up wording around bitless characters.

Remove unused and unexported guarantee-FOO procedures.

Change most places that use bitless-char? to just throw away the bucket bits.

Do the annual copyright update.

In update-copyright, replace use of old regexp with regsexp.

Also adjust the various filename patterns to reflect the current directory
structure.

Clean the compiler subdir too.

Allow alist->bundle to accept #F as predicate.

Also beef up bundle tests a bit.

Fix problem with using bundle? as a bundle predicate.

New printer parameter param:print-hash-number-in-objects?.

Use dispatch-tag-print-name.

Export dispatch-tag-print-name for convenience.

Eliminate obsolete comment from user manual.

Save file used to test gc table correctness.

Detect trivial infinite recursion in promises.

Obviously this can be fooled, like

(force (let loop () (delay-force (loop))))

or any non-halting Turing machine, but this is an easy case to detect
with negligible cost.

Test detectable screw case of delay-force infinite recursion.

Integrate %promise-parts.

Shaves another 20% off time for test-promise.scm.

Use another indirection for representation of promises.

The pairs never change, so merely loading the pair object from the
cell indirection gives us an atomic snapshot of it.  This way, there
is no need for without-interrupts in promise-forced?.

This makes each promise cost one more word (previously: one word to
represent plus three words of heap space; now one word to represent
plus four words of heap space), but reducing without-interrupts is a
big win -- this halves the time of test-promise.scm on my machine.

Of course, on a parallel system, the without-interrupts in %force is
still not enough (and we'll need the cell-contentses to be
load-acquire operations, not just loads).

Fix nested promises.

Add promise tests. Nested promises are busted.

Open-code cell operations.

Restore sf predicates, not scode predicates.

Various parts of sf were silently disabled in the overly aggressive
change

   commit 816b9122751c9b60b85f9ce3db0df8a516f763cb
   Author: Chris Hanson <org/chris-hanson/cph>
   Date:   Wed Jan 24 00:07:59 2018 -0800

       Greatly simplify SCode abstraction and change names to contain "scode".

       Also remove all FOO-components and FOO-subexpressions procedures.
       More work remains: the lambda abstraction is an unholy mess and needs to be
       cleaned up.  The scan-defines stuff also merits some consideration.

which kinda reflects on the sensibility of using disjoint type
predicates across domains like this as one does in Scheme.

Merge branch 'cross-fasdump-v2'

- Introduces a portable fasdumper that the compiler can use for
  cross-compiling.

- Adapt the build system to use it.  This form is not final: we
  should really be using GNU configure's build/host/target form.

- Fix up the i386 back end, particularly floating-point stuff.

- Split svm1 into four architectures: svm1-32be, svm1-32le,
  svm1-64be, svm1-64le.  This way you can, e.g., use your x86 laptop
  to cross-build an svm1-32le system to run on an arm32 machine.

- Various minor other fixes for cross-compilation.

Use integrated %dispatch-tag-ref in record type predicates.

These show up hot in profiles, so this makes a difference.

Integrate string.scm operations in symbol.scm.

Integrating, e.g., cp1-ref makes a huge difference.

Tweak equality-predicate-property to accept a default-value argument.

Don't use general predicate relations for record predicates.

Merge branch 'master' of git.sv.gnu.org:/srv/git/mit-scheme

Fix problem with crashing in Emacs interface.

Use runtime's string ports.

Also read file in one swell foop, rather than character by character
in a slow painful chain of indirections thousands of times slower.

We'll use legacy strings here because this code was all written under
the assumption that `string' meant byte vector, and legacy strings
still have that semantics.

Eventually this should all be adapted to use bytevectors instead for
storage, and interpret things as strings only as necessary for text
processing beyond mail data formats.

Implement position for string input ports.

Export binary-port-length too.

Fix binary-port-position for output ports.

Not sure if it'll DTRT for combined i/o ports; need more tests!

Export binary-port-position and set-binary-port-position!.

Currently busted for output ports.

Integrate string operations for order of magnitude speedup.

ucd-slc-value &c. return chars, not fixnums.

Use 32-bit xor rather than 64-bit xor for zeroing.

Split deeply nested expressions into named and typed temporaries.

No functional change intended, just makes stepping through with a
debugger easier.

Fix misparenthesization.

Confirm that a couple screw cases in closure analysis work.

Once upon a time the Y combinator and U combinator would crash the
compiler.  It's been fixed now but let's at least immortalize the
code I had lying around that crashed it so it doesn't happen again.

Add some more release notes.

Fix whitespace change ignored by magit.

Move .dir-locals.el from src/ to top level dir.

Split test data out of "test-string-normalization".

Convert char to unsigned char before using islower/toupper.

Failure to do so is undefined behaviour for any negative char values.

Use push with memory reference on i386 too.

Move comment to cover all the primitives disabled for this reason.

Open-code unordered comparison primitives on i386.

Mark some more primitives as machine-dependent and thus non-foldable.

Exclude exceptions not in FE_ALL_EXCEPT.

Some buggy libms omit some FE_* from FE_ALL_EXCEPT, apparently, oops.
When they cease to be relevant to me we can remove this.

Make primitives raise exceptions on  signalling NaN too.

Fix mistaken expansion of flo:<> as flonum-is-less-or-greater?.

Global flo:<> is the ordered version, which raises exception on qNaN;
primitive flonum-is-less-or-greater? is the unordered version, which
returns false on qNaN.

Test ordered and unordered comparisons with sNaN raise exceptions.

Normalize significand in flo:random-unit-open even on 32-bit.

Fix sign error and mask size in fix:bitcount16.

Avoid undefined behaviour with large right shifts.

Shift-right is busted on large shifts.

Disable FLONUM-EXP open-coding on i386.

The instruction sequence we had was not very good, e.g. (exp -708)
was off by far more than 1ulp.  It can be done that way, but we need
to use 64-bit precision for it, and setting the i387 precision here
is getting a bit far afield from open-coding.

Relax expm1 tests; i387 in 53-bit precision won't guarantee 0.5ulp.