Quick workaround for Reuben's M$ configuration problems

sigh, fix the ordering of the phases so that splitting works again.

Added new primitives and bytecodes that support
code generation for XMLambda. All additions are
surrounded by #ifdef XMLAMBDA.

Most important additions:
- Rows (n-tuples) which are implemented on top of Frozen Mutarrays
- Inj (variant sums), which is implemented using a new constructor
called Inj which contains both the value and an unboxed int
which represents the index.

Added definition of int64 to make it compilable with both gcc and VisualC++

Added functions to the bytecode assembler that
support code generation for Xmlambda. All additions for
Xmlambda are surrounded by #ifdef XMLAMBDA.

Added definition of int64 to make it compilable with both gcc and VisualC++

urk! the arity of a record selector Id didn't take into account any
dictionary arguments due to the context on the datatype...

(fixes bug on H/OpenGL reported by Sven)

Emit slightly better x86 floating point code for comparisons, +, -,
* and /, in the common case where one of the source fake FP regs
is the same as the destination reg.

Fixed typo: .hs left out of .SUFFIXES list.

Major thing: new register allocator.  Brief description follows.
Should correctly handle code with loops in, even though we don't
generate any such at the moment.  A lot of comments.  The previous
machinery for spilling is retained, as is the idea of a fast-and-easy
initial allocation attempt intended to deal with the majority of code
blocks (about 60% on x86) very cheaply.  Many comments explaining
in detail how it works :-)

The Stix inliner is now on by default.  Integer code seems to run
within about 1% of that -fvia-C.  x86 fp code is significantly worse,
up to about 30% slower, depending on the amount of fp activity.

Minor thing: lazyfication of the top-level NCG plumbing, so that the
NCG doesn't require any greater residency than compiling to C, just a
bit more time.  Created lazyThenUs and lazyMapUs for this purpose.

The new allocator is somewhat, although not catastophically, slower
than the old one.  Fixing of the long-standing NCG space leak more
than makes up for it; overall hsc run-time is down about 5%, due to
significantly reduced GC time.

--------------------------------------------------------------------

Instructions are numbered sequentially, starting at zero.

A flow edge (FE) is a pair of insn numbers (MkFE Int Int) denoting
a possible flow of control from the first insn to the second.

The input to the register allocator is a list of instructions, which
mention Regs.  A Reg can be a RealReg -- a real machine reg -- or a
VirtualReg, which carries a unique.  After allocation, all the
VirtualReg references will have been converted into RealRegs, and
possibly some spill code will have been inserted.

The heart of the register allocator works in four phases.

1.  (find_flow_edges) Calculate all the FEs for the code list.
    Return them not as a [FE], but implicitly, as a pair of
    Array Int [Int], being the successor and predecessor maps
    for instructions.

2.  (calc_liveness) Returns a FiniteMap FE RegSet.  For each
    FE, indicates the set of registers live on that FE.  Note
    that the set includes both RealRegs and VirtualRegs.  The
    former appear because the code could mention fixed register
    usages, and we need to take them into account from the start.

3.  (calc_live_range_sets) Invert the above mapping, giving a
    FiniteMap Reg FeSet, indicating, for each virtual and real
    reg mentioned in the code, which FEs it is live on.

4.  (calc_vreg_to_rreg_mapping) For virtual reg, try and find
    an allocatable real register for it.  Each real register has
    a "current commitment", indicating the set of FEs it is
    currently live on.  A virtual reg v can be assigned to
    real reg r iff v's live-fe-set does not intersect with r's
    current commitment fe-set.  If the assignment is made,
    v's live-fe-set is union'd into r's current commitment fe-set.
    There is also the minor restriction that v and r must be of
    the same register class (integer or floating).

    Once this mapping is established, we simply apply it to the
    input insns, and that's it.

    If no suitable real register can be found, the vreg is mapped
    to itself, and we deem allocation to have failed.  The partially
    allocated code is returned.  The higher echelons of the allocator
    (doGeneralAlloc and runRegAlloc) then cooperate to insert spill
    code and re-run allocation, until a successful allocation is found.

add missing default case in eq_btype

isNeverInlinePrag returned False for a NOINLINE pragma, which seems
wrong to me.  4.07 also has this bug, and it's why Memo is going wrong.

generate _stub.o files properly when there's a -o flag on the command
line, and in the presence of -split-objs.

don't use $(WithGhcHc) to build the driver, use $(HC) instead.

InstallShield setup added as a zip (because of spaces in file and directory
names). README explains the mess.

This is mostly for backup purposes.

Produce a gcc-like "ghc: no input files" when called with nothing to
do.  Note at the top of the file that we don't support the old
driver's "Enter your Haskell program..." nonsense.

move "boot :: all" after target.mk, so we make dependencies in the
current directory before going on to build the driver.  This still
doesn't really work because GNU make doesn't re-load the .depend file,
but it's heading in the right direction.

also, clean ghc-inplace and ghc.

incorporate several patches from Qrzak (pkg include paths for Cpp
phase, pkg extra_cc_opts in Cc phase, -D__GLASGOW_HASKELL__ for Cc
phase), and fix error messages in unlitted files.

Rewritten for 4.07.

fix installation

fix definition of GHC_STATS

Fix mondo bogosity in hGetLine, probably caused by cut-n-pasting with eyes shut.

fix installed include dir in rts package.

forgot one file

New Driver
==========

Most things work now, so I'm committing this for a shake down.
Doubtless there'll be some breakage but things should be back to
normal by the end of the week.

NOTE: GHC 4.06 won't work to build this driver at the moment, due to a
bug in its parser.  I'll commit a workaround shortly.

There are several improvements here:

	- the driver is written in Haskell, so is allegedly
	  more maintainable than the previous one.  It's a bit shorter,
	  at any rate.

	- the package system has been generalised, so that eg.
	  the RTS is a package, as is GMP and the prelude.  Packages
	  are now configured via a configuration file, package.conf.
	  Two versions of package.conf are automatically generated by
	  PackageSrc.hs, one for ghc-inplace and one for the installed ghc.

	- So that we only have to build the driver once, there's some
	  special hackery to deal with locations of utilities, and
	  other configuration stuff:

	  ghc now has a -B option, which is used in a similar way
	  to gcc's.  eg.

		ghc -B/home/blah/fptools

	  will run ghc in-place in the specified fptools tree, using
	  /home/blah/fptools/ghc/utils/mkdependHS to find mkdependHS
	  for example.  ghc-inplace is now a small shell script that
	  simply invokes the above.  Whereas

		ghc -B/usr/local/lib/ghc-4.07

	  also works, for an installed copy of ghc in
	  /usr/local/lib/ghc-4.07.

	- the mangler, object splitter and GC stats gatherer are separate
	  scripts in subdirectories of ghc/driver.  ghc-asm.lprl and
	  ghc-split.lprl have been copied in the CVS repository to maintain
	  the history (fingers crossed; I've never done this before)


Other notes:

	- Java support isn't there yet.  Andy: don't update for the time
	  being until I can sort this.

	- Windows support is also broken, but will be fixed in due course.

x86: Relativise register table offsets for Hp, R1, R2 and SpA

x86: Catch fast entry points fallthroughs via %esi and %edi

m68k-*-nextstep3 updates

When doing -monly-x-regs, fix up entry and exit from PerformGC_wrapper

Tweaked __fexp regexps

PPC updates

On mingw32, which is the only 'platform' where we support producing
DLLs, prefix each static closure with a zero word. This is needed so
that we can distinguish between pointers to (reversed!) info tables
and static closures just by checking whether there's a zero word just
above the pointed-to entity. Wish there was a better way..

HPUX fix to allow non-empty consistency chunks pass through OK

Groks output from cygwin32-gcc

Fixed consist pattern for cygwin32

- include mingw32 in the list of x86 platforms supported.
- weed out ecoff debug information.

More small changes towards 2.02

put SRTs in the text section.

gcc 2.95 on Sparc changed the assembly output slightly.  This should
fix it.

freebsd3 ==> freebsd

Push directives over literal chunks when attempting to move them to
the following chunk on x86.  Occasionally gcc generates a .glob
directive some distance before the symbol it refers to, and we were
ending up with a whole load of .glob directives attached to strings,
and duplicated in each .o file when splitting.

This change reduces the size of my libHSstd_p.a from 43M (!!!) to 9M.
I think this problem must have appeared with gcc 2.95.2, but it's a
little strange that I didn't notice it until now.