Simplify flo:-inf.0 and flo:+inf.0.

We have put out a release now whose reader understands +inf.0/-inf.0,
so we should be able to use the notation.

Fixes bugs with incorrectly raising the divide-by-zero exception flag
(even if no trap), e.g.:

;|log1mexp-invalid/(4.9406564584124654e-324)| failed 1 sub-tests out of 1 in 0. seconds:
     assertion 3: value was 3 but expected an object eqv? to 1

Here 3 = (invalid-operation divide-by-zero), 1 = (invalid-operation)
[aarch64].

Fix comment about odd rounding mode.

Add missing include guards.

Update and clarify fp-env documentation.

Simplify flo:update-environment!.

Caller is interested in exceptions afterward, so it is not sensible
to deregister interest in the floating-point environment afterward.
If you really want that, surround it in flo:preserving-environment.

Fix two bugs in floating-point environment.

1. Don't cache it in the current thread.

   We can't mark everywhere the cache needs to be invalidated --
   i.e., every floating-point instruction -- and it's not clear
   there's any performance benefit to the cache anyway.  The main
   performance cost, as I recall, was swapping environments on every
   thread switch, which we avoid for all threads in the default
   environment.

2. The default environment initialization left the machine in a wacky
   state after reset-package!, which caused many spurious exception
   traps once I undid the cache.  There's no need to preserve the
   machine environment here; we are setting up the default
   environment, after all, so the environment we're in when done
   should be the default one.

Test busted flo:set-environment!.

Fix multiplication and division by purely imaginary numbers.

That is, complex numbers whose real part is exact zero.

Test multiplication and division by +i and -i.

We do not currently follow Kahan's recommenations that when the real
part is exactly zero, the arithmetic be done by negation rather than
multiplication.

Fix edge cases in ANGLE.

Expand edge cases for ANGLE.

Based on Kahan's `Much Ado about Nothing's Sign Bit' paper.  We screw
up some zero edge cases.

Fix references incorrectly marked with EVR().

`x ... ...' is busted in syntax-rules.

Merge branch 'riastradh-20181220-closentry-v12'

Tweak logit1/2+ condition number plot for clarity.

Factor out common PostScript code for plotting.

Should make this a little more maintainable.

Uniform code and style for plots.

Tweak line widths a little bit to roughly match cmmi10 (Computer
Modern Math Italic 10pt) rule widths for axes, and a little thicker
for the plots themselves, for the printed manual.

Produce 300dpi, not 72dpi, PNGs for HTML output.

Use TLS/SSL for links to <srfi.schemers.org>.

Add release note.

Bump COMPILER_INTERFACE_VERSION.

Make attempts to use old .com files fail a little more obviously.

Set default target to all for cross-builds too.

No need to make it default to cross-host.  If you want to separate
the cross-host/cross-target stages, you'll know to do cross-host
anyway.

Avoid spurious fallthrough (fortunately harmless here).

Test fma exceptions too.

Add fma, fused-multiply/add.

Not yet open-coded anywhere.  Will be a huge pain on x86.  No aarch64
flonum open-coding at all yet.

(Maybe flo:fast-fma? should return false if it's not open-coded...)

Use a different reflect code number for compiled invocations.

Teach the continuation parser about it.

Turns out this doesn't actually coincide with the format the v8
microcode used for APPLY-COMPILED, which also has a frame size,
presumably so arity dispatch could be done in the callee.

(Not that the v8 stuff matters these days; maybe we should just flush
those parts of conpar.scm.)

Open-code WITH-STACK-MARKER too.

Saves a trip through reflect-to-interface, which would break the
return address branch target prediction stack.

Share closure interrupt labels.

The interrupt-handling subroutine just uses the tagged entry on the
stack, so no need for a separate call for each closure.  If nothing
else this should save some code size.

Also, in open-coding of with-interrupt-mask, reuse pop-return with
interrupt checks.

Tidy up compiler utility return addresses.

Use compiled returns for the ones that are likely to return to Scheme
like lookups and assignments, and compiled entries for the ones that
are likely to return to microcode like interrupts.

Architectures on which compiled entries and compiled returns have the
same format will see no difference: compiled code passes in an
untagged return address either way.

On amd64, where compiled entries and compiled returns are different:

- For hooks that act like leaf subroutines and never return to
  microcode, use plain CALL/RET in pairs.

- For hooks that are subroutines likely to return to Scheme
  immediately but might return to microcode in screw cases, use

        (CALL ,hook)                    ; Invoke hook with untagged ret addr...
        (JMP (@PCR ,continuation))      ; ...which jumps to formatted entry.
        (WORD ...)
        (BLOCK-OFFSET ,continuation)
        (QUAD U 0)
       (LABEL ,continuation)
        ...                             ; continuation instructions

  For the non-screw cases this keeps CALL/RET paired.

- For hooks that always defer to microcode, namely to handle
  interrupts, use

        (LEA Q (R ,rbx) (@PCR ,continuation))
        (JMP ,hook)

  Here it doesn't really whether the CALL/RET is paired because we're
  going to wreck the return address branch prediction stack no matter
  what, but it is convenient to have the entry address rather than
  the return address in the compiled utility.

Use ret for returns from interface and from generic arithmetic hooks.

Let's take advantage of the return address stack branch target
predictor rather than unceremoniously trash it, shall we?

Open-code with-interrupt-mask, with-interrupts-reduced.

Not open-coded at the RTL level, but at the LAP level.

This way we avoid going through a return trampoline, which wrecks the
return address stack branch target predictor as long as we transition
between Scheme and C to handle trampolines.

Most of the work, of munging MEMTOP and STACK_GUARD, is relegated to
an assembly hook subroutine so the code doesn't expand too much.  The
format of the stack still uses reflect-to-interface so that this
should require no changes to the continuation parser to get the
interrupt masks right, but with an intermediate empty-frame
continuation that actually calls the assembly hook and then pops
reflect-to-interface off.

Allow return_to_compiled_code to return to compiled entries.

The earlier compiled entry/return split left various utility calls
pushing compiled entries, rather than compiled return addresses, for
continuations on the stack -- notably interrupt routines, the linker
utility, and interpreter calls.

I arranged for these to all to use RETURN_TO_SCHEME_ENTRY (or
JUMP_TO_CC_ENTRY), but missed one spot: the continuations constructed
by STACK-FRAME->CONTINUATION, which use return_to_compiled_code,
which in turn expected a compiled return rather than a compiled entry
and choked.

The interrupt routines, linker utility, and interpreter calls should
all be adapted to take returns rather than entries (which is another
ABI-breaking flag day), but this will do for now.

Save interpreter result too before anything in continuation.

On x86, the interpreter call result register is eax/rax, register 0,
which is also the first register we hand out for register allocation.
The continuation for an interpreter call result uses register 0, but
if the caller uses a dynamic link, the continuation first pops its
frame via the dynamic link...using a temporary register that is
guaranteed to be register 0 since it's the first one the register
allocator hands out.  The code sequence looks something like this:

;; (interpreter-call:cache-reference label-10 (register #x24) #f)
(mov q (r 2) (r 1))
(call (@ro 6 #xd0))
;; (continuation-entry label-10)
(word u #xfffc)
(block-offset label-10)
label-10:
;; (assign (register #x25) (post-increment (register 4) 1))
(pop q (r 0))
;; (assign (register #x26) (object->address (register #x25)))
(and q (r 0) (r 5))
;; (assign (offset (register 6) (machine-constant 4)) (register #x26))
(mov q (@ro 6 #x20) (r 0))
;; (assign (register #x23) (register 0))
(jmp (@pcr label-13))

On entry to the continuation, register 0 holds the value we want,
chosen as a machine alias for pseudo-register #x23 in the procedure
body, but the first thing the continuation does is pop the dynamic
link into register 0, ruining the party.

This is rather tricky to trigger because it turns out in _non-error_
cases, compiled code never asks the interpreter to evaluate a cache
reference that will return a value.  But you can trigger this by
referencing an unassigned variable and invoking a restart, which does
cause the cache reference to return a value:

;; Unassigned, so compiled code will ask interpreter for help.
(define null)

;; Recursive procedure for which the compiler uses a dynamic link.
(define (map f l)
  (let loop ((l l))
    (if (pair? l)
        (cons (f (car l)) (loop (cdr l)))
        null)))

;; Invoke the restart that will return from the cache reference with
;; a value.
(bind-condition-handler (list condition-type:unassigned-variable)
    (lambda (condition)
      condition
      (use-value '()))
  (lambda ()
    (map + '(1 2 3))))
;Value: (1 2 3 . #[false 15 #xea9c18])

Here #[false 15 #xea9c18] is the (detagged) dynamic link, a pointer
into the stack, not the result we wanted at all.

Make entries point to _after_ the PC offset.

This saves a jump in closure headers, and makes non-closure entries
have a nice PC offset of 0 rather than an awkward PC offset of 8.
However, this causes all indirect calls to have an additional offset
of -8 in the addressing mode -- not clear yet how much this hurts.

WARNING: This changes the amd64 compiled code interface so that new
compiled code requires a new microcode and vice versa.  Further, you
must set compiler:cross-compiling? to #t to compile the system,
because compiled code block offsets are now in a different place
relative to compiled entries, so the native fasdumper of an old
microcode can't handle compiled entries produced by a new compiler.

Load the fallback into rax so caller needs no conditional branch.

WARNING: This changes the amd64 compiled code interface so that new
compiled code requires a new microcode.  (However, a new microcode
should handle old compiled code without trouble, since old compiled
code treats rax as garbage at this point, and LEA does not affect
flags.)

Use BTS to affix single-bit type tags.

Relax register constraints for tagging rule.

No need to keep the source alive here -- use move-to-target and allow
any temporary register instead.

Simplify hook calls.

No need for CALL or the stack to be involved: just load PC-relative
address into RBX directly.  Should shave off a few bytes of code.

WARNING: This changes the amd64 compiled code interface so that new
compiled code requires a new microcode and vice versa.

Convert x86-64 to use rax as value register.

WARNING: This changes the amd64 compiled code interface so that new
compiled code requires a new microcode and vice versa.

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.