UniqSupply: make mkSplitUniqSupply thread-safe

unsafeInterleaveIO is used instead of unsafeDupableInterleaveIO because
a mk_supply thunk that is simultaneously entered by two threads should
evaluate to the same UniqSupply.

The UniqSupply counter is now incremented atomically using the RTS's
atomic_inc().

To mitigate the extra overhead of unsafeInterleaveIO in the
single-threaded compiler, noDuplicate# is changed to exit early when
n_capabilities == 1.
TcRnMonad: make forkM thread-safe

A forkM'd action cannot safely share a UniqSupply with its parent.

[ Originally I resolved this issue in another way: by atomically
  updating env_us in newUnique/newUniqueSupply. But I think this
  (equivalent) change is more sensible. ]
FastString: make the string table thread-safe

While we're at it, consolidate duplicate code into a helper function and
strictify a few arguments.
SysTools: make various functions thread-safe
TidyPgm: Atomically update the NameCache in tidyTopName
Binary: Make lazyGet more thread-safe

All values read lazily from the same BinHandle share the same mutable
offset variable (_off_r). If two such lazy values are simultaneously
evaluated, the two threads will step over each other when writing to
_off_r.

Fortunately, for BinMem handles, making lazyGet thread-safe is simple:
just use a fresh off_r variable when deferring the call to getAt.

For BinIO handles, a race condition still exists because IO handles
contain their own mutable file pointer variable that gets clobbered in a
similar way that _off_r would. But GHC doesn't use BinIO handles anywhere
so this particular issue could be ignored for now.
TcEnv: Make mkWrapperName deterministic and thread-safe
Make stdout and stderr line-buffered

An unbuffered handle is very slow to output to and there doesn't seem to
be any reason to have these handles unbuffered.
Implement the parallel upsweep (#910)

The parallel upsweep is the parallel counterpart to the default
sequential upsweep. It attempts to compile modules in parallel by
subdividing the work of the upsweep into parts that can be executed
concurrently by multiple Haskell threads.

In order to enable the parallel upsweep, the user has to pass the -jN
flag to GHC, where N is an optional number denoting the number of jobs,
or modules, to compile in parallel, like with GNU make. In GHC this just
sets the number of capabilities to N.
Binary: eradicate BinIO handles

They are not used anywhere in the compiler.
Properly handle import loops in the parallel upsweep
Buffer stdout and stderr when we're compiling via GHCi
Pass a DynFlags argument explicitly to typecheckLoop

In the parallel upsweep, typecheckLoop has to use a different DynFlags
than the one in its HscEnv argument so that the debug message in
typecheckLoop will be outputted in order.
Merge branch 'master' into ghc-parmake-gsoc

Conflicts:
	compiler/main/DynFlags.hs
	compiler/utils/FastString.lhs
Rename DynFlags.parUpsweepNum to parMakeCount
Retain boot modules in getModLoop

The parallel upsweep needs to know about _all_ the modules that make up
a module loop in order to correctly determine a module's external loop
dependencies. Otherwise, incorrect dependency information may be
computed, resulting in an eventual deadlock during compilation.

So don't filter boot modules in getModLoop, and instead have its callers
filter them when needed.

Following this change, GHC could compile itself via --make -O2 -j. Yay!
Fix definition of DefinerOfRegs for CmmForeignCall

And update comments
Turn manual Typeable instances into errors; fixes #8132
Add --show-options to --help (#8190)

Signed-off-by: Austin Seipp <aseipp@pobox.com>
Merge remote-tracking branch 'origin/master' into ghc-parmake-gsoc