Fix indexing of remote links.

Fix byte ordering in GENERATE/NSECTS.

Fix register choices in GENERATE/REMOTE-LINKS.

Fix sense of INVOCATION-PREFIX:DYNAMIC-LINK choice.

Fix reference to constant section in GENERATE/REMOTE-LINKS.

Sign-extend PC-relative branch target.

Fix indexing in MOVE-FRAME-UP code: objects, not bytes, here.

And with this, the cold load completes on aarch64!

Fix large application setup.

Teach cmpintmd to flush the instruction cache on aarch64.

Fix argument to PUSH_D_CACHE_REGION.

Takes startptr/count, not startptr/endptr.

This was not an issue before because until aarch64, the only extant
port that even used this, i386, ignored the argument as a macro and
flushed the entire cache.

Fix branch instruction in uuo link stub.

Tweak read/write_compiled_closure_target for clarity and assertions.

Fix cache-assignment code generation.

Fix case.

Fix LSR instruction encoding.

Fix scale->shift.

Fix read/write_compiled_closure_target.

Byte offsets, not object or instruction word offsets.

Fix comment.

Fix PC-relative calculations to work entirely in newspace.

Fix read/write_compiled_closure_target offsets.

Allow non-branch in cc_return_address_to_entry_address.

This happens for trampolines.  Maybe this should be a special case.

Fix scaling of PC offsets: they're byte offsets, not word offsets.

Fix some symbol sizing.

Tidy up interface_to_C.

Note there is a way to do negative offsets.

Make C_to_interface go through interface_to_scheme.

This way C_to_interface sets up VAL, which is necessary in case it is
invoking a continuation.

Fix encoding of ROR and EXTR instructions.

Load UARG2, don't clobber UARG1, in apply hooks.

Fix calculation of hook instruction address.

Fix order of arguments to load-tagged-immediate.

Fix reversed byte order branches in read_uuo_frame_size.

Fix extraction of PC offset from branch instruction.

Fix format word padding and tweak block offsets.

We already arranged for all entries to be 64-bit aligned, so we might
as well take advantage of that in block offsets.

Fix uuo link and trampoline instructions.

Make interface_to_scheme match reality, not sensibility.

Should change cmpint.c so we pass a separate dispatch routine in for
entries and continuations, but that requires changing all the
cmpauxen at once.

Compiler oughta agree cmpauxmd about what register is stack pointer.

Simplify format words: make them always be instruction words.

No need for endianness conditionalization.

Fix passage of dynamic-link.  Only machine register, not regblock.

Assert block offset is zero.

Add a TODO.

Teach ucode identify about aarch64.

Also make this always return a string here, so it doesn't crash on
boot if it hasn't been taught about new compiled code types.

Save an instruction in multiplication with CSETM.

Tweak some register numbering to reduce a bit of code.

Fix register block indexing: no hooks in the register block here.

Fix add/sub immediate syntax and criterion.

Use a temporary if necessary in AFFIX-TYPE.

Draft aarch64 cmpauxmd.

Fix push order in move-frame-up / dynamic-link.

Fix some instruction syntax bugs.

- Specify target _and_ source -- we're not x86 here.
- Specify operand size.
- Specify multipliers correctly.

Avoid REGISTER-COPY-IF-AVAILABLE and TEMPORARY-COPY-IF-AVAILABLE.

These give out register references, which are a pain.  Just use
REUSE-PSEUDO-REGISTER-IF-AVAILABLE! to get the machine register
number.

Disable floating-point vector primitives too.

Until we have open-coded floating-point arithmetic.

Make RTL:CONSTANT-COST always return positive.

Otherwise CSE might substitute constants for registers where at best
it's not helpful and at worst we don't have rules for it.

Fix up some instruction decriptions.

- Migrate some things with citations and updates to instr1.scm.
- No need for `(evaluation ,terms) in fixed-width instructions.
- Fix some missing or duplicated bits.
- Add some more instructions.

Umptuple-check that instruction widths sum to multiples of 32 bits.

Put something in these stub files so they compile as code.

Otherwise the portable fasdumper barfs trying to fasdump a pathname.

Update config.guess and config.sub so they recognize aarch64.

Fix configure goo for aarch64 with byte order specified.

Block offset units are instructions, not bytes, so we get two more bits.

Various work to get this going.

Enough to compile and assemble advice.scm, the first file in the
runtime.  Still a ways from doing anything.

Teach assembler about MODULO.

XXX Should maybe do EUCLIDEAN-REMAINDER or the full gamut of division
operators, but this is all I need for now.

Report bad expressions more clearly.

Fill in some more files, add some build goo, fix some bugs.

Invent a way to do assembler macros so we can do legible branch
tensioning rules and reuse ADRP/ADD patterns.

Draft aarch64 back end.

Nowhere near completion yet, long TODO list, not compile-tested, &c.
Not sure if I'll find any more copious spare time to work on this for
a while.

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.)