GitLab

The -fexpose-all-unfoldings flag arranges to put unfoldings for *everything*
in the interface file.  Of course,  this makes the file a lot bigger, but
it also makes it complete, and that's great for supercompilation; or indeed
any whole-program work.

Consequences:
  * Interface files need to record loop-breaker-hood.  (Previously,
    loop breakers were never exposed, so that info wasn't necessary.)
    Hence a small interface file format change. 

  * When inlining, must check loop-breaker-hood. (Previously, loop
    breakers didn't have an unfolding at all, so no need to check.)

  * Ditto in exprIsConApp_maybe.  Roman actually tripped this bug, 
    because a DFun, which had an unfolding, was also a loop breaker

  * TidyPgm.tidyIdInfo must be careful to preserve loop-breaker-hood

So Id.idUnfolding checks for loop-breaker-hood and returns NoUnfolding
if so. When you want the unfolding regardless of loop-breaker-hood, 
use Id.realIdUnfolding.

I have not documented the flag yet, because it's experimental.  Nor
have I tested it thoroughly.  But with the flag off (the normal case)
everything should work.

This is a pretty big patch, but it has a very local effect.
It affects only the binder-swap mechanism in OccurAnal, which
was not working well becuase it's more subtle than I'd realised
(See Note [getProxies is subtle]).  I think this does a much
better job.

See Note [DFuns should not be loop breakers]

These two optimisations were originally done by SimplUtils.mkCase
*after* all the pieces have been simplified.  Some while ago I
moved them *before*, so they were done by SimplUtils.prepareAlts.
It think the reason was that I couldn't rely on the dead-binder 
information on OutIds, and that info is useful in these optimisations.

However, 
 (a) Other changes (notably moving case-binder-swap to OccurAnal)
     have meant that dead-binder information is accurate in 
     OutIds

 (b) When there is a cascade of case-merges, they happen in 
     one sweep if you do it after, but in many sweeps if you
     do it before.  Reason: doing it after means you are looking
     at nice simplified Core.

The size computation was treating gigantic case expressions as
practically free, which they really aren't.  It was exacerbated by
recent decisions to charge 0 for naked variables and constructors, so
the RHS of the case might look free too.  A good example was 
Foreign.C.Error.errnoToIOError, which hsa lots of join points
that were getting inlined way to vigorously, so we had:

  *** Simplifier Phase 2 [main]:
      Result size = 2983
  *** Core Linted result of Simplifier mode 2 [main], iteration 1 out of 4:
      Result size = 640327
  *** Core Linted result of Simplifier mode 2 [main], iteration 2 out of 4:
      Result size = 1659

Notice that gigantic intermediate!

This patch adds a small charge for each *alternative*.  Of course,
that'll also mean that there's a bit less inling of things involving
case expressions.

The file rts/win32/libHSbase.def contains a list of all the 
symbols from the base library that the RTS needs. 

When building the RTS into a DLL on Windows, we want to link the DLL
for the RTS before we link the DLL for the base library. We use 
libHSbase.def to make the "import library" libHSbase.so.a, which 
contains stubs for each of the symbols from the base library that
the RTS needs.

This meakes it easier to correctly clean libffi

We now use the tarball in the ghc-tarballs repo

On MSYS
    sed 's/.*[ \t]//'
wasn't matching
    version:<tab>1.0
so I've switched to
    's/.*[[:space:]]//'
which works on Linux, cygwin and MSYS.

So we don't try to recreate directories just because they are older
than mkdirhier, since mkdirhier won't touch them.

I can't quite remember when I spotted this, but exprIsHNF (and
similarly exprIsConLike) should ignore enclosing let-bindings,
since they don't affect termination.