Make versioned ghc and ghci programs on Windows; fixes trac #2827

SPARC NCG: Unsigned comparisons are unsigned

SPARC NCG: Fix word size conversions

SPARC NCG: Split up into chunks, and fix warnings.

SPARC NCG: Reorganise Reg and RegInfo

NCG: Cleanup old file

NCG: validate fixes for ppc-darwin

NCG: validate fixes for ghc-6.6

NCG: validate fixes for i386-darwin

NCG: validate fixes for x86_64-linux

NCG: Haddock validate fix

NCG: Validate fixes for x86-linux

SPARC NCG: Don't release top half of f6 and f8

NCG: Split up the native code generator into arch specific modules

  - nativeGen/Instruction defines a type class for a generic
    instruction set. Each of the instruction sets we have,
    X86, PPC and SPARC are instances of it.

  - The register alloctors use this type class when they need
    info about a certain register or instruction, such as
    regUsage, mkSpillInstr, mkJumpInstr, patchRegs..

  - nativeGen/Platform defines some data types enumerating
    the architectures and operating systems supported by the
    native code generator.

  - DynFlags now keeps track of the current build platform, and
    the PositionIndependentCode module uses this to decide what
    to do instead of relying of #ifdefs.

  - It's not totally retargetable yet. Some info info about the
    build target is still hardwired, but I've tried to contain
    most of it to a single module, TargetRegs.

  - Moved the SPILL and RELOAD instructions into LiveInstr.

  - Reg and RegClass now have their own modules, and are shared
    across all architectures.

SPARC NCG: Make linear allocator use info in SPARC.Regs again

SPARC NCG: Enumerate freeRegs / globalRegMaybe instead of using #ifdefery

NCG: Split PprMach into arch specific modules
  - There are still some #ifdefs for choosing between i386, x86_64,
      linux, darwin and other OS's.
  - Also reformat SPARC.RegInfo to remove some of the visual noise.

Put RelaxedPolyRec in the cabal file rather than a pragma
This should fix the build with GHC 6.6

update Sparc store/load barrier (#3019), and fix comments

comment wibbles

NCG: Use sync instead of msync for a memory barrier for powerpc
  Darwin 9.6.0 + GCC 4.0.1 doesn't understand "msync".
  I think "sync" means the same thing.

NCG: Split block reorder thing in linear allocator into separate fn

NCG: Validate fixes for powerpc

NCG: Add missing ops to powerpc isJumpish

Only pass --with-hscolour to cabal-bin once

Quote some more arguments to cabal-bin

Add more targets to the list that we need to include all libraries for

Fix Trac #3017: ensure that we quantify over enough type variables when equalities are involved

The function FunDeps.grow was not doing the right thing when type equality
constraints were involved.  That wasn't really its fault: its input was
being filtered by fdPredsOfInsts.

To fix this I did a bit of refactoring, so that the (revolting) fdPredsOfInsts
is now less important (maybe we can get rid of it in due course).  The 'grow'
function moves from FunDeps to
 Inst.growInstsTyVars
 TcMTType.growThetaTyVars
 TcMType.growTyVars

The main comments are with the first of these, in
Note [Growing the tau-tvs using constraints] in Inst.

Push to the branch if conflict free.

general tidy up

one more bugfix: a load/load memory barrier is required in stealWSDeque_()

Fix trac #3001: Biographical profiling segfaults
We were zeroing the wrong memory

Tweak the mangler; fixes trac #2871
It was getting confused by lines like:
 # 9 "C:\Temp\/ghc620_0/ghc620_0.hc" 1

On sparc, pass -mcpu=v9 when assembling with object splitting enabled
Fixes trac #2872.

Turn another ASSERT into a WARN (temproraily)

Fix Trac #3011 by temporarily making it only a WARN if we assign twice
to the same unification variable.

Improve documentation for LANGUAGE pragma (esp wrt cpp)

Don't use the absolute path to the bindist tarball
On Windows, we end up doing something like
    rsync c:/build/ghc-6.10.1-unknown-mingw32.tar.bz2 haskell.org:dist
and it thinks that it is meant to get the file from the host called "c".
Now we just do
    rsync ghc-6.10.1-unknown-mingw32.tar.bz2 haskell.org:dist
so rsync understand what we mean.

Fix cleaning and installing the libraries
When cleaning or installing, we need to ignore what $stage is, and
just clean/install all the libraries.

scheduleYield(): check the wakeup queue before yielding

Improvements to the "can't find module" error message (#2980)
If the module was found in multiple hidden packages, we list them all.

Could not find module `Data.Generics':
  it is a member of the hidden package `base-3.0.3.0'
  it is a member of the hidden package `syb'
  Use -v to see a list of the files searched for.

build fix: add -I../rts/parallel

crucial bugfix: add a store/load memory barrier to popWSDeque()

bugfix: an unsigned comparison should be signed

tiny cleanup

add debugging code and comments

add an assertion

add a single-threaded version of cas()

add a store/load memory barrier

Refactor the spark queue implementation into a generic work-stealing deque
So we can use this abstraction elsewhere in the RTS

Handle the case where setitimer(ITIMER_VIRTUAL) is not always available
Patch from sthibaul. Fixes trac #2883.

Correct an IsFunction that should be IsData

Fix calling maths functions when compiling via C

Add a panic to fix the build on amd64/Linux; to be fixed properly later

Fix the build on OS X: only understands .space, not .skip

Fix building with GHC 6.8

Fix the build on amd64/Linux

When generating C, don't pretend functions are data
We used to generated things like:
    extern StgWordArray (newCAF) __attribute__((aligned (8)));
    ((void (*)(void *))(W_)&newCAF)((void *)R1.w);
(which is to say, pretend that newCAF is some data, then cast it to a
function and call it).
This goes wrong on at least IA64, where:
    A function pointer on the ia64 does not point to the first byte of
    code. Intsead, it points to a structure that describes the function.
    The first quadword in the structure is the address of the first byte
    of code
so we end up dereferencing function pointers one time too many, and
segfaulting.

NCG: Validate fixes

NCG: Split RegAllocInfo into arch specific modules

NCG: Move RegLiveness -> RegAlloc.Liveness

NCG: Rename MachRegs, MachInstrs -> Regs, Instrs to reflect arch specific naming

NCG: Split MachRegs.hs into arch specific modules

NCG: Fix validate

SPARC NCG: Fix some haddock problems.

SPARC NCG: Add Pwr callish mach op

NCG: Split MachInstrs into arch specific modules

NCG: Move the graph allocator into its own dir

SPARC NCG: Update cabal file

SPARC NCG: Give regs o0-o5 back to the allocator

NCG: Split out joinToTargets from linear alloctor into its own module.

 * Also fix a nasty bug when creating fixup code that has a cyclic
   register movement graph.

NCG: Split linear allocator into separate modules.

SPARC NCG: Keep track of destinations when doing a tabled jump

SPARC NCG: Do general 64 bit addition and conversion

SPARC NCG: Don't need a write barrier for store synchronisation on SPARC under TSO.

SPARC NCG: Use .skip instead of .space in assembler

 - In the GNU assembler they mean the same thing
 - The Solaris assembler only has .skip

Check -XGADTs in (a) type family decls (b) pattern matches

Following Trac #2905, we now require -XGADTs for *pattern matches* on
GADTs, not just on *definitions*.

Also I found that -XGADTs wasn't being checked when declaring type families,
so I fixed that too.

Improve error reports for kind checking (Trac #2994)

I followed the suggestion in Trac #2994, which took longer than I
expected.  As usual I did a bit of tidying up at the same time,
and improved a few other error reports.

Further wibbles to 'deriving' for functor-like things

leave out rts/ from include-dirs in the inplace rts package
it shouldn't be there, and might hide bugs

Fix Trac #2999: change an ASSERT to a WARN

A bug in the constraint simplifier means that an equality can be solved
twice.  It's harmless, and will go away with the new constraint simplifier.
Hence warning, to avoid unnecessary outright failure on eg Trac #2999.

Improve transferPolyIdInfo for value-arg abstraction

If we float a binding out of a *value* lambda, the fixing-up of IdInfo
is a bit more complicated than before.  Since in principle FloatOut
can do this (and thus can do full lambda lifting), it's imporrtant
that transferPolyIdInfo does the Right Thing.

This doensn't matter unless you use FloatOut's abilty to lambda-lift,
which GHC mostly doesn't, yet.  But Max used it and tripped over this bug.

Two small improvements to LiberateCase

Max Bolingbroke suggested these two small improvements to LiberateCase
(most of the size increase is comments :-)):

a) Do LiberateCase on small functions even if they are mutually recursive
   See Note [Small enough]

b) Don't do LiberateCase on functions for which it'd be fruitless,
   namely when a free varible is scrutinised *outside* the function
   See Note [Avoiding fruitless liberate-case]

There is virtually no effect on nofib, but Max tripped over cases
where it mattered slightly.

Robustify lookupFamInstEnv, plus some refactoring

This patch deals with the following remark

     Suppose we have
            type family T a :: * -> *
            type instance T Int = []

     and now we encounter the type (T Int Bool).  If we call
     lookupFamInstEnv on (T Int Bool) we'll fail, because T has arity 1.
     Indeed, I *think* it's a precondition of lookupFamInstEnv that the
     supplied types exactly match the arity of the type function.  But
     that precondition is neither stated, nor is there an assertion to
     check it.

With this patch, lookupFamInstEnv can take "extra" type arguments in
the over-saturated case, and does the Right Thing.

There was a nearly-identical function lookupFamInstEnvUnify, which
required the precisely analogous change, so I took the opportunity
to combine the two into one function, so that bugs can be fixed in one
place.  This was a bit harder than I expected, but I think the result
is ok.  The conflict-decision function moves from FamInst to FamInstEnv.
Net lines code decreases, although there are more comments.

Robustify lookupFamInstEnv

Suppose we have
        type family T a :: * -> *
        type instance T Int = []

and now we encounter the type (T Int Bool).  That is perfectly
fine, even though T is over-saturated here.

This patch makes lookupFamInstEnv robust to such over-saturation.
Previously one caller (TcTyFuns.tcUnfoldSynFamInst) dealt with
the over-saturation case, but the others did not. It's better
to desl with the issue at the root, in lookupFamInstEnv itself.

Improve trace message

Build dph with the stage2 compiler
It will use TH, so needs to be built with stage2.

Optimise writing out the .s file
I noticed while working on the new IO library that GHC was writing out
the .s file in lots of little chunks.  It turns out that this is a
result of using multiple printDocs to avoid space leaks in the NCG,
where each printDoc is finishing up with an hFlush.

What's worse, is that this makes poor use of the optimisation inside
printDoc that uses its own buffering to avoid hitting the Handle all
the time.

So I hacked around this by making the buffering optimisation inside
Pretty visible from the outside, for use in the NCG.  The changes are
quite small.

better error message for missing package-qualified modules in ghc -M

add wiki commentary links

Force the result of user-defined commands
so that exceptions are reported with "*** Exception" instead of as a panic.

Improve error reporting for precedence errors

Adopt the suggestion of Trac #2993, and tidy up the reporting of
precedence parsing errors somewhat.

Add the ability to derive instances of Functor, Foldable, Traversable

This patch is a straightforward extension of the 'deriving' mechanism.
The ability to derive classes Functor, Foldable, Traverable is controlled
by a single flag  -XDeriveFunctor.  (Maybe that's a poor name.)

Still to come: documentation

Thanks to twanvl for developing the patch

Comments about injecting implicit bindings

Warn in configure if it looks like make 3.80 is about to be used
We get caught by
    http://savannah.gnu.org/bugs/index.php?1516
    $(eval ...) inside conditionals causes errors
with make 3.80, so warn the user if it looks like they're about to
try to use it.

Fix Trac #2985: generating superclasses and recursive dictionaries

The Note [Recursive instances and superclases] explains the subtle
issues to do with generating the bindings for superclasses when
we compile an instance declaration, at least if we want to do the
clever "recursive superclass" idea from the SYB3 paper.

The old implementation of tcSimplifySuperClasses stumbled when
type equalities entered the picture (details in the Note); this
patch fixes the problem using a slightly hacky trick.  When we
re-engineer the constraint solver we'll want to keep an eye on
this.

Probably worth merging to the 6.10 branch.

White space only

Two more wibbles to CorePrep (fixes HTTP package and DPH)

Ensuring that
  a) lambdas show up only on the RHSs of binding after CorePrep
  b) the arity of a binding exactly matches the maifest lambdas
is surprisingly tricky.

I got it wrong (again) in my recent CorePrep shuffling, which broke
packages HTTP and DPH.  This patch fixes both.

Remove the doc/ contents from the GMP tarball
They are GFDLed, which causes problems for Debian

#2973: we should virtualise the CWD inside the GHC API, not in the client
The problem is that we install the client's CWD before calling
runStmt, but runStmt has to load modules before running the code.  We
need to install the CWD just before running the code instead, which
means it has to be done inside runStmt (and resume).

Fix detection of i386 vs. x86_64 for -pc-solaris
From #2951

Implement #2191 (traceCcs# -- prints CCS of a value when available -- take 3)
In this version, I untag R1 before using it, and even enter R2 at the
end rather than simply returning it (which didn't work right when R2
was a thunk).