Simplify x86-64 utility interface, and nuke all x87 code from it.

The calling convention for microcode utilities now more closely
matches the standard calling convention for C on the AMD64, which
reduces the amount of code needed in scheme_to_interface.  The i386
hack to split the assembly hook addresses between negative addresses
and positive addresses is no more; most of what little benefit it
added on the i386, it ceased to add on x86-64, since no hooks fit in
positive byte offsets from the register block start any longer, and
only sixteen would fit in negative byte offsets.  Perhaps later it
would be worth deciding which sixteen deserve byte offsets (e.g.,
scheme-to-interface certainly would), but this is simpler for now.
Note that there is still a space advantage to invoking a hook (jump
to an offset from Registers) over invoking an interface (move its
number to AL, jump to scheme-to-interface), since invoking an
interface requires going through a hook anyway.

These change serves mainly to simplify the code, not to improve
performance, although shuffling the calling convention may improve
performance as a bonus.

The x87 code appears to have been causing problems, and will later
be replaced by the AMD64's 128-bit media (SSEn) instructions anyway.
The compiler still has some x87 vestiges left in it, but not in any
code that is hit, and nearly all of it is commented out now.

*** NOTE:  Since this changes the calling convention of utilities
from compiled code, it breaks all existing x86-64 .com files, which
you must recompile with the new compiler.  This means that you can't
straightforwardly rebuild Scheme the usual way from a prior x86-64
installation.  The easiest way to proceed is to start again from a
LIARC snapshot and rebootstrap the x86-64 code.  Expect more of this
to come; in particular, since we now have a reasonable number of
machine registers, it may be worthwhile to assign one to be the
return value register.

Simplify gcloop.c's tospace_open.

This need not have a conditional; it is called only when the
condition is true, to report the error.  This may not have been the
source, but Gerry observed GCC stumble into an internal compiler
error while compiling this procedure!

Eliminate irrelevant reference to OS/2.

Work around problem with SDX addressing mode under MacOS.

Allow --enable-native-code to override default code generator.

Fix thinko; add support for x86-64 on MacOS.

Add icon file for MacOS app.

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

Simplify x86-64 addressing mode syntax.

*** NOTE:  Since this changes machines/x86-64/insmac.scm, you must
resyntax the compiler afresh, e.g. by running

scheme --band runtime.com <<EOF
(for-each load-option '(SF CREF))
(load "compiler.sf")
EOF

Otherwise, the compiler will expand machines/x86-64/insutl.scm using
the old macro definitions, not the new ones, and grow very confused.
Using the host compiler's macros is pretty bogus.

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

Treat PRIMITIVE-OBJECT-SET-TYPE as a side-effecting primitive.

This causes it not to be constant-folded, which was causing problems
for LIARC when compiling runtime/packag.scm, and which was probably
unsafe to do anyway.

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

Hook up x86-64 in the compiler and microcode's configure scripts.

Simplify INVOCATION:PRIMITIVE for x86-64.

No generated code changes; the code implementing the rule has just
been reduced by factoring out common parts of conditional branches.

Make the compiler/configure script idempotent.

Check for an existing MIT Scheme in top-level Setup.sh and configure.

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

Enable open-coding of most non-flonum primitives on x86-64.

Adapt rulfix.scm for x86-64.

Fix various immediate operands in x86-64 LAP generation.

Implement an abstraction for yielding an operand representing some
immediate value, either by yielding an actual immediate operand or by
loading an immediate into a temporary register with MOV (which takes
64-bit immediate operands, unlike every other instruction) and by
yielding a reference to the temporary register for the operand.

Use this to simplify LOAD-DISPLACED-REGISTER, and reduce the code it
generates.

Use more appropriate names for procedures that generate code to move
objects into registers (`load') and to move objects into memory
(`store').

Fix various other places that generate LAP with immediates to use the
new abstraction to ensure that they always fit in the relevant
instructions' operands.

Another round of clarifying signedness in x86-64 instruction syntax.

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

Restructure LIAR's lists of foldable variables and primitives.

Treat global variables and primitives separately when enumerating the
global boolean-valued, function, or side-effect-free operators.  This
re-enables LIAR's constant-folding after it was defeated by earlier
changes to bind global variables to compiled procedures that call
primitives, rather than to bind them to the primitives.

Comment out machines/x86-64/instrf.scm.

Later this will be replaced by the SSEn instruction sets, but since
the instruction syntax syntax changed, it is necessary to ignore the
old x87 definitions for now.

In x86-64 arithmetic instructions, use UNSIGNED bits for &U.

Align stack to 16 byte boundary in x86-64's C_to_interface.

Otherwise, parts of the microcode fail spectacularly when compiled
with `gcc -O3'.

Fix another bug in IMUL: the 3-operand, >8-bit opcode is 69, not 6b.

Fix bug in IMUL L/Q rules: immediate operand is a long, not a word.

Implement microcode auxiliaries for AMD x86-64 compiled code.

Adapt general LAP generation rules to AMD x86-64.

Move interrupt-check analysis to new file back/checks.scm.  Later,
the other back ends should switch to using this, rather than having
copies of the code.

Fixnum and flonum rules are not yet adapted.

Disable i386 LAP optimizer for AMD x86-64.

To be rewritten later.

Write instruction rules for the general AMD x86-64 instruction set.

(No floating-point instructions yet.)

Write machine parameters and instruction syntaxer for AMD x86-64.

Fix bug in recent transformations that caused inadvertent shadowing.

The real fix is to make cgen do alphatization, in which case copy.scm
could be considerably simplified, but this hack works for now to fix,
e.g., miscompilation of INITIALIZE-PACKAGE! in runtime/emacs.scm,
which has

(let ((type (select-console-port-type)))
  (if (let ((type (port/type the-console-port)))
        (or (eq? type vanilla-console-port-type)
            (eq? type emacs-console-port-type)))
      (set-port/type! the-console-port type)))

=>

(let ((type (select-console-port-type)))
  (let ((type (port/type the-console-port)))
    (if (or (eq? type vanilla-console-port-type)
            (eq? type emacs-console-port-type))
        (set-port/type! the-console-port type))))

One of the variables formerly named TYPE is now named by an uninterned
symbol instead.

Fix ADD-DEFAULTED-SUBPROBLEMS! to use the model's original rest parameter.

Fix argument order bug in integrated parameter deletion.

Make AUTOMAGIC-INTEGRATIONS search recursively, so that it transform

(let ((foo cdr))
  (cdr x))

into

(cdr x),

which will then be open-coded.  I believe AUTOMAGIC-INTEGRATIONS
formerly made no changes that improved the code LIAR generates; now
this change does improve the code that LIAR generates.  This idiom
arises mainly in macros and in integrated procedures.

Fix bugs in previous changes that this change uncovered: when
integrating compound operators and conditional predicates, bail if
any open blocks are involved; handling them is too complicated.

Use x86-64 pathnames for x86-64 back end's packaging and scripts.

Copy i386 back end to begin x86-64 back end for LIAR.

Perhaps later we can merge the common parts to reduce the amount of
duplication, but this is most convenient for now.

Close some procedures whose closing blocks are expression blocks.

Reverse sense of ordering in argument type string to reflect reality.

Fixes

(set-hash-table/rehash-size! (make-hash-table) -1.2)
;The object -1.2, passed as an argument to set-hash-table/rehash-size!, is not a real number < 1 or exact integer >= 1.

Add grep spencer1 tests.

Avoid infinite loop for patterns like (* (SEQ)).

Rename REPEAT> to ** and REPEAT< to **? and allow single limit.

Add grep ere tests.

Don't count singleton sub-tests as a separate level.

Fix thinko in last change.

Change reporting of test results to be terse when passing and more verbose when failing.

Fix thinko.

Fix bug in cold-load sequence.

Strip angle brackets off record-type name when printing record.

Fix cold-load errors.

Don't signal compiler errors while linking.

Add tests for regsexp.

Build unit-test framework.

Add notices and comments to test files.

Move *parser tests to new tests directory.

Move XML tests to new tests directory.

Add some tests; these are mostly old and not automated.

Fix definition of FNV hash.  Thanks Taylor!

Simplify definitions of core object lengths and masks.  Eliminate references to 8-bit types.  Fix a couple of sign errors.

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

Fix hygiene in top-level bindings of synthetic identifiers.

Make such bindings globally unique by creating them with uninterned
symbols, bypassing the alpha renaming which was making them look
prettier at the expense of global uniqueness.

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

Remove complex and unused optimizer.  Change "combination" to "form"
in places where it was being used incorrectly.  A couple of other
tweaks.

When pretty-printing code, abbreviate quotations.

Fix thinko in previous change.

Don't accept negative integers when converting to ulong.

Eliminate unsyntaxer's logic for FLUID-LET.

This code was fragile, and has neither worked nor even been reached
in at least eight years, so eliminating it doesn't really reduce any
functionality.

Teach SF to pull LETs and BEGINs out of IF predicates.

LIAR doesn't do a very good job with disjunctions not immediately in
the predicate position of IFs.  It still doesn't do a very good job
with (OR X (LET ((Y ...)) (OR ...))), but this helps it a little to
reduce needless pushing and popping of #F on the stack.

Tweak EQUALITY-PREDICATE to do what it's called.

Eliminate keyword quote in rule patterns.

Tabify recent change to sf/subst.scm, for consistency.

When expanding (VALUES ...) in SF, integrate the receiver.

Make SF invert LAMBDAs nested inside LETs in operator positions.

((let ((x (foo)) (y (bar)))
   (lambda (receiver) ...))
 (lambda (x y z)
   ...))

=>

(let ((receiver (lambda (x y z) ...)))
  (let ((x (foo)) (y (bar)))
    ...))

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

Use a little currying to turn the instruction set into a combinator language.  Now passes a bunch of simple tests; more to write.

Fix bugs in regsexp.  Many simple parts now work.

Fix oversight from previous change.

Fix export of SYNTAX-RULES.

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

Move transcript off the property list.

Fix bug in LET* after the recent syntax reorganization.

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

Add missing Edwin variable IMAIL-INLINE-MIME-TEXT-LIMIT to imail.pkg.

Add many missing entries for Edwin commands to imail/imail.pkg.

Signal errors with better messages in VECTOR-FIRST &c.

Refactor syntax to break it into smaller, more coherent pieces.
Simplify where easy to do so.

Fix some bugs in regsexp.

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

Add script to run three-stage compile.

Don't use built-in Scheme executables; provide env var to override.

Back out change to disable type checks for accessors and modifiers;
it's tickling a compiler bug.

More simplification.

Fix logic in STRING-HEAD!.  Also some small tweaks.

Handle UNTERMINATED tokens in RFC822:TOKENS->STRING.

Fix DBG-INFO-VECTOR? so that it accepts both new and old formats.

Fix integration of ACCESS where the environment is SYSTEM-GLOBAL-ENVIRONMENT.

Make symbol? an integrable operator.

Implement regular s-expressions.