GitLab

This is a much more robust way to do recompilation checking.  The idea
is to create a fingerprint of the ABI of an interface, and track
dependencies by recording the fingerprints of ABIs that a module
depends on.  If any of those ABIs have changed, then we need to
recompile.

In bug #1372 we weren't recording dependencies on package modules,
this patch fixes that by recording fingerprints of package modules
that we depend on.  Within a package there is still fine-grained
recompilation avoidance as before.

We currently use MD5 for fingerprints, being a good compromise between
efficiency and security.  We're not worried about attackers, but we
are worried about accidental collisions.

All the MD5 sums do make interface files a bit bigger, but compile
times on the whole are about the same as before.  Recompilation
avoidance should be a bit more accurate than in 6.8.2 due to fixing
#1959, especially when using -O.

In an instance declaration, omitted methods get a definition that
uses the default method.  We used to generate source code and feed it
to the type checker.  But tc199 shows that is a bad idea -- see
Note [Default methods in instances] in TcClassDcl.

So this patch refactors to insteadl all us to generate the 
*post* typechecked code directly for default methods.

Refactoring reduces code and improves error messages

This bug allowed, for example

  f = let x = ( 1#, 'x' ) in x

which is ill-typed because you can't put an unboxed value in a tuple.
Core Lint fails on this program.

The patch makes the program be rejcted up-front.

This is the optimisation level recommended when compiling DPH programs. At the
moment, it is equivalent to -O2 -fno-method-sharing -fdicts-cheap
-fmax-simplifier-iterations20 -fno-spec-constr-threshold.

We want -Odph to be a dynamic flag and that should imply -fno-method-sharing.
This doesn't add a lot of complexity.

Try to load interfaces in getLinkDeps

Trac #2273 showed a case in which 'seq' didn't cure the space leak
it was supposed to.  This patch does two things to help

a) It removes a now-redundant special case in Simplify, which
   switched off the case-binder-swap in the early stages.  This
   isn't necessary any more because FloatOut has improved since
   the Simplify code was written.  And switching off the binder-swap
   is harmful for seq.

However fix (a) is a bit fragile, so I did (b) too:

b) Desugar 'seq' specially.  See Note [Desugaring seq (2)] in DsUtils
   This isn't very robust either, since it's defeated by abstraction, 
   but that's not something GHC can fix; the programmer should use
   a let! instead.

If the value is > 2^63 then we need to work out its value mod 2pi,
and apply the operation to that instead.

This turned out not to be too hard, just a matter of figuring out the
correct argument list size by peeking inside FunPtr's type argument,
and in the C backend we have to emit an appropriate prototype for the label.

Needed in lieu of -XRelaxedPolyRec

I also changed con2tag_Foo and related names to follow the standard
practice of prefixing $ to compiler-generated names, so now we have
$con2tag_Foo.

  
Previously we declared all external labels with type StgWord[],
because the same label might be used at different types in the same
file, e.g. if there are multiple foreign import declarations for the
same function.  However, we have to declare called functions with the
right type on Windows, because this is the only way to make the
compiler add the appropriate '@n' suffix for stdcall functions.

Related to this is the reason we were getting mangler complaints
(epilogue mangling) when compiling the RTS with -fvia-C.  The function
barf() doesn't return, but we had lost that information by declaring
our own prototypes, and so gcc was generating extra code after the
call to barf().

For more details see
http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/Backends/PprC