[MLton] Experimental 64-bit binary package (now w/ amd64 codegen)

[Matthew Fluet]

I have posted an experimental amd64-linux (64-bit mode) binary package
to the usual place:
   http://www.mlton.org/Experimental
The corresponding sources can be checked out with:
   svn co svn://mlton.org/mlton/branches/on-20050822-x86_64-branch 
mlton.svn.x86_64
(You can skip the binary package and use a 32-bit build (preferably
from a recent trunk check out) to bootstrap.)

This isn't a fully polished release.  However, it does feature a
native amd64 code generator (enabled by default), passes all the
regressions and bootstraps, and there are no known bugs.

Currently, I'm mostly interested in the correctness of produced code;
please report any compile-time assertions or bugs in the resulting
executables.

As the 64-bit port is wrapping up, I am also interested in portability 
and configuration issues.  I believe that for each x86-$TARGET_OS 
platform supported by MLton, we should also be able to support the
amd64-$TARGET_OS platform (when it exists).  In particular, I'm hoping
that someone can try bootstrapping from a 32-bit build to a 64-bit
build on the *BSD variants.  Making experimental binary packages 
available for other systems would also be a great help.

Items of note:

   * Please see the original 'Experimental 64-bit' announcement:
     http://mlton.org/pipermail/mlton/2007-February/029662.html

   * Both the C codegen and a native amd64 codegen are supported on
     amd64-*.  The native amd64 codegen is enabled by default.

   * Fixed the issue mentioned in the announcement above regarding
     datatypes with variants carrying a Real32.real.  There are now
     primitives supporting bitcasts of word to/from real; these
     operations are also exported in the MLton.Real{32,64} structures.

   * Restored the use of Word8{Array,Vector}_{sub,update} primitives
     for PackWord<N>{Big,Little} structures.  This solves a performance
     issue (introduced by previous refactoring that used C-functions
     for sub and update).  Also, use an ML byte swap function to handle
     when PackWord<N>{Big,Little}'s endian and host's endian differ.
     Finally, PackReal<N>{Big,Little} are implemented entirely in ML
     using PackWord<N>{Big,Little} and the word/real bitcast
     operations.