GitLab

Occasionally people write very large recursive groups of definitions. 
In general we desugar these to a single definition that binds tuple,
plus lots of tuple selectors.  But that code has quadratic size, which
can be bad.

This patch adds a new case to the desugaring of bindings, for the
situation where there are lots of polymorphic variables, but no
dictionaries.  (Dictionaries force us into the general case.)

See Note [Abstracting over tyvars only].  

The extra behaviour can be disabled with the (static) flag

	-fno-ds-multi-tyvar

in case we want to experiment with switching it on or off.  There is
essentially-zero effect on the nofib suite though.

I was provoked into doing this by Trac #1136.  In fact I'm not sure
it's the real cause of the problem there, but it's a good idea anyway.

From the docs:
   <para>Suppress any unsolicited debugging output.  When GHC
     has been built with the <literal>DEBUG</literal> option it
     occasionally emits debug output of interest to developers.
     The extra output can confuse the testing framework and
     cause bogus test failures, so this flag is provided to
     turn it off.</para>

Several changes in this patch, partially bug fixes, partially new code:
o bug fixes in ZipDataflow
   - added some checks to verify that facts converge
   - removed some erroneous checks of convergence on entry nodes
   - added some missing applications of transfer functions
o changed dataflow clients to use ZipDataflow, making ZipDataflow0 obsolete
o eliminated DFA monad (no need for separate analysis and rewriting monads with ZipDataflow)
o started stack layout changes
   - no longer generating CopyIn and CopyOut nodes (not yet fully expunged though)
   - still not using proper calling conventions
o simple new optimizations:
   - common block elimination
      -- have not yet tried to move the Adams opt out of CmmProcPointZ
   - block concatenation
o piped optimization fuel up to the HscEnv
   - can be limited by a command-line flag
   - not tested, and probably not yet properly used by clients
o added unique supply to FuelMonad, also lifted unique supply to DFMonad

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

Modules that need it import it themselves instead.

This patch removes the ndpFlatten directory and the -fflatten static flag.
This code has never worked and has now been superceded by vectorisation.

It turns out that -prof -threaded works (modulo some small changes),
because all the data structures used in profiling are only accessed by
one thread at a time, at long as we don't use +RTS -N2 or higher.  So
this patch enables the use of -prof -threaded, but an error is given
if you ask for more than one CPU with +RTS -N.

This patch addresses a problem that Roman found in SpecConstr.  Consider:

foo :: Maybe Int -> Maybe Int -> Int
foo a b = let j b = foo a b
           in
           case b of
             Nothing -> ...
             Just n  -> case a of
                          Just m  -> ... j (Just (n+1)) ...
                          Nothing -> ... j (Just (n-1)) ...

We want to make specialised versions for 'foo' for the patterns
	Nothing  (Just v)
	(Just a) (Just b)

Two problems, caused by the join point j.  First, j does not
scrutinise b, so j won't be specialised f for the (Just v) pattern.
Second, j is defined where the free var 'a' is not evaluated.

Both are solved by brutally inlining j at its call sites.  This risks
major code bloat, but it's relatively quick to implement.  The flag
	-fspec-inline-join-points
causes brutal inlining for a 
	non-recursive binding
	of a function
	whose RHS contains calls
	of a recursive function

The (experimental) flag is static for now, and I have not even
documented it properly.

This flag does nothing, and should have been removed ages ago. (GHC
no longer does update-in-place.)

MERGE to 6.8 branch

This is intended only for debugging use: it makes it easier to
compare two variants without the variations between uniques mattering.

(Of course, you can't actually feed the output to the C compiler
or assembler and expect anything sensible to happen!)

Fixes building with -Werror (i.e. validate) and GHC < 6.6

Older GHCs can't parse OPTIONS_GHC.
This also changes the URL referenced for the -w options from
WorkingConventions#Warnings to CodingStyle#Warnings for the compiler
modules.

Ugly hack; see comments for details

Use standard isPrefixOf/isSuffixOf instead.

* -{short,long}-ghci-banner are now dynamic options, so you can put
  ":set -short-ghci-banner" in .ghci
* The -v2 banner information now always tells you what compiler booted GHC,
  and what stage the compiler is. Thus we no longer assume that stage > 1
  iff GHCI is defined.

Add -short-ghci-banner and -long-ghci-banner.  The default is long, which is
the current behavior.  The short banner prints a one-line introduction with
only the version, web site, and ":? for help" message.

- parseStaticFlags is now not required, but if it is called, it should
  be called only once and before newSession, otherwise you get an
  error.
- parseStaticFlags is exported from GHC

Argubly rewrite rules should not fire with -O0, and it turns
out that when compiling GHC.Base with -O0 we get a crash if
the rewrite rules do fire (see Note [Scoping for Builtin rules]
in PrelRules).

So unless someone yells, rewrite rules are off with -O0.

The new (now dynamic) flag is 
    -frewrite rules (with -fno-rewrite-rules to disable)

The old (static) flag -frules-off is gone.

-ticky is the command-line flag for ticky-ticky profiling now, but
internally, the -fticky-ticky flag was used to represent whether ticky
was on. This led to link errors if the user supplied -fticky-ticky but
not -ticky (ticky code would be generated but the wrong RTS library
would be passed to the linker). I removed references to -fticky-ticky
-- now, only the way flags dictate whether ticky is on, and
-fticky-ticky is no longer accepted as a command-line option.

When a snapshot version number is included, opt_HiVersion tends to exceed the range of a 32bit Int.

MERGE TO STABLE