GitLab

For consistency, changed access of thread id to be through capability instead of directly from StgRegTable.

StgWord64 other better represents this argument since it can be used as
any particular data, thus "other" and not the "from" capability as it was
previously strictly used.  Also, StgWord64 is normally larger than type
nat to allow for larger data to be passed through the "other" argument.

Fixed ThreadID to be defined as StgThreadID, not StgWord64.  Changed CapabilityNum to CapNo.  Added helper functions postCapNo() and postThreadID().
ThreadID was StgWord64, but should have been StgThreadID, which is
currently StgWord32.  Changed name from CapabilityNum to CapNo to better
reflect naming in Capability struct where "no" is the capability number.
Modified EventLog.c to use the helper functions postCapNo() and
postThreadID () for CapNo and ThreadID.

EventTypeDescriptions order must be synchronized with the event type
definitions in includes/EventLogFormat.h for the definitions to correctly
index with the matching description.

This patch sligtly re-adjusts the way in which the syntax of types 
is handled:

 * In the lexer, '.' and '*' are always accepted in types
   (previously it was conditional).  This things can't mean
   anything else in H98, which is the only reason for doing things
   conditionally in the lexer.

 * As a result '.' in types is never treated as an operator.
   Instead, lacking a 'forall' keyword, it turns into a plain parse error.

 * Test for -XKindSignatures in the renamer when processing
     a) type variable bindings
     b) types with sigs (ty :: kind-sig)

 * Make -XKindSignatures be implied by -XTypeFamilies 
   Previously this was buried in the conditonal lexing of '*'

With the
    On x86, use thread-local storage instead of stealing a reg for gct
patch, on Windows and OS X:
    error: thread-local storage not supported for this target

One of these things is not like the others:

stdPattern :: [LRep] -> Maybe StgHalfWord
stdPattern reps
  = case reps of
        []  -> Just ARG_NONE    -- just void args, probably
        [N] -> Just ARG_N
        [P] -> Just ARG_N
        [F] -> Just ARG_F
        [D] -> Just ARG_D
        [L] -> Just ARG_L

Today's debugging session was brought to you by the letter P.

- Block concat and branch-chain elimination were allowing a function call
  to return to the caller's entry point. But that doesn't leave anywhere
  for the infotable on the stack, since the SP on return must be the same
  as the SP on entry to the procedure.

 - Previously, the node was taken as a parameter, then ignored,
   for static closures. Goofy. Now, the vestigial node parameters
   are gone.

Code simplifications due to call/return separation; some improvements to how node argument is managed

Benchmarks show that using TLS instead of stealing a register is
better by a few percent on x86, due to the lack of registers.

This only affects -threaded; without -threaded we're (now) using
static storage for the GC data.

unbreaks ghc-pkg check in an installed GHC

This patch is the result of a long series of nofib-based experiments
to improve GHC's inlining heuristics.

In the end, I'm not sure how worthwhile it all was: I only got a 
   1% decrease in code size
   1% decrease in allocation
and I don't trust the runtime statistics enough to quote.

Still, in doing all this I tidied up the code quite a bit, and 
I understand it much better now, so I'm going to commit it.

The main changes are in CoreUnfold, which has lots of new comments.
Other changes:

  - litSize moves from Literal to CoreUnfold
  - interestingArg moves from SimplUtils to CoreUnfold
  - the default unfolding threshold (in StaticFlags) 
      reduces from 8 to 6 (since the size calculation 
      has changed a bit)

If worker/wrapper decides not to w/w something on the grounds that
it's too small, it should add an INLINE pragma.  Otherwise, later
in the day that small thing might now be big, and we'd wish we'd
done the w/w after all.  This only made a difference in one nofib 
program (bspt), but it's an easy change.

See Note [Don't w/w inline things (a) and (b)]

I found a couple of shortcomings in arity computation, and did
quite a bit of refactoring as a result.  Regrettably, I have
forgotten the details, but I do remember that one part was to
do with the infamous "state hack".  If we're going to use the
state-hack at all, we'd better do it right.

Anyway I think this is an improvement. The comments are more
up to date too, and more voluminous.

See Note [Case MFEs]; don't float case expressions from 
a strict context.

This patch fixes a rather obscure bug, whereby it's possible
for (case C a b of <alts>) to have altenatives that do not inclue
(C a b)!  See Note [Unreachable code] in CoreUtils.

I'm changing the details of SimplUtils.interstingArg, and don't want to
mess  up the way Specialise works, so this patch makes a specilialised
(ha) function, Specialise.interestingDict, that is used locally.

Make idDetails and idInfo into proper functions, rather than record
fields, so that we can report more informatively if you use thenm on
a non-Id.

In the case binder-swap operation (which is done in OccurAnal),
we deliberately use shadowing. But the new shadowing binder should
not inherit any fancy INLINE or NOINLINE pragmas from its parent.

This patch changes the compilation pipeline flags so that constants
are floated to the top level even in the first full laziness pass.
For some reason this was not done before.  Fixing this makes a big
improvement in 'spectral/rewrite', and has zero effect on any other
nofib benchmark.

 1. it was out of date in various ways
 2. this is not the place people look for installation instructions
 3. we have installation instructions elsewhere (e.g. the INSTALL
    file in a binary distribution)
 4. the section "layout of installed files" is now on the wiki under
    Building/Installing.