GitLab

Remove apostrophe from #error directive text, as gcc doesn't like that,
even if the #error is ifdef'd out.

All other C compilers I know claim that this is correct C :-(.

merge to stable

Mac OS X/PowerPC:
Learn to cope with out-of-range relative jumps.

PowerPC relative branch instructions have a 24 bit displacement field.
As PPC code is always 4-byte-aligned, this yields a +-32MB range.
If a particular imported symbol is outside this range, we have to redirect
the jump to a short piece of new code that just loads the 32bit absolute
address and jumps there.

Unbreak the 2nd stage of non-threaded-RTS builds by #ifdefing out a
call to wakeBlockedWorkerThread. This should probably fixed more
cleanly by taking an OO view, i.e. always defining this function, but
doing nothing in the non-threaded case. The final decision on this
issue is left to the Masters of the Threads (tm)...

Merged Ross' patch for Hugs:

Tweak to the FPTOOLS_HAVE_OPENGL: when testing for the GLUT lib,
include the GL/GLU/GLX libs just discovered.  While most platforms
don't require this, mysteriously some (e.g. OpenBSD) do.

Fix typo.

Fix handling of unused-matches for parallel list comprs. e.g, for,

     [ e | v1 <- e11 | v2 <- e21 ]

'e' wasn't considered part of v1 & v2's scope. Is now.

parStmtErr: typo

Extend -Werror's scope to also include the desugarer.

Note: -Werror doesn't give you the union of warnings from the renamer,
      TC and desugarer before bailing out, but one pass at a time.

Un-break non-threaded RTS
(hopefully; I have no time to test it right now)

enableTimingStats():
  bring back -Rghc-timing output when compiled with >= 4.11
  (was >= 5.05, which looks unnecessarily restrictive.)

outCLine: Use "#line n <filename>", not "# n <filename>". The latter
          isn't ISO (and causes breakage when compiling output with
	  MSVC.)

New implementation & changed type signature of forkProcess

forkProcess now has the following type:
forkProcess :: IO () -> IO ProcessID

forkProcessAll has been removed as it is unimplementable in the threaded RTS.

forkProcess using the old type (IO (Maybe ProcessID)) was impossible to
implement correctly in the non-threaded RTS and very hard to implement
in the threaded RTS.
The new type signature allows a clean and simple implementation.

Threaded RTS:
Don't start new worker threads earlier than necessary.
After this commit, a Haskell program that uses neither forkOS nor forkIO is
really single-threaded (rather than using two OS threads internally).

Some details:
Worker threads are now only created when a capability is released, and
only when
(there are no worker threads)
	&& (there are runnable Haskell threads ||
	    there are Haskell threads blocked on IO or threadDelay)
awaitEvent can now be called from bound thread scheduling loops
(so that we don't have to create a worker thread just to run awaitEvent)

Make sure that the sequence
rts_lock();
rts_unlock(); /* (with nothing in between) */
doesn't crash the threaded RTS.

rts_getBool: we should check the constructor tag instead of comparing
directly against False_closure and True_closure, since we might be
using the dynamically-linked versions of these.

This may or may not be the cause of bug [ 792761 ] rts_getBool: not a
Bool.

oops, we need to include -fignore-interface-pragmas and
-fomit-interface-pragmas in the default set of options.

Uncomment Alex version test: Alex 2.0 is now required to build GHC.

More Mac OS X-specific gcc 3.3 fixes

merge to stable

Warning police

Warning police

Added prototypes for __hscore_[gs]et_saved_termios to make Linker.c
happy and avoid warnings in RtsStartup.c

Saving/restoring termios is only done for GHC

Update Linker following changes to saved_termios.

Better error trace when cat_evals crashes

To fix dynamic linking issues with Hugs, access saved_termios via
getter/setter.

Add saved_termios symbol

remove docs for -fwith option

The concensus seems to be that 'with' should go away now, after its
customary period of deprecation.  Hugs has already removed it, so
we're following suit.

Move forkOS_createThread into the RTS so its implementation can be
dependent on RTS_SUPPORTS_THREADS, which means we can provide a stub
implementation in the !RTS_SUPPORTS_THREADS case, and hence not depend
on pthread_create, which requires -lpthread.  The upshot is that GHCi
now works again when !RTS_SUPPORTS_THREADS.

If we change the terminal settings as a result of hSetBuffering or
hSetEcho, then restore them again in hs_exit().  This is just good
citizenship on Unixy platforms.

We *don't* just automatically save the terminal settings and restore
them at the end, because that would prevent implementing stty-like
programs in Haskell.  This scheme is a compromise that hopefully DTRT
in most cases.

wibble

If the user explicitly did an instances-only import, i.e.,
"import Foo ()", don't emit an unused-import warning.

Mac OS X uses .dylib instead of .so, recognize that properly.

Change some statics to dynamics, and remove a couple of obsolete options.

Some wibbles to the optimisation section.

Add a BF_PINNED block flag, and attach it to blocks containing pinned
objects (in addition to the usual BF_LARGE).

In heapCensus, we now ignore blocks containing pinned objects, because
they might contain gaps, and in any case it isn't clear that we want
to include the whole block in a heap census, because much of it might
well be dead.  Ignoring it isn't right either, though, so this patch
just fixes the crash and leaves a ToDo.

Fix for clearing the evacuated flag on a block: don't throw away other
flag settings in the process.

--------------------------
         Much grunting about let-floating
	   --------------------------

We want to avoid putting bindings between the '=' of a defn and a '\':
	let { f = let ... in \y-> ... } in ...

Reason: float-in often follows float-out, and it may then add yte
more bindings there, some of which may be strict.  But f may by
not be marked as not-demanded (for other reasons: see the call to
zapDemandInfo in Simplify.completeLazyBind); and now the strict binding
may not be able to float out again.  (Well, it triggers the ASSERT in
simplLazyBind.)

So this commit adds FloatOut.floatNonRecRhs (to complement floatRhs) which
is a big more vigorous about floating out.

But that in turn showed up a pile of gore to do with unlifted bindings.
We can't have them showing up at top level.  After thrashing in the swamp
for a while, I eventually arranged that
	let x# = e in b
(where x# has an unlifted type) is treated exactly like
	case e of x# -> b
That is, it is never floated.  Yes, we lose opportunities to float some
(very cheap!  unlifted let-bindings are always cheap) out of a lambda,
but we're missing much bigger opportunities already.  For example:
	\x -> f (h y)

where h :: Int -> Int# is expensive. We'd like to float the (h y) outside
the \x, but we don't because it's unboxed.  Possible solution: box it.
Anyway, that's for the future.

--------------------------
     Move demand-zapping code to where it belongs
	   --------------------------

A rather subtle point in the simplifier concerns the zapping of demand-info
when the RHS of a binding is a value.  This used to be tucked away inside
IdInfo where it was hard to find.  This commit moves the code to Simplify,
so it occurs where you'd look for it.  Along with copious comments.

See the zapDemandInfo in Simplify.completeLazyBind

Add more informative assertion