Use much larger default heap size on 64-bit machines.

Use much larger default heap size on 64-bit machines.

When compiler supports x86-64, use x86-64 in preference to x86.

Find structure field default value procedures by index, not by name.

Otherwise, every constructor generated by DEFINE-STRUCTURE performs
lookups by name for every field with a default initializer, every
time you call the constructor.

This is a backward-compatible change, in the sense that .bin and .com
files generated with the old definition of DEFINE-STRUCTURE can still
be loaded into images with the new definition of DEFINE-STRUCTURE and
its corresponding run-time support.  However, .bin and .com files
generated with the new definition cannot be loaded into images with
the old run-time support, which lacks procedures needed by the new
definition for lookup by index.

Note: For the full benefit of this change, run at least a two-stage
build so that the runtime will include the new definition and be
compiled with the new definition.

Bum case canonicalization and character input in the parser.

This avoids an ASSQ for every character read and some interpreter
environment lookups for every character dispatched on and atom read,
and replaces a general unknown procedure call by some open-coded
string and character operations for every character read in an atom
to canonicalize its case.

Use PRIMITIVE-OBJECT-SET-TYPE, not OBJECT-SET-TYPE, in EOF-OBJECT.

Neither is constant-folded, but PRIMITIVE-OBJECT-SET-TYPE is
open-coded while OBJECT-SET-TYPE is not.  (Is there a reason for
this?  An artefact of Multischeme?)

Export ERROR:NOT-INPUT-PORT and ERROR:NOT-OUTPUT-PORT.

These should be exported anyway, but in particular they caused
INTEGRATE-EXTERNAL in files other than port.scm to generate
references to them out of their scope.

Reduce (<= a b ...) to (and (<= a b) ...) in genio column tracking.

Neither SF nor LIAR currently performs that reduction, so every
character written to a generic I/O port was causing a rest list to be
consed up and control to go through a generic microcode primitive
trampoline to do the reduction at run-time.

Also use FIX:<= rather than <=, since the numbers in question are all
fixnums.

Fix ERROR:ILLEGAL-STREAM-ELEMENT in runtime/stream.scm.

The first argument to what CONDITION-CONSTRUCTOR returns must be a
continuation, so (ERROR (MAKE-ILLEGAL-STREAM-ELEMENT ...)) doesn't
work.  Instead use CONDITION-SIGNALLER.

Fix bug in recent change to runtime/uenvir.scm's WALK-GLOBAL.

MAP-ENTRY takes two arguments, not just one.

Use weak pairs for some entries in obarray buckets.

Entries for symbols with global bindings still use ordinary pairs.
This enables interned symbols without global bindings to be garbage-
collected.  Operations in lookup.c that create or destroy global
bindings update the relevant obarray bucket entry to strengthen or
weaken it.

In the process, fix intern.c's string_hash to accept a long string
length, rather than a uint32_t string length, so that strings longer
than 4 GB will not lose on 64-bit systems.

Fix invocation of out-of-line FIXNUM-LSH hook for i386 and x86-64.

Add comment explaining why it is unnecessary to clear the register
map before invoking the hook.

Clean up texinfo auxiliary files (e.g. imail.aux).

* doc/make-common.in (clean): Use new TEXINFO_ROOT variable to delete
the texinfo auxiliary files.  Also used it in place of the GNU make
specific "word" function.

* doc/imail/Makefile.in (clean): Set TEXINFO_ROOT.
* doc/sos/Makefile.in (clean): ditto
* doc/ref-manual/ref-manual (clean): ditto
* doc/user-manual/Makefile.in  (clean): ditto

Use port/%state in genio ports.

Use port/%state in stringio ports.

Export %char-set-member? to parser.

Use faster write-char when transcribing chars.

Use faster i/o in parse.

Ensure input and output are syntaxed early on.

Export fast input and output operations.

Ensure port is syntaxed before input and output.

Add fast write-char and discretionary-flush.

Add fast read-char and peek-char.

Expose fast port operators.

Create some accessors that don't check PORT?

Don't run-boot-inits! if saved-boot-inits is unbound.

Add an assembly hook for SET-INTERRUPT-ENABLES! on i386.

Mark OVERFLOW? ignored in FIXNUM-LSH methods on i386 and x86-64.

Show only current year in start-up copyright.

Fix references to flonum_zero and flonum_one.

Make x86 and x86-64 assembly hooks for out-of-line FIXNUM-LSH.

I believe this now covers all cases, and is more reasonable than
generating for each FIXNUM-LSH invocation the nearly two dozen
instructions composing the assembly hooks.

Fixes Savannah bug 27384.

Fix bug in new double_round: flip order of arguments to copysign.

Use ja/jb, not jg/jl, in floating-point predicates on x86-64.

Fix flonum case of ROUND to use IEEE round-to-even, per the R5RS.

Fix i386 and x86-64 generic multiplication hooks on fixnums.

Before multiplying, both tags must be cleared, and one of the
operands must be shifted to include a factor of 2^6.  Shifting both
operands, so that there is an extra factor of 2^12, or not clearing
the tag on both operands, is wrong.  However, this didn't affect any
real code, since the fixnum case of generic multiplication is always
open-coded by the compiler unless you futz with compiler switches.

Cache PORT/OPERATION/READ-CHAR in INPUT-PORT/READ-LINE and INPUT-PORT/READ-STRING.

Remove redundant PORT? test.

Fix bug in x86-64 instruction encoder: REX prefix must be last.

(Thanks, AMD, for making it seem like the 66, F2, and F3 bytes are
part of the `opcode' all throughout the media instruction set
manual.)

Also change ([U]COMISF ...) to be ([U]COMIF S ...) for consistency.

Fix headings on x86-64's instr1.scm, instr2.scm, and lapgen.scm.

Open-code floating-point primitives on AMD x86-64.

Only lightly tested.  Use with caution.  Slippery when wet.  Keep out
of reach of children.

Test stack overflow in LIARC interrupt checks.

Provide default binding for MIT_SCHEME_EXE.

Add quote marks to instances of MIT_SCHEME_EXE to provide some
protection from the shell.

Show "aborted" when leaving the extent of an unfinished notification
thunk.

Fix typo.

Merge git pull.

Adjust script so that MIT_SCHEME_EXE is just the executable name, not
a partial shell command.  Figure out stage library directory using
wildcard, since it now has an arch-specific suffix.  Allow override of
default stage0 dirs.

Fix thinko: the boot-root executable is _not_ $(MIT_SCHEME_EXE).

Fix typo.

Fix various minor problems introduced in the configure scripts.

Also kludge up a fix to etc/run-three-stages.

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

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.

Fix problem with compiler/configure: it needed to be updated to match
the other changes around it.  Also, rewrite the script to meet
autoconf portable shell recommendations.

Fix and simplify handling of MIT_SCHEME_EXE in top-level configure.

Always test for existing Scheme, except when running etc/make-liarc.sh.

Ignore variants on standard binary dirs.

Changes to allow multiple architecture binaries to co-exist in the
same file system.  In MacOS X, for example, both the i386 and x86-64
architectures can be used, so it's useful to have both available for
development work, if nothing else.

* Change primary executable name and library name to
  "mit-scheme-ARCH".

* Create a new shell script in the microcode that implements the
  decision logic for choosing a target architecture, based on the host
  architecture and the --enable-native-code argument.  Use this script
  in both the top-level configure file and the microcode configure
  file, so that they agree on the architecture and the corresponding
  names.

* Add logic to create an executable symlink "mit-scheme-native"
  pointing to a native-code executable.  This name is used when we
  need a native-code implementation but don't care which one.  (It's
  also for compatibility.)

* Rework several shell scripts to make them more portable, using the
  autoconf shell portability recommendations.

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.