See Note [Eta-expanding INLINE things] in DsBinds

This is to fix a performance bug that Roman was encountering.

The log file format was still using 32 bits, this just updates the
header file to match; there should be no functional changes.

Due to darcs confusion, I managed to leave out part of the patch for
#1185.  This should make 1185(threaded1) go through now.

I'd forgotten the case of single-method classes! I've also improved
the documentation. See
  Note [ClassOp/DFun selection]
  Note [Single-method classes]
both in TcInstDcls

Someone on IRC reported that they were encountering a strange missing
module error from GHC, and it turned out that they had mtl-1.1.0.2
installed in both the global and local DB, with the same
InstalledPackageId.  The two packages should be interchangeable, but
we were forgetting to eliminate duplicates in part of the
package-processing phase in GHC.

Really I should switch this code over to use the new PackageIndex data
type in Cabal, which ought to make things simpler.

And add a comment explaining why these options are here

Patch 1/2: second part of the patch is to libraries/base

This time without dynamic linker hacks, instead I've expanded the
existing rts/Globals.c to cache more CAFs, specifically those in
GHC.Conc.  We were already using this trick for signal handlers, I
should have realised before.

It's still quite unsavoury, but we can do away with rts/Globals.c in
the future when we switch to a dynamically-linked GHCi.

* Core Lint now does full checking of kinds and coercion terms
  which picks up kind errors in coercions that were previously
  simply not checked for

* Coercion.lhs now provides optCoercion which optimises coercion
  terms.  It implements all of Dimitrios's rules

* The constructors for coercion terms now make no attempt to be
  "smart"; instead we rely solely on the coercion optimiser

* CoercionTyCons in TyCon.lhs always had a "custom" kinding rule
  (the coKindFun field of CoercionTyCon) but its type was not 
  clever enough to do both 
     (a) *figure out the result kind*, assuming the whole thing
         is well-kinded in the first place
     (b) *check* the kinds of everything, failing gracefully if
         they aren't right. 
  We need (b) for the new CoreLint stuff. The field now has type
        CoTyConKindChecker
  which does the job nicely.

The native back ends had difficulties with loops;
in particular the code for branch-chain elimination
could run in infinite loops or drop basic blocks.
The old codeGen didn't expose these problems.

Also, my fix for T3286 in the new codegen was getting
applied to too many (some wrong) cases; a better pattern
match fixed that.

Wrote a generic function to extend dataflow results for safe foreign calls.
Should be able to throw it away when we change the representation of safe foreign calls.

When we used derived pointers into the middle of an object,
we need to keep the pointer to the start of the object live.
We use a "fat machine instruction" with the primitive MO_Touch
to propagate this information through the back end.

Apparently, the arguments should be sorted by pointerhood.
While we're at it, I rewrote the code that assigns registers
and stack space to function call and return parameters.

If the scrutinee is bottom, the generated Cmm code could have a
type error when the case arm expected an unboxed floating-point
value (even though the arm should never be reached).
Now, we detect this case and avoid producing the type-incorrect
assignment.

This means that the docs get built with the correct relative paths.
When installing, the absolute path will still be used.

You can now have multiple versions of a package installed, and
gen_contents_index will do the right thing.

Patches from Goetz Isenmann <info@goetz-isenmann.de>, slightly updated
for HEAD (the method for configuring platforms in configure.ac has
changed).

Patch submitted by Matthias Kilian <kili@outback.escape.de>,
re-recorded against HEAD by me, with a comment added.

Patch submitted by Matthias Kilian <kili@outback.escape.de>

The Core Lint warnings are new.  There's only one at the moment,
namely one to identify recursive INLINE things:

    [RHS of $c>>_als :: forall s_afT a_alJ b_alK.
                        Cpr001_imp.StateTrans s_afT a_alJ
                        -> Cpr001_imp.StateTrans s_afT b_alK
                        -> Cpr001_imp.StateTrans s_afT b_alK]
    INLINE binder is loop breaker: $c>>_als

This is definitely non-fatal, and typically gets unravelled after
another simplifier run anyway.  So I'm suppressing such warnings
for the testsuite, when -dno-debug-output is on.

The main change is using SimplUtils.updModeForInlineRules
doesn't overwrite the current setting, it just augments it.

We preserve the InlineRule on loop breakers, in the hope that they'll
stop being a loop breaker later.  So don't inline them!

See Note [Preserve strictness when floating coercions]

This ensures that messages coming out with -dshow-passes 
also come out with -dverbose-core2core

In preparation for implementing the PushC rule for coercion-swizzling
in the Simplifier, I had to inmplement the three new decomposition
operators for coercions, which I've called csel1, csel2, and cselR.

     co :: ((s1~t1) => r1) ~ ((s2~t2) => r2)
     ---------------------------------------
              csel1 co :: s1~s2

and similarly csel2, cselR.

On the way I fixed the coercionKind function for types of form
          (s1~t2) => r2
which currently are expressed as a forall type.  

And I refactored quite a bit to help myself understand what is
going on.

- It might be worthwhile to MERGE this to 6.12, BUT somebody should validate
  it on PPC/Mac OS X first.