Comment explaining use of seq in DFMonad

FIX unregisterised target by #ifdefing targetPlatform stuff
I'm not sure if this is the correct fix.  If targetPlatform is really
NCG-specific, then maybe we should call it asmTargetPlatform or
something.

Removed a trace

Calling convention bug and cleanup
- yet another wrong calling convention; this one was a special case for returning one
  value.

Inconsistent type and arguments in safe foreign calls...
- The function argument was stripped from the argument list but not from the type.
  Now they're both stripped.

stack overflows and out of memory's
1. Stack overflow fixed by making dataflow monad strict in the state.
2. Out of memory fixed by "forgetting" lastoutfacts in the dataflow monad
   where we should. We were creating an unnecessarily long list that grew
   exponentially...

Add the notion of "constructor-like" Ids for rule-matching

This patch adds an optional CONLIKE modifier to INLINE/NOINLINE pragmas,
   {-# NOINLINE CONLIKE [1] f #-}
The effect is to allow applications of 'f' to be expanded in a potential
rule match.  Example
  {-# RULE "r/f" forall v. r (f v) = f (v+1) #-}

Consider the term
     let x = f v in ..x...x...(r x)...
Normally the (r x) would not match the rule, because GHC would be scared
about duplicating the redex (f v). However the CONLIKE modifier says to
treat 'f' like a constructor in this situation, and "look through" the
unfolding for x.  So (r x) fires, yielding (f (v+1)).

The main changes are:
  - Syntax

  - The inlinePragInfo field of an IdInfo has a RuleMatchInfo
    component, which records whether or not the Id is CONLIKE.
    Of course, this needs to be serialised in interface files too.

  - The occurrence analyser (OccAnal) and simplifier (Simplify) treat
    CONLIKE thing like constructors, by ANF-ing them

  - New function coreUtils.exprIsExpandable is like exprIsCheap, but
    additionally spots applications of CONLIKE functions

  - A CoreUnfolding has a field that caches exprIsExpandable

  - The rule matcher consults this field.  See
    Note [Expanding variables] in Rules.lhs.

On the way I fixed a lurking variable bug in the way variables are
expanded.  See Note [Do not expand locally-bound variables] in
Rule.lhs.  I also did a bit of reformatting and refactoring in
Rules.lhs, so the module has more lines changed than are really
different.

Fixes to "Retract Hp *before* checking for HpLim==0"

Add fast event logging

Generate binary log files from the RTS containing a log of runtime
events with timestamps.  The log file can be visualised in various
ways, for investigating runtime behaviour and debugging performance
problems.  See for example the forthcoming ThreadScope viewer.

New GHC option:

  -eventlog   (link-time option) Enables event logging.

  +RTS -l     (runtime option) Generates <prog>.eventlog with
              the binary event information.

This replaces some of the tracing machinery we already had in the RTS:
e.g. +RTS -vg  for GC tracing (we should do this using the new event
logging instead).

Event logging has almost no runtime cost when it isn't enabled, though
in the future we might add more fine-grained events and this might
change; hence having a link-time option and compiling a separate
version of the RTS for event logging.  There's a small runtime cost
for enabling event-logging, for most programs it shouldn't make much
difference.

(Todo: docs)

FIX biographical profiling (#3039, probably #2297)
Since we introduced pointer tagging, we no longer always enter a
closure to evaluate it.  However, the biographical profiler relies on
closures being entered in order to mark them as "used", so we were
getting spurious amounts of data attributed to VOID.  It turns out
there are various places that need to be fixed, and I think at least
one of them was also wrong before pointer tagging (CgCon.cgReturnDataCon).

Add getNumberOfProcessors(), FIX MacOS X build problem (hopefully)
Somebody needs to implement getNumberOfProcessors() for MacOS X,
currently it will return 1.

FIX #3093: stub filenames when using -osuf
Also remove some unused cruft

Don't call processHeapClosureForDead on pinned blocks
Fixes heapprof001(prof_hp) after fix for #2917

Retract Hp *before* checking for HpLim==0
Fixes heapprof001(prof_hp) following the recent HpLim patch, which
depended on the lack of slop in the heap.

eliminate some not-quite-duplicate code

start finalizers on the current Capability rather than last_free_capability

cope with ThreadRelocated on the sleeping_queue

Fix Trac #3095, and make RdrHsSyn warning-clean

Layout only

Reject foralls in constructor args in 'deriving', except for Functor etc

Fix Trac #3092

We were't checking that a 'data/type instance' was extending a family
type constructor.

Merge to 6.10 if we ever release 6.10.3 (or do it for 6.10.2).

Ensure the orientation of var-var equalities is correct for instatiation
- During fianlisation we use to occasionally swivel variable-variable equalities
- Now, normalisation ensures that they are always oriented as appropriate for
  instantation.
- Also fixed #1899 properly; the previous fix fixed a symptom, not the cause.

Use work-stealing for load-balancing in the GC

New flag: "+RTS -qb" disables load-balancing in the parallel GC
(though this is subject to change, I think we will probably want to do
something more automatic before releasing this).

To get the "PARGC3" configuration described in the "Runtime support
for Multicore Haskell" paper, use "+RTS -qg0 -qb -RTS".

The main advantage of this is that it allows us to easily disable
load-balancing altogether, which turns out to be important in parallel
programs.  Maintaining locality is sometimes more important that
spreading the work out in parallel GC.  There is a side benefit in
that the parallel GC should have improved locality even when
load-balancing, because each processor prefers to take work from its
own queue before stealing from others.

Fix Trac #3087: derived Data now defines dataCast1/2

This patch generates code in deriving(Data) for dataCast1 or 2 as
appropriate.

While I was there I did some refactoring (of course), pulling out
the TcDeriv.inferConstraints as a separate function.

I don't think it's worth merging this to 6.10.2, even though it's a bugfix,
because it modifies code that I added in the HEAD only (for deriving Functor)
so the merge will be sligtly awkward.  And there's an easy workaround.

Adjust error message slightly to make it clearer

just comment formatting

Add "+RTS -N" to determine the -N value automatically (see #1741)

tidy up "missing symbol" error message

Fix sanity checking after fix to #2917

Instead of a separate context-switch flag, set HpLim to zero
This reduces the latency between a context-switch being triggered and
the thread returning to the scheduler, which in turn should reduce the
cost of the GC barrier when there are many cores.

We still retain the old context_switch flag which is checked at the
end of each block of allocation.  The idea is that setting HpLim may
fail if the the target thread is modifying HpLim at the same time; the
context_switch flag is a fallback.  It also allows us to "context
switch soon" without forcing an immediate switch, which can be costly.

FIX #3079, dodgy parsing of LANGUAGE pragmas
I ended up rewriting this horrible bit of code, using (yikes) lazy I/O
to slurp in the source file a chunk at a time.  The old code tried to
read the file a chunk at a time, but failed with LANGUAGE pragmas
because the parser for LANGUAGE has state and the state wasn't being
saved between chunks.  We're still closing the Handle eagerly, so
there shouldn't be any problems here.

avoid a crash: don't return unless the run queue has some threads in it

Allocate the right number of words in new*PinnedByteArrayzh_fast

FIX #2816 (correct unicode output for :type/:kind)
This is just a hack, since we don't have correct unicode output for
Handles in general, I just fixed a couple of places where we were not
converting to UTF-8 for output.

Fix #2992: don't create a named event
Evidently I misread the docs for CreateEvent: if you pass a name to
CreateEvent, then it creates a single shared system-wide Event with
that name.  So all Haskell processes on the machine were sharing the
same Event object.  duh.

FIX #2832: Setting SplitObjs=NO doesn't disable -split-objs in GHC
Now ghc --info reports whether-split-objs is supported, rather than
whether the libraries were built using -split-objs.

FIX #2976: fix buggy implementation of shadowing in GHC.getBindings

Don't put a trailing / on the mingw include path

Fix a bug which sometimes caused extra major GCs to be performed
A long-running GC would cause the timer signal to declare the system
to be idle, which would cause a major GC immediately following the
current GC.  This only happened with +RTS -N2 or greater.

Redesign 64-bit HEAP_ALLOCED (FIX #2934 at the same time)

After much experimentation, I've found a formulation for HEAP_ALLOCED
that (a) improves performance, and (b) doesn't have any race
conditions when used concurrently.  GC performance on x86_64 should be
improved slightly.  See extensive comments in MBlock.h for the
details.

Partial fix for #2917

 - add newAlignedPinnedByteArray# for allocating pinned BAs with
   arbitrary alignment

 - the old newPinnedByteArray# now aligns to 16 bytes

Foreign.alloca will use newAlignedPinnedByteArray#, and so might end
up wasting less space than before (we used to align to 8 by default).
Foreign.allocaBytes and Foreign.mallocForeignPtrBytes will get 16-byte
aligned memory, which is enough to avoid problems with SSE
instructions on x86, for example.

There was a bug in the old newPinnedByteArray#: it aligned to 8 bytes,
but would have failed if the header was not a multiple of 8
(fortunately it always was, even with profiling).  Also we
occasionally wasted some space unnecessarily due to alignment in
allocatePinned().

I haven't done anything about Foreign.malloc/mallocBytes, which will
give you the same alignment guarantees as malloc() (8 bytes on
Linux/x86 here).

Don't force HSCOLOUR_SRCS = YES when validating
This removes a burden from developers, and I can't remember an
occasion where it would have caught a regression.

Add CONTRACT to the pragmas that we recognise.
It's used by ESC/Haskell.

Generate lots of __inline_me during vectorisation

Special-case desugaring of simple parallel array comprehensions

Make LDV_FILL_SLOP use a forwards loop rather than a backwards loop

Fix warning

Try not to avoid vectorising purely scalar functions

Package dph needs to be cleaned in stage=1, too

Add --version to runghc. Trac #2757.
We use the GHC version number, as the old runghc one doesn't seem very
useful.

add final newlines
My Windows build has started complaining about lacking final newlines,
I'm not entirely sure why.

remove foo.exe.manifest when --embed-manifest is on

add --with-ld=c:/mingw/bin/ld

Document -fwarn-unrecognised-pragmas; fixes trac #3031

On OS X/x86, tell gcc to generate instructions for i686. Fixes trac #2983.
By default, gcc on OS X will generate SSE instructions, which need
things 16-byte aligned, but we don't 16-byte align things. Thus drop
back to generic i686 compatibility.

By default, only HsColour the docs if we find HsColour. Fixes trac #3004.
If you manually set HSCOLOUR_SRCS=YES then the build will fail if
HsColour wasn't found.

Make -fdicts-cheap cope with implication constraints

See the Note [Dictionary-like types] in TcType for the full story here
Should only affect programs that use -fdicts-cheap, for
which you'll get better arities

Finally fix Trac #3066

This is a fix to
  Tue Mar  3 17:42:58 GMT 2009  simonpj@microsoft.com
    * Fix Trac #3066: checking argument types in foreign calls
which I embarassingly got wrong.

Have to be careful when expanding recursive newtypes.

Pls merge.

Fix a broken link. Spotted by Norman Ramsey in trac #3068.

Fix spelling (Trac#3069)

Layout only

Fix a long-standing latent bug (and the build): check res_ty not sig_ty

Fix #3067: GHCi panics with 'initTc:LIE' while :stepping on code with funny types

The problem is that calls to boxyUnify would panic if the types involved
contained type functions.
It looks like one should wrap these calls with getLIE, although I don't
really know what I am doing here

Fix Trac #3066: checking argument types in foreign calls

When checking argument types in a foreign call we were stupidly
looking through foralls.  The fix is easy.

Merge to 6.10.2

Fix Trac #3057 in deriving Functor

The universal type variables of a data constructor are not necessarily
identical to those of its parent type constructor, especially if the
data type is imported.

While I was at it, I did a significant refactoring to make all this
traversal of types more comprehensible, by adding the data type
FFoldType.

fix assertion failure with -debug non-threaded RTS (by deleting code!)

improvements: generate LaTeX tables for more than one run

A few bug fixes; some improvements spurred by paper writing
Among others:
- Fixed Stg->C-- translation of let-no-escapes -- it's important to use the
  right continuation...
- Fixed infinite recursion in X86 backend (shortcutJump mishandled infinite loops)
- Fixed yet another wrong calling convention -- primops take args only in vanilla regs,
  but they may return results on the stack!
- Removed StackInfo from LGraph and Block -- now in LastCall and CmmZ
- Updated avail-variable and liveness code

Comments only

Filter out carriage returns in doc strings

We want the internal format to contain LFs only. This makes it easier to work
with the doc strings for clients of the GHC API.

z-encode digits at the start of a symbol name; fixes trac #2997
Digits already have a couple of meanings in z-encoding (Z3T is a tuple,
and z123U is a unicode character), so we encode digits as unicode
characters to avoid trying to squeeze in another meaning.

Also removed a little GHC < 6.2 compatibility hack.

Whitespace only

Improve documentation of bang patterns

Use 'nonIOok' instead of 'True'; cosmetics only

Tweak +RTS --info docs

In +RTS --info output, use YES rather than Yes

FIX #1891 (describe +RTS --info output in GHC user guide)

If we are given -Werror, then pass -Werror to cpp

Strip tag bits from closure pointers before trying to deference them.

SPARC NCG: Split out sanity checking into its own module

SPARC NCG: Add jumps to end of blocks when working out condition codes

SPARC NCG: Enforce the invariant that each block ends with a jump.

 - If each basic block doesn't end with a jump then the register
   liveness determinator will get the cross-block liveness info
   wrong, resulting in a bad allocation.

Add targets clean.library.dph and remake.library.dph
- Package dph ist a meta package that contains a number of subpackages inside.
- This patch adds two targets to clean and remake all subpackages with a
  single command.

:steplocal and :stepmodule should not polute trace history

Do not print anything to stdout when stopping at a breakpoint with custom code attached

newPinnedByteArray#: align the result to 16-bytes (part of #2917)

Only use STAGE3_PACKAGE_CONF for building GHC itself
In particular, when building dph with the stage2 compiler, we want to
register it in the main package.conf.

Export blockUserSignals and unblockUserSignals (needed for #2870)

#2860: remove redundant unblocking of signals

newPinnedByteArray#: align the result to 16-bytes (part of #2917)

Rewrite of signal-handling (ghc patch; see also base and unix patches)

The API is the same (for now).  The new implementation has the
capability to define signal handlers that have access to the siginfo
of the signal (#592), but this functionality is not exposed in this
patch.

#2451 is the ticket for the new API.

The main purpose of bringing this in now is to fix race conditions in
the old signal handling code (#2858).  Later we can enable the new
API in the HEAD.

Implementation differences:

 - More of the signal-handling is moved into Haskell.  We store the
   table of signal handlers in an MVar, rather than having a table of
   StablePtrs in the RTS.

 - In the threaded RTS, the siginfo of the signal is passed down the
   pipe to the IO manager thread, which manages the business of
   starting up new signal handler threads.  In the non-threaded RTS,
   the siginfo of caught signals is stored in the RTS, and the
   scheduler starts new signal handler threads.

Fix an off-by-one; fixes the second bug in trac #3001

Install libHSffi_p.a

Fix ghc and ghci wrappers on Windows

Make versioned ghc and ghci programs on Windows; fixes trac #2827

SPARC NCG: Unsigned comparisons are unsigned

SPARC NCG: Fix word size conversions

SPARC NCG: Split up into chunks, and fix warnings.

SPARC NCG: Reorganise Reg and RegInfo

NCG: Cleanup old file