GitLab

enable __CONCURRENT_HASKELL__

RET_DYN doesn't have a proper header, just an info pointer.

In case the desugaring of a lit-lit should fail, give a more informative error msg

tidied up the error handling defs.

Fix pretty-printing of FunTys to not throw away NoteTys (eg type synonyms).
(re-commit because first mail message didn't get sent)

Fix pretty-printing of FunTys to not throw away NoteTys (eg type synonyms).

Pragmas, Haskell (98) report style.

Int and Word have to be treated like other Prelude modules in a DLLish
world.

*_SECTION_END_MARKER_DECLs are now void*

Fix cost centres on PAPs.

Previous commit broke let-no-escape.  Fix it up again.

PAPs are ReEntrant, not SingleEntry.

decodeFloat and decodeDouble were accidentally allocating too much
due to a StgWord/byte confusion.

Fix cost centre restores for unboxed tuple alternatives.

raise# now prints "uncaught exception" if it finds a STOP_FRAME.

Fix the HsForAll case in TcMonoType.tc_type_kind so that it
permits types like

	f :: forall a. Num a => (# a->a, a->a #)

Previously it insisted that the body of a for-all was a boxed
type, but 'f' makes perfect sense, and indeed occurs in interface
files as a result of CPR analysis.

Update from autoheader.

Missing ';'.

cpp wibble

Some fixes to profiling stuff.

Minor documentation fixes, and addition of SRT explanation.

egcs sometimes leaves a 'popl %ecx' in the epilogue, it seems.

Add infixr 1 =<<

Make mut_link field be NULL when removing CAF_{UN}ENTERED from
mut_once_list.  Convention is to have the field be NULL iff
the caf is not on a mut_once_list.  This gives a O(1) cost way
to avoid putting a caf onto a mut_once_list more than once.

Add missing semicolon

- Stack overflow now generates an (AsyncException StackOverflow)
  exception, which can be caught as normal.

- Add a stack overflow handler to the top-level mainIO handler, with
  the standard behaviour (i.e. call the stack overflow hook and then
  exit).

- Add a test for stack overflow catching.

- Fix a couple of bugs in async exception support.

Ignore type lambdas for the purposes of occurrence analysis.

Print (ICanSafelyBeINLINEd InsideLam _) as "__Ul".

Make it so that Local (i.e. non-top-level) names record
whether they originally came from an interface file.  This
means that when unifying two type variables we can readily
choose one that occurred in the source, rather than one
imported from an interface file.  That in turn improves 
compiler error messages.  E.g.

  rd :: (RealFloat a, RealFrac b) => b -> Transformation a
  rd degrees  = r ((degrees / 180.0) * pi)

used to say

    Could not deduce `Floating a'
	(arising from use of `pi' at Foo.hs:11)
	from the context: (RealFloat a1, RealFrac a)
    Probable cause: missing `Floating a' in type signature for `rd'

[here the 'a' came from the signature for 'pi' in PrelBase;
 the 'a1' is a renamed version of the 'a' in the source pgm]

but now says

    Could not deduce `Floating b'
	(arising from use of `pi' at Foo.hs:11)
	from the context: (RealFloat a, RealFrac b)
    Probable cause: missing `Floating b' in type signature for `rd'

When resizing a stack, set the Sp and Su of the old, dead, TSO to be just
beyond the end of its stack so we don't attempt to scavenge any part of
the stack in case we come across this TSO during GC.

Complete the hack that lets us give 'error' the type

	error :: forall a:?. String -> a

The kind '?' (also known as 'Type AnyBox') means that
error can be applied to unboxed types too.  unsafeCoerce is
similar.  But the 'real' type of error is:

	error :: forall bv. forall a:Type bv. String -> a

That is, it's really polymorphic in the boxity of a; that's
different to saying that the type bound to 'a' must have
kind '?'.  

The fix was in TcType.inst_tyvar, where we look for the kind '?'
and generate a boxity variable instead.  Sigh.

- Document the pragmas we support
- Fix some lies in the vs. Haskell section.

Improvements to the threading model.

   - asynchronous exceptions supported.

	- killThread# can now raise an exception in the specified
	  thread.  It's new type is

		killThread# :: ThreadId# -> Exception -> IO ()

	  High-level versions:

		killThread :: ThreadId -> IO ()
		raiseInThread :: ThreadId -> Exception -> IO ()

	  (killThread raises a 'ThreadKilled' exception in the
	   specified thread).

	  If the thread has no exception handler, it is killed
	  as before.  Otherwise, the exception is passed to
	  the innermost CATCH_FRAME and the thread is woken up
	  if it was blocked.  The current computation is
	  suspended, instead of being replaced by the exception
	  (as is the case with throw).

	  Sending an exception to the current thread works too.

   - new primitive: myThreadId# :: IO ThreadId# and corresponding
     high-level version myThreadId :: IO ThreadId.

   - new primitive: yield# :: IO (), and yield :: IO ().

   - the TSO now contains a pointer to the resource currently blocked
     on (MVAR or BLACKHOLE_BQ).

  - Add a giant comment to TSO.h about what the various link fields
    are supposed to do, and invariants etc.

Bring up to 4.02 interface file syntax

Make it only a warning if you have a type like this:

	forall a. Int -> Int

These show up in interface files occasionally, just because
the simplifier is a bit blase about adding type arguments.

But it's an error to have

	forall a. Eq a => Int -> Int

The flag -fwarn-unused-matches reports a warning for these
redundant for-alls.

Remove a couple of stgcasts.

Specialise STATIC_LINK() for {FUN,THUNK,IND}_STATIC.

Reduce alignment for info tables on x86 to 1 word.  It was previously
4 words, which meant that the entry code was wrongly aligned all the
time (because info tables are either 2 or 3 words).  At least this way
we've got a 1 in 4 chance of being properly aligned.

Remove flags field from info tables; create a separate table of flags
indexed by the closure type in the RTS.

Make clear in HsType whether a for-all is explicit
in the source program or not.  Implicit for-alls now
look like 
	HsForAllTy Nothing ctxt ty
while explicit ones look like
	HsForAllTy (Just tvs) ctxt ty

Before this, the scope analysis stuff in RnSource was
actually wrong (not that anyone had noticed), but Alex Ferguson
did notice a bogus (sort-of-duplicate) error message on types
like
	f :: Eq a => Int -> Int
which led me to spot the deeper problem.  Anyway, it's all 
cool now.