Allow careful use of available machine registers in RTL.

This will enable us to put fixed machine registers such as the value
register carefully into the RTL even if they are ordinarily available
as pseudo-register aliases for machine register allocation.

- CGEN-RINST calls TARGET-MACHINE-REGISTER! if the target of an RTL
  instruction is a machine register that is ordinarily available for
  register allocation.

- REGISTER-ALIAS declines to return any aliases reserved by
  TARGET-MACHINE-REGISTER!, until...

- DELETE-DEAD-REGISTERS! makes the target machine registers available
  again for REGISTER-ALIAS so that they can be chosen as targets.
  (However, they still won't be chosen as temporaries.)

- MOVE-TO-ALIAS-REGISTER! -- which may be used only after all other
  source registers have been chosen -- also allows the machine target
  to be used as a source alias in order to avoid unnecessary register
  motion.

- Don't propagate RTL references to available machine registers in
  common subexpression elimination or in code compression.

  Since the machine register might be allocated as an alias for another
  register, it can't be moved around.  The RTL generator ensures these
  references appear only at the beginning or end of a block where the
  machine register cannot be an alias for any live pseudo-register.

Ensure register:value appears first or last in block.

Either it is the first register referenced, or the last register
assigned.  This will enable us to use a machine register that is
normally available for register allocation, without having to worry
that it may be an alias for a live pseudo-register.

- In continuations that receive a value through register:value,
  create a temporary register and make the first instruction be an
  assignment of register:value to the temporary register, before we
  the pop-extra.

  The RTL optimizer avoids propagating this alias so the assignment
  will stay in place, but later on, the LAP generator will take
  advantage of the alias to avoid generating additional unnecessary
  code.

- In returns that store a value in register:value, create a temporary
  register and assign it where we used to assign to register:value,
  and then store the temporary in register:value as the very last
  instruction before pop-return after any frame-popping which might
  involve temporaries.

Optimize execute caches: avoid indirect jumps if possible.

No change to the compiled code interface: this just generates faster
code in execute caches if it can.

Generate per-invocation jmp instructions.

I hypothesize that this will help the CPU's branch target predictor
be more precise than having a single jmp instruction inside an
assembly hook that actually jumps to an unknown procedure.

Empirically, this gives about 5x speed improvement for a
microbenchmark involving unknown procedure calls:

(define x (make-vector 1))

(define (test-01 x)
  (define (g)
    (vector-set! x 0 0))
  (g)
  ((identity-procedure g)))

(define (test-10 x)
  (define (g)
    (vector-set! x 0 0))
  ((identity-procedure g))
  (g))

(define (repeat n f x)
  (show-time
   (lambda ()
     (do ((i 0 (fix:+ i 1)))
         ((fix:>= i n))
       (f x)))))

; Before:
(repeat 10000000 test-01 x)
;process time: 1420 (1370 RUN + 50 GC); real time: 1427

; After:
(repeat 10000000 test-01 x)
;process time: 290 (220 RUN + 70 GC); real time: 312

Caveat: This is on top of a bunch of other experiments.
XXX Redo this in isolation.

WARNING: This adds hooks to the amd64 compiled code interface, so new
compiled code requires a new microcode.  (However, a new microcode
should handle old compiled code just fine.)

Use CALL/RET for pushing and returning to continuations on amd64.

Calls now look like:

  ;; (assign (register #x123) (cons-pointer tag (entry:continuation cont)))
  (CALL (@PCR pushed))
  (JMP (@PCR cont))
pushed:
  (OR Q (@R ,rsp) (&U ,tag))
  ...
  (JMP (@PCR uuo-link))

Returns now look like:

  ;; (pop-return)
  (AND Q (@R ,rsp) (R ,regnum:datum-mask))
  (RET)

These should happen in pairs, so that we can take advantage of the
CPU's return address branch target prediction stack rather than
abusing the indirect jump branch target predictor.

WARNING: This changes the amd64 compiled code interface, so new
compiled code requires a new microcode.  (A new microcode might be
able to handle existing compiled code just fine.)

Split compiled entries and compiled return addresses.

Reallocate tag 4 for return addresses.

This way, a compiled entry can be a pointer to a PC offsets so that
we can construct closures without dynamically generating code and
wrecking the instruction cache, while a compiled return addresses can
be a pointer to a PC, since we never dynamically create indirections
for returns.

For now, the runtime can handle both tags for return addresses.

XXX Only done and tested on x86-64 for now.  Other architectures need
to be tested.  Might be worthwhile to do this on i386 too, if anyone
still cares about i386.

WARNING: This changes the compiled code interface on all
architectures, so you'll have to build a new compiler running on an
old microcode and use that to compile a new system afresh.

Use indirection for entry points on amd64.

A compiled entry is now a tagged address A pointing to a 64-bit word
W such that A + W points to instruction to execute.

This adds a memory indirection overhead to unknown procedure calls,
but it has the effect that consing a closure only involves writing
data memory, not instruction memory that must be reloaded into the
CPU's instruction cache.

WARNING: This changes the amd64 compiled code interface, so you'll
have to build a new compiler running on an old microcode and use that
to compile a new system afresh.

Avoid CALL without RET for closure entries, hooks, and trampolines.

This will wreck the CPU's return address branch target predictor.

This is an intermediate change en route to using paired CALL/RET for
continuation pushes and pop-returns in order to take advantage of the
CPU's branch target predictor.

WARNING: This changes the format of compiled closures, and as such,
new compiled code requires a new microcode and vice versa.

Eliminate return/entry compiled invocation pun.

There is a small cost to this.  My hope is that it will be offset by:

1. distinguishing compiled entries from compiled return addresses, in
   order to enable...

2. using indirection for compiled entries so closures don't need
   dynamically generated code, and finally...

3. using direct instruction addresses for compiled return addresses
   so we can exploit the return stack branch predictor,

which all requires this change in order to function correctly.

No change to compiled code interface intended.

Use ln -n to avoid following symlinks to directories.

Evidently -h is the BSD option for `don't follow symlinks', following
the convention of chmod and other utilities, while -n is the GNU
option; fortunately at least NetBSD ln has had -n too for GNU
compatibility for decades so I'm satisfied with -n.  (Neither one is
POSIX.)

Allow hyphenation of log-probability, log-logistic, ill-conditioned.

Can't find a good way to make TeX hyphenate a word that already has a
hyphen in it, so this'll have to do.

Clarify error amplification.

Fix punctuation in display.

Avoid Unicode in texinfo.

Modern LaTeX can handle it but texinfo can't.

Add missing definition of exact as noticed by GJS.

Also update the text of inexact and exact to match R7RS.

Fix thinko in previous change.

Change write to use datum labels only when cycles are present.

This is required by R7RS but was not understood earlier.

Implement bundle delegation using a more general combinator mechanism.

Need to load sf before host-adapter.scm these days, it seems.

Avoid bash.

bash is not reliably available, and on the systems where it is
available, it is often not installed at /bin/bash.

Fix reading hashed object notation #[foo 123].

Test hashed object notation.

Currently busted for #[foo 123].

x11-screen: Fix cut/paste after upcasing X atom names.

Do not install non-existent runtime options hashtb and krypt.

x11-screen: downcase symbols, most names; fix copyright notices

x11: downcase symbols, most names; fix copyright notices

pgsql: downcase symbols, most names; fix copyright notices

mcrypt: downcase a symbol, most names; fix copyright notices

gdbm: downcase symbols, most names; fix copyright notices

blowfish: downcase symbols, most names; fix copyright notices

ffi: downcase symbols, most names

Add pgsql-shim.h as a dependency of pgsql-shim.la.

Punt CREF's 9.2-compatible deprecated exports syntax.

Drop support for the awkward, undocumented and hopefully unused
EXPORT-DEPRECATED syntax too.

Fix definition of MIT_SCHEME_PKD; use _OS_SUFFIX from src/configure.

Edwin/Makefile.am: Include sources.scm.  Punt unnecessary overrides.

Plugin builds: Improved tags-fix.sh.  Handle .cdecl files specially.

Plugin builds: Add adapter.c to _shim_la_SOURCES, not _LIBADD.

Plugin builds: Use MIT_SCHEME_PKD, not MIT_SCHEME_OS_SUFFIX.

Plugin builds: Do not include generated -const.c in dist.

Plugin builds: Restore dependence of stamp-scheme on -const.bin.

The stamp-scheme target builds -types.bin, not -const.bin.  The
-const.bin comes from plugin-const.scm which comes from ./plugin-const
which comes from -const.c which is a product of stamp-shim.

Silence autogen.shs when plugins are built separately.

mcrypt/Makefile.am: typo

Add subprocess-binary-i/o-port.

Plugin Makefile.am improvements.

These were backported from recent improvements to x11/Makefile.am.

  + Use EXEEXT where appropriate.
  + Add MOSTLYCLEANFILES and mostlyclean-local.
  + Use TAGS_FILES and punt the ETAGS_ARGS misuse.
  + Add -adapter.lo to _shim_la_OBJECTS, not _shim_la_LIBADD.
  + Eliminate trailing whitespace.
  + Correct the copyright notices for x11 and x11-screen.
  + Punt stamp-scheme's dependence on -const.bin (redundant to the
    dependence on stamp-shim).

Silence autogen.shs, which blabber error messages (to Emacs's eye).

gdbm: Downcase constants to match case in package descriptions.

Change symbol<? to delegate to bytevector<?.

This is much faster than string comparison, which matters since symbols should
be fast.  The downside is that symbols and strings will sort somewhat
differently, but that shouldn't matter since someone can always sort them using
symbol->string.

Implement bytevector<?.

Don't unread #f as if it were a character.

Edwin: force subprocess I/O ports to use iso-8859-1 coding.

There may still be a problem with synchronous subprocesses, since we don't have
a way to get at those ports.  If the process writes UTF-8, then the I/O copier
will try to write unicode chars to a buffer, and I'm not sure what will happen
in that case.  It might just ignore the upper bits.

Treat keyword-only syntax environments differently from runtime environments.

The former are those created by let-syntax and the like; the latter are models
of runtime environments as created by lambda.

This fixes a bug when let-syntax contains a bunch of definitions, which should
be defined in the parent environment of the let-syntax, because it's meaningless
to define them in the let-syntax environment itself.  This was previously worked
around by heuristic means, but this change makes the definitions appear in the
correct syntactic environment corresponding to the runtime environment.

Implement a delegation protocol for bundles.

Fix stupid typo in reader.

Fix screw-up in previous host-adapter change.

Eliminate unused variable from typo.

Fix a bunch of problems caused by the call-with-values/values change.

First, SF was open-coding these, so that the compiled code wasn't using the new
convention.  This caused problems at the boundary between interpreted code and
compiled code, and of course the compiled code was now incorrect.  This is fixed
but requires stuff in host-adapter to make it work.

Second, eliminating the open-coding exposed a couple of places that would no
longer initialize correctly during the cold load because they were initialized
prior to the loading of the multiple-values procedures.  This is fixed by
rewriting those to not use multiple values and have been marked with comments.

Finally, because the host-adapter file is now changing SF, SF must be loaded
prior to loading the host adapter.  There was one case in the make file that
needed to be tweaked to make this guarantee.

Don't choose the flo:+inf.0/flo:-inf.0 implementations at cold load.

This is wrong because in our public distributions, the cold load is done on
Ubuntu, but the code is supposed to run on any appropriate unix system.

The fix is to make the selection when the band is restored, guaranteeing that
it's running on the target system.

Add procedure-arity-intersection.

Change multiple-value return to be slighly closer to correct.

It's never going to be correct, but this at least permits mixing single values
and multiple values a bit.

Don't use +inf.0 because it throws an exception on macos.

This will need to be fixed but right now it prevents compilation.

Plot the new math functions and their condition numbers.

Plots are done purely in PostScript, so no additional tools required
on top of the existing PostScript/PDF stack we essentially already
depended on.  Plots are cubic spline interpolations computed by a
little automatic differentiation library in PostScript.

Fix some mistakes in the prose characterizations of the condition
numbers that I had written.

Fix typo.

Clarify the non-significance of the total ordering.

Tweak some text strength.

Don't call NaN a number.

Fix pasto.

Flesh out an example and fix a typo.

Add flo:signed-lgamma.

Note a few more flonum operations.

Update random number generation section of manual.

Use a trailing 0 for text clarity.

Document floating-point environment, exceptions, rounding modes.

Update documentation for floating-point operations.

Fix flo:ulp on NaN.

flo:ulp is busted on NaN.

Document copysign.

Couple more logsumexp tests.

Document some loggy numerical functions.

Repair mistakes in proofs of some error bounds.

While here:

- Spell out some magic constants.
- Handle and test some edge cases in log1pexp and log1mexp.
- Paginate.

Expect some failures to signal errors on fp exception traps on arm64.

Fix calls to read-bytevector! that weren't aware of EOF values.

Add "adapters" to list of source files.

Suggest use of macOS command line developer tools rather than Xcode.

Update make-upload-files to new version.

Fix incorrect edit.

Teach reader to find and respect "coding" attribute.

This allows a file to override the default utf-8 coding.

Make sure that ports use ISO 8859-1 coding.

Modify CREF to show references to inherited bindings.

This will help track down which parts of the string abstraction need to be
replaced.

lisppaste is dead.

Fix bug that caused redrawing whole display on paren flash.

Hold strong reference to message header while writing summary line.

This way the GC won't be inclined to eat it from under us when we're
just going to parse it again in a moment for the date or subject.

Tighten encode-cache-namestring.

Use channel I/O directly for file->string and string->file.

Here a string is an octet sequence, always in US-ASCII or UTF-8, so
we don't need the rigmarole of text I/O.

Make number of topmost frames with expressions shown configurable.

Use the Edwin-private %string-append.

No need to pay the cost of wide stuff with string-append*.

Let SIGALRM do its thing even if we're on the right millisecond.

If we request a timer interrupt now in logic that closes a lot of
files, which runs through %deregister-io-descriptor, it looks like
_all_ the time is spent in closing files even if it's merely the case
that at least one file is closed every millisecond.

If we instead let SIGALRM do its thing, unless the interrupt is
_overdue_, then the profiler can discriminate at sub-millisecond
resolution where the time is spent which is what I really want.

Line break between #; and multiline expression.

Otherwise Emacs gets confused.

Use number->string directly; skip dispatch through write-to-string.

Block interrupts, _then_ lock.

Otherwise an interrupt might try to acquire the lock while we already
hold it, leading to deadlock.

Rework profiler to be more useful.

Just make a histogram of stacks and print that.