Tweak layout for alternative layout rule

Link all dynamic libraries with the correct install_name on Mac OS/X.
This is a rerecord of
    Stephen Blackheath <oversensitive.pastors.stephen@blacksapphire.com>**20090930222855
to avoid conflicts.

Document the new -dylib-install-name option in the user's guide.

Add -dylib-install-name option to GHC so the install name can be set for dynamic libs on Mac OS/X.

Force -fPIC when linking against dynamic libraries on Mac OS/X.
Otherwise you get
/tmp/ghc7602_0/ghc7602_0.s:207:0:
   non-relocatable subtraction expression, "___stginit_Lib_dyn" minus "L1x2;4"
/tmp/ghc7602_0/ghc7602_0.s:207:0:
   symbol: "___stginit_Lib_dyn" can't be undefined in a subtraction expression

evaluate_large: evaluate large objects to bd->dest rather than gen->to
This fixes aging of large objects in the new scheme.  Bug found by
perf/space_leaks/space_leak_001.  Yay perf regressions tests.

Correction to the allocation stats following earlier refactoring

export g0

GC refactoring, remove "steps"

The GC had a two-level structure, G generations each of T steps.
Steps are for aging within a generation, mostly to avoid premature
promotion.

Measurements show that more than 2 steps is almost never worthwhile,
and 1 step is usually worse than 2.  In theory fractional steps are
possible, so the ideal number of steps is somewhere between 1 and 3.
GHC's default has always been 2.

We can implement 2 steps quite straightforwardly by having each block
point to the generation to which objects in that block should be
promoted, so blocks in the nursery point to generation 0, and blocks
in gen 0 point to gen 1, and so on.

This commit removes the explicit step structures, merging generations
with steps, thus simplifying a lot of code.  Performance is
unaffected.  The tunable number of steps is now gone, although it may
be replaced in the future by a way to tune the aging in generation 0.

fix error message on Windows (fixes rtsflags001)

Fix loading of annotations

The problem was that we collected all annotations we knew about once when the
simplifier started and threaded them through the CoreM monad. If new interface
files were loaded during simplification, their annotations would not be
visible to the simplifier.

Now, we rebuild the annotation list at the start of every simplifier pass that
needs it (which is only SpecConstr at the moment). This ensures that we see
all annotations that have been loaded so far. This is somewhat similar to how
RULES are handled.

Add new ForceSpecConstr annotation

Annotating a type with {-# ANN type T ForceSpecConstr #-} makes SpecConstr
ignore -fspec-constr-threshold and -fspec-constr-count for recursive functions
that have arguments of type T. Such functions will be specialised regardless
of their size and there is no upper bound on the number of specialisations
that can be generated. This also works if T is embedded in other types such as
Maybe T (but not T -> T).

T should not be a product type because it could be eliminated by the
worker/wrapper transformation. For instance, in

data T = T Int Int

foo :: T -> Int
foo (T m n) = ... foo (T m' n') ...

SpecConstr will never see the T because w/w will get rid of it. I'm still
thinking about whether fixing this is worthwhile.

Generate INLINE pragmas for PA methods

Add a GHC layout extension to the alternative layout rule

Fix HPC column numbers, following the column number changes in GHC

Whitespace only

Fix column numbers used when highlighting :list output

add a missing lock around allocGroup()

remove unused cap->in_gc flag

Refactoring only

move sanity checking code from Storage.c to Sanity.c

stg_ap_0_fast: sanity-check only the topmost frame, not the whole stack
Sanity checking was getting too slow in some cases, this returns it to
a constant-factor overhead.

Fix profiling build

More work on the simplifier's inlining strategies

This patch collects a small raft of related changes

* Arrange that during
     (a) rule matching and
     (b) uses of exprIsConApp_maybe
  we "look through" unfoldings only if they are active
  in the phase. Doing this for (a) required a bit of
  extra plumbing in the rule matching code, but I think
  it's worth it.

  One wrinkle is that even if inlining is off (in the 'gentle'
  phase of simplification) during rule matching we want to
  "look through" things with inlinings.
   See SimplUtils.activeUnfInRule.

  This fixes a long-standing bug, where things that were
  supposed to be (say) NOINLINE, could still be poked into
  via exprIsConApp_maybe.

* In the above cases, also check for (non-rule) loop breakers;
  we never look through these.  This fixes a bug that could make
  the simplifier diverge (and did for Roman).
  Test = simplCore/should_compile/dfun-loop

* Try harder not to choose a DFun as a loop breaker. This is
  just a small adjustment in the OccurAnal scoring function

* In the scoring function in OccurAnal, look at the InlineRule
  unfolding (if there is one) not the actual RHS, beause the
  former is what'll be inlined.

* Make the application of any function to dictionary arguments
  CONLIKE.  Thus (f d1 d2) is CONLIKE.
  Encapsulated in CoreUtils.isExpandableApp
  Reason: see Note [Expandable overloadings] in CoreUtils

* Make case expressions seem slightly smaller in CoreUnfold.
  This reverses an unexpected consequences of charging for
  alternatives.

Refactorings
~~~~~~~~~~~~
* Signficantly refactor the data type for Unfolding (again).
  The result is much nicer.

* Add type synonym BasicTypes.CompilerPhase = Int
  and use it

Many of the files touched by this patch are simply knock-on
consequences of these two refactorings.

Fix Trac #3100: reifyType

A type without any leading foralls may still have constraints
   eg:  ?x::Int => Int -> Int

But reifyType was failing in this case.

Merge to 6.12.

Fix Trac #3102: pre-matching polytypes

When *pre-matching* two types
     forall a. C1 => t1  ~  forall a. C2 => t2
we were matching t1~t2, but totally ignoring C1,C2
That's utterly wrong when pre-matching
       (?p::Int) => String  ~  a
because we emerge with a:=String!

All this is part of the impredicative story, which is about
to go away, but still.

Worth merging this to 6.12

threadStackUnderflow: put the new TSO on the mut list if necessary

don't sanity check the whole stack when switching interp<->compiled

fix to sanity checking for ThreadRelocated TSOs

sanity check the top stack frame, not the whole stack

Make allocatePinned use local storage, and other refactorings

This is a batch of refactoring to remove some of the GC's global
state, as we move towards CPU-local GC.

  - allocateLocal() now allocates large objects into the local
    nursery, rather than taking a global lock and allocating
    then in gen 0 step 0.

  - allocatePinned() was still allocating from global storage and
    taking a lock each time, now it uses local storage.
    (mallocForeignPtrBytes should be faster with -threaded).

  - We had a gen 0 step 0, distinct from the nurseries, which are
    stored in a separate nurseries[] array.  This is slightly strange.
    I removed the g0s0 global that pointed to gen 0 step 0, and
    removed all uses of it.  I think now we don't use gen 0 step 0 at
    all, except possibly when there is only one generation.  Possibly
    more tidying up is needed here.

  - I removed the global allocate() function, and renamed
    allocateLocal() to allocate().

  - the alloc_blocks global is gone.  MAYBE_GC() and
    doYouWantToGC() now check the local nursery only.

Free full_prog_argv at exit, closing a memory leak

free cap->saved_mut_lists too
fixes some memory leakage at shutdown

exitScheduler: move boundTaskExiting call outside #ifdef THREADED_RTS
Fixes a little leaked memory at shutdown in non-threaded RTS

Use dlltool from the in-tree mingw installation
We only use dlltool on Windows, and this way we don't require that
the user has it installed.

Fix Commentary link in the HACKING file; trac #3706

Add an entry fo the ghci command :run to the user guide

Fix typo in docs

Delay expansion of some makefile variables until they are available

Call $(SED) rather than sed

Look for sed as gsed first
Solaris's sed apparently doesn't understand [:space:]

Avoid running empty for loops; fixes trac #3683
Solaris's sh gives
    /bin/sh: syntax error at line 1: `;' unexpected
when faced with something like
    for x in ; do ...; done
Patch from Christian Maeder.

Fix PS file generation
(the image doesn't work, but at least db2latex doesn't fall over)

Implement a new heap-tuning option: -H

-H alone causes the RTS to use a larger nursery, but without exceeding
the amount of memory that the application is already using.  It trades
off GC time against locality: the default setting is to use a
fixed-size 512k nursery, but this is sometimes worse than using a very
large nursery despite the worse locality.

Not all programs get faster, but some programs that use large heaps do
much better with -H.  e.g. this helps a lot with #3061 (binary-trees),
though not as much as specifying -H<large>.  Typically using -H<large>
is better than plain -H, because the runtime doesn't know ahead of
time how much memory you want to use.

Should -H be on by default?  I'm not sure, it makes some programs go
slower, but others go faster.

Store a destination step in the block descriptor
At the moment, this just saves a memory reference in the GC inner loop
(worth a percent or two of GC time).  Later, it will hopefully let me
experiment with partial steps, and simplifying the generation/step
infrastructure.

Fix the prof_scc.png image in the profiling section (#3694)

document 'recache' command in the help output (#3684)

Check whether the main function is actually exported (#414)

Avoid using non-standard GNU tar option --force-local

Reorder ALL_RTS_LIBS

ALL_RTS_LIBS is (ab)used for linking ghc when BootingFromHc=Yes,
which needs libHSrtsmain.a before libHSrts.a.

Update dependencies

Follow Cabal changes

Tweak layout to work with alternative layout rule

Tweak the alternative layout rule: {} contains commas

Correct the advanceSrcLoc calculation for tabs
It was off-by-one

Tweak alternative layout rule

Make the alternative layout rule cope with file pragmas

Give more informative error messages
We used to just get
    ghc: panic! (the 'impossible' happened)
      (GHC version 6.13.20091128 for x86_64-unknown-linux):
        too few bytes. Failed reading at byte position 32753
with no indication of what was being parsed.

Teach advanceSrcLoc about tab characters

Whitespace only

Columns now start at 1, as lines already did
Also corrected a couple of line 0's to line 1

Remove configure tests on tarballs that no longer exist

Implement non-decreasing do indentation in the alternative layout rule

add docs for Unicode entities in #2978

Apply patch from #2978: add more Unicode syntax

Use UTF-8 explicitly for InstalledPackageInfo
So ghc-pkg register/update takes input in UTF-8, and ghc-pkg dump
outputs in UTF-8.  Textual package config files in the package DB are
assumed to be in UTF-8.

Comments only, esp about RecStmts

Fix a bug in alternative layout rule

Fix a bug in alternative layout
And make the code simpler in the process!

Bug fix for alternative layout rule

Tweak alternative layout rule

Add unboxed parentheses to the alternative layout rule

Tweak the warning suppression flags used in Lexer

Implement the alternative layout rule
Caution: Largely untested

Fix some warning in Lexer

threadStackOverflow: check whether stack squeezing released some stack (#3677)

In a stack overflow situation, stack squeezing may reduce the stack
size, but we don't know whether it has been reduced enough for the
stack check to succeed if we try again.  Fortunately stack squeezing
is idempotent, so all we need to do is record whether *any* squeezing
happened.  If we are at the stack's absolute -K limit, and stack
squeezing happened, then we try running the thread again.

We also want to avoid enlarging the stack if squeezing has already
released some of it.  However, we don't want to get into a
pathalogical situation where a thread has a nearly full stack (near
its current limit, but not near the absolute -K limit), keeps
allocating a little bit, squeezing removes a little bit, and then it
runs again.  So to avoid this, if we squeezed *and* there is still
less than BLOCK_SIZE_W words free, then we enlarge the stack anyway.

add a comment to TSO_MARKED

Pass --no-user-package-conf to ghc-pkg in bindisttest

Add a note saying what Haddock relies on about Instance.is_dfun

Treat () as an enumeration tycon
This fixes deriving Ord (), which previously failed with
  ghc-stage1: panic! (the 'impossible' happened)
    (GHC version 6.13.20091123 for x86_64-unknown-linux):
          TcGenDeriv:mk_FunBind

Whitespace only

inline has moved to GHC.Magic

Use the ghc-perl tarball on Windows, instead of the msys one

Install perl on Windows

Remove cprAnalysis directory from hs-source-dirs

Remove -fasm from mk/validate-settings.mk
Makes it easier to do unregisterised validate runs

Fix some dependencies in bindists
We can't depend on sources in a bindist, because we don't have the sources.

Add a rule to allow us to sdist libraries easily

Check upper/lower bounds on various RTS flags (#3633)

Also, make K mean 1024 rather than 1000, in RTS flags (similarly for M
and G).  The main reason I want to change it is that otherwise this
might be confusing:

exp3_8: error in RTS option -H4k: size outside allowed range (4096 - 18446744073709551615)

And I think the original reason for using 1000 instead of 1024,
worries about direct-mapped caches, is not an issue in this context
(even if you can find a direct-mapped cache these days).

define HS_WORD_MAX

Print the prog name in errorBelch() even if prog_argv is not set yet
This means we get the prog name in error messages from the flag parser

Remove dead code

Remove the (very) old strictness analyser

I finally got tired of the #ifdef OLD_STRICTNESS stuff.  I had been
keeping it around in the hope of doing old-to-new comparisions, but
have failed to do so for many years, so I don't think it's going to
happen.  This patch deletes the clutter.

Make INLINE warning more precise

Implement -fexpose-all-unfoldings, and fix a non-termination bug

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.

Re-implement the binder-swap stuff in OccurAnal

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.

Try harder not to make DFuns into loop breakers

See Note [DFuns should not be loop breakers]

Extend the GHCi FAQ slightly

Add gnutar to the list of names we use when looking for GNU tar

Add support for the man page to the new build system