TickBox representation change

This changes the internal representation of TickBoxes,
from
        Note (TickBox "module" n)  <expr>
into

        case tick<module,n> of
          _ -> <expr>

tick has type :: #State #World, when the module and tick numbe
are stored inside IdInfo.

Binary tick boxes change from

         Note (BinaryTickBox "module" t f) <expr>

into

          btick<module,t,f> <expr>

btick has type :: Bool -> Bool, with the module and tick number
stored inside IdInfo.

Fixing Alts to reflect Alternatives, rather than every pattern match in Hpc.

fix to isNormalComment for non-Haddock mode, and some cleanup

Haddock documentation comments weren't being treated as comments even
without the -haddock flag.  Fixes nofib/spectral/simple, and probably
others.

Make the non-threaded-RTS threadDelay wait at least as long as asked

retain arity for let-bound vars in simplifier

Initial support for x86_64-darwin

Basic -fvia-C code generation is there, not much testing.

Support I64->I32 casts in the NCG, and use them for I64->Integer conversions

We can avoid using any other long long operations in PrimOps.cmm.
One more step towards compiling the RTS using the NCG.

NCG: Really avoid the need for memory-to-memory moves in the register allocator

This is a follow-up to "NCG: Handle loops in register allocator".
The newly-introduced invariant that every virtual register is always assigned to
the same spill slot wasn't kept under all circumstances.
*Now* memory-to-memory moves should never be required when compiling hand-written
cmm code.

i386-darwin: disable use of code stubs for dynamic linking

We can't use lazy binding for tail-calls accross shared libraries, because dyld
will crash due to incorrect stack layout. We can't get the stack alignment right for
both cross-library tailcalls and foreign calls, so we have to bypass the stub code altogether
and load the address to branch to from the non-lazy pointer table.

Support RelocatableReadOnlyData section type in CmmParse, and use it where needed in AutoApply

This is needed for position-independent code on Mac OS X
(both i386 and powerpc), when compiling the RTS with -fasm.

Cast switch scrutinees to W_ in AutoApply.cmm

... and make CmmLint check for this problem.
This doesn't matter for -fvia-C, but passing a halfword to a switch
will make the NCG generate crashing code.

Add some Outputable instances

Change a comma to a colon

ghc-pkg: New command 'check' and made 'list' indicate broken packages
Command 'check': print a list of all packages that are broken and
                 which dependencies they are missing.
Command 'list': updated by making it put brackets around broken
                packages.

Fix constraint handling for lazy patterns

Lazy patterns are quite tricky!  Consider
f ~(C x) = 3
Can the Num constraint from the 3 be discharged by a Num dictionary
bound by the pattern?  Definitely not!

See Note [Hopping the LIE in lazy patterns] in TcPat

The type checker wasn't ensuring this, and that was causing all
manner of strange things to happen.  It actually manifested as a
strictness bug reported by Sven Panne.

I've added his test case as tcrun040.

Warning police: Removed unused variable

small stats fix

Make SpecConstr more aggressive, by neglecting reboxing

SpecConstr was conservative about avoiding reboxing (see Note [Reboxing])
but that meant it lost useful opportunities.  This patch makes it much
more aggressive, but at the risk of doing some reboxing.

Actually, the strictness analyser has the same property (it's possible
for it to generate reboxing code, and thus increase allocation), but we
don't worry so much about that.  Maybe we should.

Ideally, one would do some more sophisticated analysis that spotted
the reboxing cases without excluding the useful ones.

But meanwhile, let's try this.

Drop redundant parens in pretty-printing

Improve handling of implicit parameters

A message to Haskell Cafe from Grzegorz Chrupala made me realise that
GHC was not handling implicit parameters correctly, when it comes to
choosing the variables to quantify, and ambiguity tests.  Here's the
note I added to TcSimplify:

Note [Implicit parameters and ambiguity]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
What type should we infer for this?
f x = (show ?y, x::Int)
Since we must quantify over the ?y, the most plausible type is
f :: (Show a, ?y::a) => Int -> (String, Int)
But notice that the type of the RHS is (String,Int), with no type
varibables mentioned at all!  The type of f looks ambiguous.  But
it isn't, because at a call site we might have
let ?y = 5::Int in f 7
and all is well.  In effect, implicit parameters are, well, parameters,
so we can take their type variables into account as part of the
"tau-tvs" stuff.  This is done in the function 'FunDeps.grow'.

The actual changes are in FunDeps.grow, and the tests are
tc219, tc219

Fix name-capture bug in rule matching

The matching algorithm for RULES should respect alpha-conversion, but it
wasn't doing so.  In particular, if the names of the template variables
clashed with a variable in scope at the call site, bad things could happen
(it showed up as a CoreLint failure when compiling nofib/real/parser)

This patch fixes the problem; see Note [Template binders]

Test is in simplCore/should_compile/spec002, but nofib -O2 in
real/parser, real/fulsom

Improve hashing of expressions

We were getting too many cases where different expressions map to the
same hash code (which shows up in CSE). This patch tries to improve
the hash algorithm a bit.

Use existing Ord instance on Int, saving code

Use existing function uniqAway instead of duplicating code

Gather constraints in program order

Provoked by a suggestion of Simon's, this patch makes a half-hearted attempt
to gather constraints in program order, so that we tend to report an error
at its first occurrence, rather than its last.  Examples:
mdofail001, tcfail015

It's "half-hearted" because generally-speaking the typechecker does not
guaranteed to keep constraints in order; it treats them as a set.  Nevertheless
this very small change seems to improve matters, so it seems a good one.

Simplify TcSimplify, by removing Free

For a long time TcSimplify used a three-way classification of constraints,
into  Free
Irred
ReduceMe
(see the data type WhatToDo).  In the new world of implication constraints,
the Free case does not make so much sense, and I managed to elminate it
altogether, thus simplifying the story somewhat.  Now WhatToDo has constructors
Stop
ReduceMe

There should be no change in behaviour.

fix failing assertion

Improve recovery in hptRules

Refactoring of where tcSimplifyTop happens

We want to do tcSimplifyTop after checkMain, because checkMain can add
useful type information that eliminates ambiguity.  E.g.
main = return undefined

This is the way it used to be in 6.6, and I think I mistakenly moved it
when doing implication constraints. This patch effectively puts it back
the way it was.

Cures the cg053 failure.

Retain simplifications of implication constraints

When simplifying an implication constraint (reduceImplication), if we make
progress, make a new implication constraint for the result.  If we don't
do this, we get a constraint that can be simplified in a unique way,
and that in turn confuses reportNoInstance

Improve error messages slightly

refactor code for memInventory()

allocatePinned(): fix n_large_blocks count after allocating a new block

fix bug in memInventory() giving false memory leak errors
fixes ffi009(threaded1)

Remove the concept of stableRoots.

StableRoots opened new possibilities in the world
of plugins with their ability to link partially
applied closures against object code.
Exporting '(fn pluginwideState)' severely reduced
the complexity of HIDE's plugin system. The previous
system of global variables was both fragile and hard
to scale.

Good bye, StableRoots. We sure had some fun.

small fix to DEBUG case in coalesce/freeGroup patch

optimisation to freeGroup() to avoid an O(N^2) pathalogical case
In the free list, we don't strictly speaking need to have every block
in a coalesced group point to the head block, although this is an
invariant for non-free blocks.  Dropping this invariant for the free
list means that coalesce() is O(1) rather than O(N), and freeGroup()
is therefore O(N) not O(N^2).

The bad case probably didn't happen most of the time, indeed it has
never shown up in a profile that I've seen.  I had a report from a
while back that this was a problem with really large heaps, though.
Fortunately the fix is easy.

Fix ":i Maybe", noticed by Claus Reinke
It looks like this was just commented out while FC was being developed.

put the unsafeCoerce trace inside DEBUG, to avoid test failures

Fix printf$LDBLStub workaround for Darwin

Apparently, the original fix never really worked due to typos and oversights.

Mac OS X mangler: follow some minor gcc changes

Add ppr for the MKPAP case, and rearrange the other cases to match the datatype

Avoid problems with unaligned loads on alpha/mips/mipsel/arm
This is overly conservative, but it works.

reorganise PAPI configuration: off by default, even if library is found
Add GhcRtsWithPapi=YES to mk/build.mk to turn it on

No special Papi measurements taken by default

whitespace

Cosmetic improvements, no change in Papi functionality.

better error messages when PAPI_library_init() fails

alter PAPI help message slightly

Added configure gadgets to detect Papi, and fixed build problems

Selection of PAPI events via RTS command line

Addition of PAPI to RTS
This patch still requires the addition of the USE_PAPI
define to compile with PAPI. Also, programs must be
compiled and linked with the appropriate library flags
for papi.

Don't force -static on mips

Don't make ghc threaded if GhcNotThreaded is YES

Cope with big endian float word order on little endian machines

Emit .bat versions of -inplace scripts on Windows platforms (Cabal-friendlier)

Emit .bat version of -inplace script on Windows platforms

restore compilation with 5.04

remove unused includes, now that Storage.h & Stable.h are included by Rts.h

move newSpark() prototype to RtsExternal.h to avoid warnings

mark stop event handle as invalid once closed, making shutdowns more graceful.

simplify the generated C a little by removing some casts.

fix types in generated C for comparison MachOps
C comparisons have type 'int', but our generated code assumed they had
type 'StgWord', leading to (very) occasional warnings from gcc.

Remove unused Name imort, and add a comment explaining why pragmas are disabled

Document new -L RTS flag

Be compatible with older C standards

hp2ps_config_mk

Add variables for hp2ps to config.mk.in

hp_slash_fix

Fix output of cost-centre stacks so that the slashes appear in the correct place

Please include this patch in the 6.6 branch as well as HEAD

rts_ccs_length

Add the -L RTS flag to control the length of the cost-centre stacks reported in
a heap profile.

Please include this change in the 6.6 branch as well as HEAD

multipage_hp2ps

Add support for splitting the key index over multiple pages in hp2ps
Multipage support can be requested with the -M command-line flag
or inferred if the number of bands requested is greater than 20
(the limit on the number of bands displayed has been removed)

Please include this change in the 6.6 branch as well as HEAD

Fix (yet another) odd interaction between selector thunks and compacting GC
This should fix errors of the form

  internal error: scavenge_mark_stack: unimplemented/strange closure
    type 28 @ 0x2b92e5f79960

But since it's quite difficult to reproduce the error, I can't be 100%
certain it's gone.  I certainly can't reproduce it again after the
fix, anyway.

Add literal-shift rewrite rules

This is a re-factored version of Sam Bronson's patch

Need to take care with logical shifts.

Fixups to PelRules (esp using intResult, wordResult)

In PrelRules we carefully use 'intResult' to trim off the overflow in
compile-time calculations, but we were not doing so consistently.  This
patch fixes that, I think, and adds type signatures

Fix typo "comand" (trac #965)

Zap stray whitespace in lhs formatting

Fix up .lhs delimiters a bit

find fop.sh

the fop bundle contains fop.bat and fop.sh, but not fop;
let configuration find the latter.

Doc nit in OccName

Remove STANDALONE_PACKAGE bits that had escaped the removal

Make StablePtr and friends visible, this seems to be necessary for 64bit architectures

Make all needed prototypes visible to avoid warnings

Added a comment about se.info.type being used uninitialized

Added a workaround for format specifier mismatch

Use implication constraints to improve type inference

Cosmetics and debug printing only

Cosmetics only

Add HsUtils.unguardedGRHSs, and use it

Comments and cosmetics only

Add new utility function, partitionWith

Trim imports

Patch to demand analyser, to handle polymorphism in zipWithDmds

Do not print HsDoc field when pretty-printing patterns (messes up error message)

use the right $(HC) for stage 3

remove unused STANDALONE_PACKAGE stuff

update flag settings after files were relocated

Comment out deeply suspicious (and unused) function insertStableSymbol

The function insertStableSymbol looks utterly wrong, because it
coerces a value of type 'a' to an Addr#!  That was in turn making the
code generator get confused (now improved), but since insertStableSymbol
isn't used at all, I'm just commenting it out.

Meanwhile, this patch also enhances CoreToStg to report the most egregious
cases where an unsafe coerce is going to confuse the code generator.

Layout and comments only

Warn only of explicit imports that are unused (test is mod177)

This is really a long-standing bug.  See test mod177.

Various debugging print changes; nothing exciting

Tidy up substitutions

The new simplifer stuff exposed the fact that the invariants on the
TvSubstEnv and IdSubstEnv were insufficiently explicit.  (Resulted in
a bug found by Sam Brosnon.)

This patch fixes the bug, and tries to document the invariants pretty
thoroughly. See
Note [Extending the TvSubst] in Type
Note [Extenting the Subst]   in CoreSubst

(Most of the new lines are comments.)