I tried this out on the panic we're currently getting for #3103:

ghc-stage2: panic! (the 'impossible' happened)
  (GHC version 7.3.20111128 for x86_64-unknown-linux):
        tcIfaceGlobal (local): not found:
    base:GHC.Word.W#{d 6w}
    [(32R, Type constructor `base:GHC.Word.Word{tc 32R}'),
     (r6O, Identifier `base:GHC.Word.$fNumWord{v r6O}'),
     (r6P, Identifier `base:GHC.Word.$fEqWord{v r6P}'),
     (r6Q, Identifier `base:GHC.Word.$fNumWord1{v r6Q}'),
     (r6R, Identifier `base:GHC.Word.$fNumWord2{v r6R}'),
     (r6S, Data constructor `base:GHC.Word.W#{d r6S}'),
     (r6U, Identifier `base:GHC.Word.W#{v r6U}'),
     (r75, Identifier `base:GHC.Word.$fNumWord_$csignum{v r75}'),
     (r76, Identifier `base:GHC.Word.$fEqWord_$c/={v r76}'),
     (r77, Identifier `base:GHC.Word.$fEqWord_$c=={v r77}')]
{ Main.main
   GHC.defaultErrorHandler
    GHC.runGhc
     GhcMonad.>>=
      GhcMonad.>>=.\
       Main.main'
        Main.doMake
         GhcMake.load
          GhcMake.load2
           GhcMake.upsweep
            GhcMake.upsweep.upsweep'
             GhcMake.reTypecheckLoop
              GhcMake.typecheckLoop
               GhcMake.typecheckLoop.\
                TcRnMonad.initIfaceCheck
                 TcRnMonad.initTcRnIf
                  IOEnv.runIOEnv
                   IOEnv.thenM
                    IOEnv.thenM.\
                     TcIface.typecheckIface
                      TcIface.typecheckIface.\
                       LoadIface.loadDecls
                        LoadIface.loadDecl
                         TcIface.tcIfaceDecl
                          TcIface.tc_iface_decl
                           TcIface.tcIdInfo
                            MonadUtils.foldlM
                             TcIface.tcIdInfo.tcPrag
                              TcIface.tcUnfolding
                               TcIface.tcPragExpr
                                TcIface.tcIfaceExpr
                                 TcIface.tcIfaceAlt
                                  TcIface.tcIfaceDataCon }

 - add getCCSOf# :: a -> State# s -> (# State# s, Addr# #)
   (returns the CCS attached to the supplied object)

 - remove traceCcs# (obsoleted by getCCSOf#)

 - rename getCCCS# to getCurrentCCS#

We now put the before and after filenames into a tree structure,
which vastly improves performance when simulating the delete
commands.

We were generating them from the tcg_tcs field of the TcGblEnv,
but that goes badly wrong when there are top-level Template
Haskell splices, because the tcg_tcs field grows successively.
If we generate record-selector binds for all the TyCons in the
accumulated list, we generate them multiple times for TyCons
earlier in the program.  This what was happening in Trac #5665:
  data T = T { x :: Int }
  $(f 4)  -- Top level splice
  ..more code..
Here the record selector bindings for T were being generated
twice.

Better instead to generate the record-selector bindings in
TcTyClsDecls, right where the new TyCons are being declared (as indeed
they were some time ago).  This pushed me into doing some refactoring:
instead of returning the record bindings, tcTyAndClassDecls adds them
to the tcg_binds field of the TcGblEnv.  I think the result is a bit
nicer, and it has the additional merit of working.

Returns a pointer to the current cost-centre stack when profiling,
NULL otherwise.

This means that both time and heap profiling work for parallel
programs.  Main internal changes:

  - CCCS is no longer a global variable; it is now another
    pseudo-register in the StgRegTable struct.  Thus every
    Capability has its own CCCS.

  - There is a new built-in CCS called "IDLE", which records ticks for
    Capabilities in the idle state.  If you profile a single-threaded
    program with +RTS -N2, you'll see about 50% of time in "IDLE".

  - There is appropriate locking in rts/Profiling.c to protect the
    shared cost-centre-stack data structures.

This patch does enough to get it working, I have cut one big corner:
the cost-centre-stack data structure is still shared amongst all
Capabilities, which means that multiple Capabilities will race when
updating the "allocations" and "entries" fields of a CCS.  Not only
does this give unpredictable results, but it runs very slowly due to
cache line bouncing.

It is strongly recommended that you use -fno-prof-count-entries to
disable the "entries" count when profiling parallel programs. (I shall
add a note to this effect to the docs).

This field was doing nothing.  I think it originally appeared in a
very old incarnation of the new code generator.

This is a vital wibble to:
 f7cf3dcd * Be a bit less gung-ho in exprIsConApp_maybe

that evVarPred.cc_id must be equal to ctPred
needs no longer be true.

In GHC, this provides an easy way to call a C function via a C wrapper.
This is important when the function is really defined by CPP.

Requires the new CApiFFI extension.

Not documented yet, as it's still an experimental feature at this stage.

Details:
isReflCo is no longer reliable for detection of no-rewriting/flattening
since we are using cached reflexivity solved goals. Introduced a boolean
flag in the flattener for this purpose, instead.

Adding commentary, and fixing a knot-tie related bug.

Commentary only.

1) Stopped rewriting and caching solveds in the inerts because
profiling showed that a lot of time was spent on rewriting
already solved goals.

2) Optimisations in zonkEvBinds for common-case
evidence bindings generated from the constraint solver.

3) Now solved goals cache their evidence terms, so that we can more
aggressively optimize Refl coercions during constraint solving.
This patch also includes a rewrite of rewriteInertEqsFromInertEq
which greatly improves its efficiency.

0) Typo in panic message.
1) prioritization of equalities over family equalities in the worklists.
2) rewriting of inert substitutions and solveds on-the-spot instead of
   kicking them out in the inerts. This required a monadic map over
   substitutions hence the modifications in UniqFM.
3) Just comments and removing stale commented code.

4) Useful SCC for simplifyInfer.

5) Making CoreStats outputable.

This was responsible for Trac #5001, and it was a real bug;
an inlining could be lost.

In particular, don't second-guess callSiteInline by
effectively inlining function call.  This eliminates
the "Interesting!" debug messages we've been getting.
I concluded they weren't interesting enough to account
for the extra complexity!

Some platforms use linkers that don't support the --hash-size=31 and
--reduce-memory-overheads flags.