Make lazy unlifted bindings an error by default.

This was supposed to happen a long time ago, but later is better than
never. This makes `-fwarn-lazy-unlifted-bindings` into a no-op (with its
own warning) to be removed in GHC 7.10.

This fixes #8022.

Signed-off-by: Austin Seipp <austin@well-typed.com>
Fix BCO bitmap generation on 32-bit platforms (#8377)

On 32-bit platforms, the bitmap should be an array of
32-bit words, not Word64s.

Signed-off-by: Austin Seipp <austin@well-typed.com>
Remove extra space in LIBFFI_CFLAGS (#8349)

Signed-off-by: Austin Seipp <austin@well-typed.com>
Add a note about Proxy# to the user guide

Signed-off-by: Austin Seipp <austin@well-typed.com>
Mention the Foldable and Traversable instances for Const r in the user guide

Signed-off-by: Austin Seipp <austin@well-typed.com>
Fix AMP warnings for explicit Prelude imports (#8004)

No AMP warnings will be issued anymore when the name is not imported
from Prelude anymore. For example, a local definition of 'join' is now
legal in modules containing 'import Prelude (map)' for example. This
allows better future-proofing of libraries.

See also http://ghc.haskell.org/trac/ghc/ticket/8004#comment:16

Authored-by: David Luposchainsky <dluposchainsky@gmail.com>
Signed-off-by: Austin Seipp <austin@well-typed.com>
Compare against pRELUDE_NAME instead of "Prelude"
Typos in users' guide
Expand the commentary in Note [syntax of cmm files]
Remove use of R9, and fix associated bugs

We were passing the function address to stg_gc_prim_p in R9, which was
wrong because the call was a high-level call and didn't declare R9 as
a parameter.  Passing R9 as an argument is the right way, but
unfortunately that exposed another bug: we were using the same macro
in some low-level Cmm, where it is illegal to call functions with
arguments (see Note [syntax of cmm files]).  So we now have low-level
variants of STK_CHK() and STK_CHK_P() for use in low-level Cmm code.
use a nat, not StgWord8, for gc_type
use StgWord not StgWord8 for wakeup

volatile StgWord8 is not guaranteed to be atomic.
Globally replace "hackage.haskell.org" with "ghc.haskell.org"
grammar fix
Remove a couple of unnecessary/outdated references to HBC
Clarification in the docs for INLINE

People often jump to the conclusion that functions aren't inlined
unless you say INLINE, so clarify the documentation to emphasize the
fact that you shouldn't normally need to use INLINE unless you need to
override the defaults.
Add back a comment that got lost
Add layout to MultiWayIf (#7783)

This makes it possible to write

x = if | False -> if | False -> 1
                     | False -> 2
       | True -> 3

Layout normally inserts semicolons between declarations at the same
indentation level, so I added optional semicolons to the syntax for
guards in MultiWayIf syntax.  This is a bit of a hack, but the
alternative (a special kind of layout that doesn't insert semicolons)
seemed worse, or at least equally bad.
comment update
Lift an unnecessary assumption in the demand analyser (fix Trac #8329)

Here's the Note about the (simple) fix.  Apparently #8329 prevented all
23 packages of the Snap framework from compiling.

Note [Demand transformer for a ditionary selector]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If we evaluate (op dict-expr) under demand 'd', then we can push the demand 'd'
into the appropriate field of the dictionary. What *is* the appropriate field?
We just look at the strictness signature of the class op, which will be
something like: U(AAASAAAAA).  Then replace the 'S' by the demand 'd'.

For single-method classes, which are represented by newtypes the signature
of 'op' won't look like U(...), so the splitProdDmd_maybe will fail.
That's fine: if we are doing strictness analysis we are also doing inling,
so we'll have inlined 'op' into a cast.  So we can bale out in a conservative
way, returning topDmdType.

It is (just.. Trac #8329) possible to be running strictness analysis *without*
having inlined class ops from single-method classes.  Suppose you are using
ghc --make; and the first module has a local -O0 flag.  So you may load a class
without interface pragmas, ie (currently) without an unfolding for the class
ops.   Now if a subsequent module in the --make sweep has a local -O flag
you might do strictness analysis, but there is no inlining for the class op.
This is wierd so I'm not worried about whether this optimises brilliantly; but
it should not fall over.