GitLab

fix some (thankfully harmless) typos

strictly speaking, we also need write barriers in the update code too
(although gcc hasn't been caught doing any reordering here, as yet).

unlockClosure() requires a write barrier for the compiler - write
barriers aren't required for the CPU, but gcc re-orders non-aliasing
writes unless we use an explicit barrier.

This only just showed up when we started compiling the RTS with -O2.

make this compile non-threaded again

lock down the global state in the StablePtr implementation

wibble

bugfix to rev. 1.3: we must fill the slop before writing the
indirectee, because in the case of AP_STACK the indirectee will
overwrite the size field of the closure.

bugfix to new raiseAsync_

A patch to the already-somewhat-delicate machinery that deals with
pattern-matching on unboxed tuples.  This patch deals with pattern
matches that can fail, e.g.
	case f x of
	  (# Just x, Nothing #) -> ...

The fix is in desugaring of HsCase (DsExpr.lhs).

The test is dsrun013

un-revert rev. 1.22, it wasn't the cause of last weekend's breakage

report the correct version number in the "compiled by GHC version.."
message in a bootstrapped compiler.

fix up the GhcWithNativeCodeGen logic

Add "Why doesn't GHC have a .NET back end?"

make --mk-dll work with --make

Submitted by: Esa Ilari Vuokko <eivuokko@gmail.com>, thanks!

Files missed from STM implementation changes

Re-use temporary storage in the STM implementation

Wibble to typerep (fixes crash I hope)

fix repType after changes to the representation of type synonyms.
This caused the stage2 compiler to crash, because various info tables
misrepresented the pointerhood of constructor arguments.

something has gone wrong; I don't have time right now to find out
exactly what, so revert rev. 1.22 in an attempt to fix it.

fix threaded build

Two improvements to the SMP runtime:

  - support for 'par', aka sparks.  Load balancing is very primitive
    right now, but I have seen programs that go faster using par.

  - support for backing off when a thread is found to be duplicating
    a computation currently underway in another thread.  This also
    fixes some instability in SMP, because it turned out that when
    an update frame points to an indirection, which can happen if
    a thunk is under evaluation in multiple threads, then after GC
    has shorted out the indirection the update will trash the value.
    Now we suspend the duplicate computation to the heap before this
    can happen.

Additionally:

  - stack squeezing is separate from lazy blackholing, and now only
    happens if there's a reasonable amount of squeezing to be done
    in relation to the number of words of stack that have to be moved.
    This means we won't try to shift 10Mb of stack just to save 2
    words at the bottom (it probably never happened, but still).

  - update frames are now marked when they have been visited by lazy
    blackholing, as per the SMP paper.

  - cleaned up raiseAsync() a bit.

cosmetic

Add wcStore(), a write-combining store if supported

(I tried using it in the update code and only succeeded in making
things slower, but it might come in handy in the future)

cosmetic

Omit the __DISCARD__() call in FB_ if __GNUC__ >= 3.  It doesn't
appear to be necessary now, and it prevents some gcc optimisations.

Discard various ways in which gcc zeroes stack slots in the prologue.
So far in my investigations these have always been unnecessary, they
appear to be the result of missed optimisations by gcc, so cross
fingers and discard them.  New variants have just shown up because I
started compiling the RTS with -optc-O2.

small improvement to the update code

Use -optc-O2 when compiling the RTS

Separate the documentation for Concurrent Haskell from that for
Parallel Haskell, and put a big note at the top of the Parallel
Haskell section pointing to the GPH site.

small fixes to docs for +RTS -C

Better error reporting for newtypes with too many constructors,
or too many fields.  Instead of yielding a parse error, we
parse it like a data type declaration, and give a comprehensible
error message later.

A suggestion from Jan-Willem.

Two significant changes to the representation of types

1. Change the representation of type synonyms

    Up to now, type synonym applications have been held in
    *both* expanded *and* un-expanded form.  Unfortunately, this
    has exponential (!) behaviour when type synonyms are deeply
    nested.  E.g.
	    type P a b = (a,b)
	    f :: P a (P b (P c (P d e)))
    
    This showed up in a program of Joel Reymont, now immortalised
    as typecheck/should_compile/syn-perf.hs

    So now synonyms are held as ordinary TyConApps, and expanded
    only on demand.  

    SynNote has disappeared altogether, so the only remaining TyNote
    is a FTVNote.  I'm not sure if it's even useful.

2. Eta-reduce newtypes

    See the Note [Newtype eta] in TyCon.lhs
    
    If we have 
	    newtype T a b = MkT (S a b)
    
    then, in Core land, we would like S = T, even though the application
    of T is then not saturated. This commit eta-reduces T's RHS, and
    keeps that inside the TyCon (in nt_etad_rhs).  Result is that 
    coreEqType can be simpler, and has less need of expanding newtypes.

Yet more detail in types with -dppr-debug

Move the building guide to GHC where it belongs. This is more consistent and
currently even necessary, otherwise *every* fptools project would need the ghc
subtree.

Better TH -> HsSyn conversion

	Merge to stable (attempt)

This commit monad-ises the TH syntax -> HS syntax conversion.
This means that error messages can be reported in a more civilised
way.  It also ensures that the entire structure is converted eagerly.
That means that any exceptions buried inside it are triggered 
during conversion, and caught by the exception handler in TcSplice.
Before, they could be triggered later, and looked like comiler
crashes.

Fix a crash in STM; we were releasing ownership of the transaction too
early in stmWait(), so a TSO could be woken up before we had finished
putting it to sleep properly.

- point to the bug tracker from the "known bugs" section
- move the item about instances from GHCi to GHC, and tweak it a bit

make validate happy

oops, it's i386_TARGET_ARCH, not x86_TARGET_ARCH

SMP bugfix: if the thread we were just running blocked, then we are in
a delicate state - we don't necessarily have access to the TSO we were
just running, because we relinquished it when we put it on whatever
blocking queue it is on.  It might even be running already.

Previously I made the scheduler quickly loop again in this case.
However, I made it loop too quickly: we should be sure to set the
blackholes_need_checking flag if necessary, otherwise we can miss some
wakeups.