Tidy up rebindable syntax for MDo

For a long time an 'mdo' expression has had a SyntaxTable
attached to it.  However, we're busy deprecating SyntaxTables
in favour of rebindable syntax attached to individual Stmts,
and MDoExpr was totally inconsistent with DoExpr in this
regard.

This patch tidies it all up.  Now there's no SyntaxTable on
MDoExpr, and 'modo' is generally handled much more like 'do'.

There is resulting small change in behaviour: now MonadFix is
required only if you actually *use* recursion in mdo. This
seems consistent with the implicit dependency analysis that
is done for mdo.

Still to do:
  * Deal with #4148 (this patch is on the way)
  * Get rid of the last remaining SyntaxTable on HsCmdTop

Make the occurrence analyser track preInlineUnconditionally

This fixes a somewhat obscure situation in which an
over-optimistic use of "occurs once" led to an infinite
sequence of simplifier iterations.  Se Note [Cascading inlines]
for the details.

This showed up when compiling rather large DPH programs, which
run lots of iterations of the simplifier, which in turn made
compilation take much longer than necessary.

Make mkDFunUnfolding more robust

It now uses tcSplitDFunTy, which is designed for the purpose and
allows arbitrary argument types to the dfun, rather than
tcSplitSigmaTy.  This generality is used in DPH, which has
internally-generated dfuns with impliciation-typed arguments.

To do this I had to make tcSplitDFunTy return the number of
arguments, so there are some minor knock-on effects in other
modules.

Count allocations more accurately
The allocation stats (+RTS -s etc.) used to count the slop at the end
of each nursery block (except the last) as allocated space, now we
count the allocated words accurately.  This should make allocation
figures more predictable, too.

This has the side effect of reducing the apparent allocations by a
small amount (~1%), so remember to take this into account when looking
at nofib results.

Add a simple arity analyser

I've wanted to do this for ages, but never gotten around to
it.  The main notes are in Note [Arity analysis] in SimplUtils.

The motivating example for arity analysis is this:

  f = \x. let g = f (x+1)
          in \y. ...g...

What arity does f have?  Really it should have arity 2, but a naive
look at the RHS won't see that.  You need a fixpoint analysis which
says it has arity "infinity" the first time round.

This makes things more robust to the way in which you write code.  For
example, see Trac #4474 which is fixed by this change.

Not a huge difference, but worth while:

        Program           Size    Allocs   Runtime   Elapsed
--------------------------------------------------------------------------------
            Min          -0.4%     -2.2%    -10.0%    -10.0%
            Max          +2.7%     +0.3%     +7.1%     +6.9%
 Geometric Mean          -0.3%     -0.2%     -2.1%     -2.2%

I don't really believe the runtime numbers, because the machine was
busy, but the bottom line is that not much changes, and what does
change reliably (allocation and size) is in the right direction.

Miscellaneous tidying up and refactoring

Comments only

Single-method classes are implemented with a newtype

This patch changes things so that such classes rely on the coercion
mechanism for inlining (since the constructor is really just a cast)
rather than on the dfun mechanism, therby removing some needless
runtime indirections.

For single-method classes use newtypes

This clears up an awkward hack for exprIsConApp_maybe, and
works better too.  See Note [Single-method classes] in
TcInstDcls.

boundTaskExiting: don't set task->stopped unless this is the last call (#4850)
The bug in this case was that we had a worker thread making a foreign
call which invoked a callback (in this case it was performGC, I
think).  When the callback ended, boundTaskExiting() was setting
task->stopped, but the Task is now per-OS-thread, so it is shared by
the worker that made the original foreign call.  When the foreign call
returned, because task->stopped was set, the worker was not placed on
the queue of spare workers.  Somehow the worker woke up again, and
found the spare_workers queue empty, which lead to a crash.

Two bugs here: task->stopped should not have been set by
boundTaskExiting (this broke when I split the Task and InCall structs,
in 6.12.2), and releaseCapabilityAndQueueWorker() should not be
testing task->stopped anyway, because it should only ever be called
when task->stopped is false (this is now an assertion).

releaseCapabilityAndQueueWorker: task->stopped should be false (#4850)

Fix Windows build

raiseExceptionHelper: update tso->stackobj->sp before calling threadStackOverflow (#4845)

add 'make re2' for rebuilding stage2 (similarly re1 and re3)

fix warning

Small improvement to CorePrep

This change avoids unnecessary bindings. Example

     foo (let fn = \x.blah in
          in fn)

We were generating something stupid like

    let fn = \x.blah in
    let fn' = \eta. fn eta
    in foo fn

Now we don't.  The change is quite small.

Thanks to Ben for showing me an example of this happening.

Fix warnings

Small refactoring

Drop GhcWithLlvmCodeGen configuration bits
The LLVM code generator is always built unconditionally, so both the
configuration variable in mk/config.mk.in as well as the string in
compilerInfo can be removed.

Pass --hoogle to haddock; fixes trac #4521

vectoriser: don't always pass superclass dictionaries to PA dfuns

This is just a guess at how this should work.

vectoriser: delete dead code

vectoriser: adapt to new superclass story part I (dictionary construction)

Replace uses of the old try function with the new one

Replace uses of the old catch function with the new one

Create ~/.ghc/ if it doesn't already exist; fixes trac #4522

Document GADTSyntax extension

Implement GADTSyntax extension

Whitespace-only in rts/Linker.c

Add some casts to fix warnings; patch from Greg Wright

Put an up-to-date Makefile in docs/Makefile
It doesn't do anything useful yet, but it works with the new build system

do not compile part of shared lib RTS with -fno-PIC on Solaris

provide shared libraries support on i386-unknown-solaris2 platform

fix CPP detection of Solaris in NCG

Fix checkBinaries on OS X

Remove redundant HpcMap and HpcSet wrappers around Data.{Map,Set}

Use "-perm -u+x" rather than "-executable" to find executables
On Windows, -executable is matching the html docs.

Remove a debugging print

__GLASGOW_HASKELL__ >= 604 is now always true

Remove more dead code now we require GHC >= 6.12

refactor and tidy up the section on RTS options

Related to #4826: Some minor tweaks to the wording of the User Guide, section 4.16

FIX #4826 partial: Add -rtsopts and -with-rtsopts to User Guide section 4.11.6

FIX #4826 partially: Change -f to -? in User Guide section F4.16

fix #3910

remove an optimisation that wasn't

fix a warning

use EXTERN_INLINE instead of STATIC_INLINE to avoid some gcc warnings

remove dead code

fix retainer profiling: add missing case for TSO

add a missing STACK case

Remove code that is dead now that we need >= 6.12 to build

fix for large stack allocations

Implement stack chunks and separate TSO/STACK objects

This patch makes two changes to the way stacks are managed:

1. The stack is now stored in a separate object from the TSO.

This means that it is easier to replace the stack object for a thread
when the stack overflows or underflows; we don't have to leave behind
the old TSO as an indirection any more.  Consequently, we can remove
ThreadRelocated and deRefTSO(), which were a pain.

This is obviously the right thing, but the last time I tried to do it
it made performance worse.  This time I seem to have cracked it.

2. Stacks are now represented as a chain of chunks, rather than
   a single monolithic object.

The big advantage here is that individual chunks are marked clean or
dirty according to whether they contain pointers to the young
generation, and the GC can avoid traversing clean stack chunks during
a young-generation collection.  This means that programs with deep
stacks will see a big saving in GC overhead when using the default GC
settings.

A secondary advantage is that there is much less copying involved as
the stack grows.  Programs that quickly grow a deep stack will see big
improvements.

In some ways the implementation is simpler, as nothing special needs
to be done to reclaim stack as the stack shrinks (the GC just recovers
the dead stack chunks).  On the other hand, we have to manage stack
underflow between chunks, so there's a new stack frame
(UNDERFLOW_FRAME), and we now have separate TSO and STACK objects.
The total amount of code is probably about the same as before.

There are new RTS flags:

   -ki<size> Sets the initial thread stack size (default 1k)  Egs: -ki4k -ki2m
   -kc<size> Sets the stack chunk size (default 32k)
   -kb<size> Sets the stack chunk buffer size (default 1k)

-ki was previously called just -k, and the old name is still accepted
for backwards compatibility.  These new options are documented.

comments on SRC_HC_OPTS (#4829)

fix another sanity error, and refactor/tidy up

Fix a bug in functorLikeTraverse, which was giving wrong answer for tuples

This bug led to Trac #4816, which is hereby fixed

Improve printing for -ddump-deriv

Tighten up what it means to be an "enumeration data constructor"

See Note [Enumeration types] in TyCon, and comments in Trac #4528

Allow enumerations to have phantom arguments.

The bytecode generator was being too eager.
Fixes Trac #4528, or rather, a near variant.

Instance declaration overlap allowed if *either* has -XOverlappingInstances

This satisfies Trac #3877.  Documentation is changed too.
I'm not sure if this should go in 7.0.2.

Fix Trac #4841: behave right with TypeSynonymInstances and NoFlexibleInstances

When we have TypeSynonymInstances without FlexibleInstances we should still
insist on a H98-style instance head, after looking through the synonym.

This patch also make FlexibleInstances imply TypeSynonymInstances.  Anything
else is a bit awkward, and not very useful.

Fix Trac #3731: more superclass subtlety (sigh)

I will add more comments, but I want to commit this tonight,
so the overnight builds get it.

Less verbose debug print

Wibble to InstEnv.instanceHead

Fixes an accidental glitch in T1835

Remove dead code now that we require the bootstrapping compiler be >= 6.12

GHC 6.12 is now needed to build the HEAD

Add libstdc++-4.5.0-1-mingw32-dll-6.tar.lzma to mingw tarballs

Fix recursive superclasses (again).  Fixes Trac #4809.

This patch finally deals with the super-delicate question of
superclases in possibly-recursive dictionaries.  The key idea
is the DFun Superclass Invariant (see TcInstDcls):

     In the body of a DFun, every superclass argument to the
     returned dictionary is
       either   * one of the arguments of the DFun,
       or       * constant, bound at top level

To establish the invariant, we add new "silent" superclass
argument(s) to each dfun, so that the dfun does not do superclass
selection internally.  There's a bit of hoo-ha to make sure that
we don't print those silent arguments in error messages; a knock
on effect was a change in interface-file format.

A second change is that instead of the complex and fragile
"self dictionary binding" in TcInstDcls and TcClassDcl,
using the same mechanism for existential pattern bindings.
See Note [Subtle interaction of recursion and overlap] in TcInstDcls
and Note [Binding when looking up instances] in InstEnv.

Main notes are here:

  * Note [Silent Superclass Arguments] in TcInstDcls,
    including the DFun Superclass Invariant

Main code changes are:

  * The code for MkId.mkDictFunId and mkDictFunTy

  * DFunUnfoldings get a little more complicated;
    their arguments are a new type DFunArg (in CoreSyn)

  * No "self" argument in tcInstanceMethod
  * No special tcSimplifySuperClasss
  * No "dependents" argument to EvDFunApp

IMPORTANT
   It turns out that it's quite tricky to generate the right
   DFunUnfolding for a specialised dfun, when you use SPECIALISE
   INSTANCE.  For now I've just commented it out (in DsBinds) but
   that'll lose some optimisation, and I need to get back to
   this.

Doing the smart canonicalization only if we are not simplifying a Rule LHS.
Also, same thing now applies for adding superclasses.

Moved canonicalisation inside solveInteract

Moreover canonicalisation now is "clever", i.e. it never canonicalizes a class
constraint if it can already discharge it from some other inert or previously
encountered constraints. See Note [Avoiding the superclass explosion]

GHCi linker: Assume non-Haskell libraries are dynamic libs
This works around a segfault we get when trying to load libiconv.a on
some platforms.

Add --version support to ghc-cabal

Don't link the GHC RTS into our C-only programs

Build a copy of ghc-cabal with the in-tree compiler, for the bindist

Add a test that all programs in the bindist were built with the right GHC
They should use the GHC from the build tree, not the bootstrapping compiler.

Fix Trac #4534: renamer bug

The renamer wasn't attaching the right used-variables to a
TransformStmt constructor.

The real modification is in RnExpr; the rest is just
pretty-printing and white space.

White space only

Comments only

Make the case-to-let transformation a little less eager

See Note [Case elimination: lifted case].
Thanks to Roman for identifying this case.

warning fix: don't redefine BLOCKS_PER_MBLOCK

Only reset the event log if logging is turned on (addendum to #4512)

allocate enough room for the longer filename (addendum to #4512)

Fix Windows build: move rtsTimerSignal to the POSIX-only section

Default the value of -dppr-cols when the static flags aren't initialised yet
If GHC's command line options are bad then the options parser uses the
pretty printer before the -dppr-cols flag has been read.

Defensify naked read in LLVM mangler

Formatting only

Always ppr case alts on separate lines

Add -dppr-colsN to set width of dumps

Add -dppr-case-as-let to print "strict lets" as actual lets

Suppress more info with -dsuppress-idinfo

Implement -dsuppress-type-signatures

Add more suppression flags
 -dsuppress-all
 -dsuppress-type-applications
 -dsuppress-idinfo

fix ticket number (#4505)

fix warnings

Catch too-large allocations and emit an error message (#4505)

This is a temporary measure until we fix the bug properly (which is
somewhat tricky, and we think might be easier in the new code
generator).

For now we get:

ghc-stage2: sorry! (unimplemented feature or known bug)
  (GHC version 7.1 for i386-unknown-linux):
        Trying to allocate more than 1040384 bytes.

See: http://hackage.haskell.org/trac/ghc/ticket/4550
Suggestion: read data from a file instead of having large static data
structures in the code.

Export the value of the signal used by scheduler (#4504)

Tweak the "sorry" message a bit

- "sorry! (this is work in progress)\n"
+ "sorry! (unimplemented feature or known bug)\n"

:unset settings support
Added support for settings [args, prog, prompt, editor and stop].
Now :unset supports the same set of options as :set.

Fix Windows memory freeing: add a check for fb == NULL; fixes trac #4506
Also added a few comments, and a load of code got indented 1 level deeper.