This re-implements the code generation for case expressions at the Stg →
Cmm level, both for data type cases as well as for integral literal
cases. (Cases on float are still treated as before).

The goal is to allow for fancier strategies in implementing them, for a
cleaner separation of the strategy from the gritty details of Cmm, and
to run this later than the Common Block Optimization, allowing for one
way to attack #10124. The new module CmmSwitch contains a number of
notes explaining this changes. For example, it creates larger
consecutive jump tables than the previous code, if possible.

nofib shows little significant overall improvement of runtime. The
rather large wobbling comes from changes in the code block order
(see #8082, not much we can do about it). But the decrease in code size
alone makes this worthwhile.

```
        Program           Size    Allocs   Runtime   Elapsed  TotalMem
            Min          -1.8%      0.0%     -6.1%     -6.1%     -2.9%
            Max          -0.7%     +0.0%     +5.6%     +5.7%     +7.8%
 Geometric Mean          -1.4%     -0.0%     -0.3%     -0.3%     +0.0%
```

Compilation time increases slightly:
```
        -1 s.d.                -----            -2.0%
        +1 s.d.                -----            +2.5%
        Average                -----            +0.3%
```

The test case T783 regresses a lot, but it is the only one exhibiting
any regression. The cause is the changed order of branches in an
if-then-else tree, which makes the hoople data flow analysis traverse
the blocks in a suboptimal order. Reverting that gets rid of this
regression, but has a consistent, if only very small (+0.2%), negative
effect on runtime. So I conclude that this test is an extreme outlier
and no reason to change the code.

Differential Revision: https://phabricator.haskell.org/D720

Test Plan: validate twice

Reviewed by: thomie

Differential Revision: https://phabricator.haskell.org/D771

Signed-off-by: Edward Z. Yang <ezyang@cs.stanford.edu>

Reviewed By: kgardas

Differential Revision: https://phabricator.haskell.org/D763

Before:
Cpp     = Pre-process C
Ccpp    = Compile C++
Cobjcpp = Compile Objective-C++
CmmCpp  = Pre-process Cmm

Quite confusing! This commit renames `Ccpp` to `Ccplusplus`, and
`Cobjcpp` to `Cobjcplusplus`. The two letters `p-p` keep standing for
`pre-processing` throughout the compiler.

Reviewed By: austin

Differential Revision: https://phabricator.haskell.org/D756

Summary:
The list was 14 years old, and there don't seem to be any problems
with seq# or par#; the other par*# primops were not actually
implemented at all and were removed in D758.

Test Plan:
validate; will also try to locally validate an unregisterised build
in case there was some truth to the deleted comment

Reviewers: austin

Subscribers: thomie

Differential Revision: https://phabricator.haskell.org/D759

GHC Trac Issues: #10191

Summary:
An attempt to use these resulted in an error like:

[1 of 1] Compiling Main             ( p.hs, p.o )
ghc: panic! (the 'impossible' happened)
  (GHC version 7.8.4 for x86_64-unknown-linux):
	emitPrimOp: can't translate PrimOp  parAt#{v}

Test Plan: validate

Reviewers: thomie, austin

Reviewed By: thomie, austin

Subscribers: thomie

Differential Revision: https://phabricator.haskell.org/D758

By mistake, the Git-commit-id detection was only enabled for
`RELEASE=NO` (since the date-based GHC version computation is
only active in that case). With this commit the commit-id
detection is active regardless of the `RELEASE`-setting.

This is a follow-up to 73e5e2f8

This was proposed a couple of times in the past, e.g.

 - https://mail.haskell.org/pipermail/libraries/2011-November/017153.html
 - https://mail.haskell.org/pipermail/libraries/2013-July/020446.html

but its implementation had been blocked by the fact that `Monoid` wasn't
in scope where the `Monad` class was defined. Since the AMP/FTP restructuring
this is no longer the case.

This is a minor refactoring, but it simplifies the code quite a bit

* Decrease the number of variants of tcExtend in TcEnv
* Remove "not_actually_free" from TcEnv.tc_extend_local_env2
* Simplify plumbingof the "closed" flag
* Remove redundant scoping of wild-card variables

This is a variation of T2431 where the emptyness of the type is hidden
behind a newtype, a type family and a closed type family. In all cases,
it would be sound for the compiler to determine that the equality type
is empty and the case alternatives may be dropped.

At the moment, GHC does _not_ determine that. But if it ever does, this
test ensures that we do not forget to make the lint from #10180 smarter
as well.

The last trace of NDP was removed in 2008 in commit:
44ee866e

NDP stood for 'Nested Data Parallelism'. It was superseded by Data
Parallel Haskell (DPH).

Reviewed By: austin

Differential Revision: https://phabricator.haskell.org/D752

This addresses https://ghc.haskell.org/trac/ghc/ticket/10180#comment:6
[skip ci]

Any expression with of empty type is necessary bottom, so we can use
that here. No effects known, but it is the right thing to do and
validate, so lets do it.

Differential Revision: https://phabricator.haskell.org/D754

Signed-off-by: Edward Z. Yang <ezyang@cs.stanford.edu>

Test Plan: validate with 7.8 stage0 and HEAD stage0

Reviewers: austin, kgardas

Subscribers: thomie

Differential Revision: https://phabricator.haskell.org/D740

The LLVM developers seem to make breaking changes in the LLVM IR
language between major releases. As a consumer of the LLVM tools
GHC now needs to be locked more tightly to a single version of
the LLVM tools.

GHC HEAD currently only supports LLVM version 3.6. This commit
changes the configure script to look for `llc-3.6` and `opt-3.6`
before looking for `llc` and `opt`. If the former are not found,
but the later are, check that they actually are version 3.6.

At the same time, when detecting known problems with the LLVM
tools (ie #9439) test for it using the versions of the LLVM tools
retrieved from the bootstrap compiler's settings file.

Test Plan: Manual testing.

Reviewers: thomie, rwbarton, nomeata, austin

Subscribers: thomie

Differential Revision: https://phabricator.haskell.org/D745

GHC Trac Issues: #10170

[skip ci]

in a follow up to #10180.

The arity of an id should not be larger than what the type allows, and
it should also not contradict the strictness signature. This adds a lint
check for that.

This broke test T8743, uncovering a bug in the SOURCE import machinery,
which is now filed as #10182.

detected either by exprIsBottom or by an empty type.

This was suggested by SPJ and fixes #10180.

as evaluting (\ (@ a) -> e) diverges if and only if evaluating e
diverges. This was found in the context of #10180.

This implements (roughly) the plan put forward in comment:14:ticket:7788,
fixing #7788, #8550, #9554, #10139, and addressing concerns raised in #10079.
There are some regressions w.r.t. GHC 7.8, but only with pathological type
families (like F a = F a). This also (hopefully -- don't have a test case)
fixes #10158. Unsolved problems include #10184 and #10185, which are both
known deficiencies of the approach used here.

As part of this change, the plumbing around detecting infinite loops has
changed. Instead of -fcontext-stack and -ftype-function-depth, we now have
one combined -freduction-depth parameter. Setting it to 0 disbales the
check, which is now the recommended way to get (terminating) code to
typecheck in releases. (The number of reduction steps may well change between
minor GHC releases!)

This commit also introduces a new IntWithInf type in BasicTypes
that represents an integer+infinity. This type is used in a few
places throughout the code.

Tests in
  indexed-types/should_fail/T7788
  indexed-types/should_fail/T8550
  indexed-types/should_fail/T9554
  indexed-types/should_compile/T10079
  indexed-types/should_compile/T10139
  typecheck/should_compile/T10184  (expected broken)
  typecheck/should_compile/T10185  (expected broken)

This commit also changes performance testsuite numbers, for the better.

Another bug in the #10164 series. Only Python 2.7 and up allow you to
omit the positional argument specifiers in format strings.

Test Plan: this fixes the Solaris builders

Reviewed By: kgardas

Differential Revision: https://phabricator.haskell.org/D750

GHC Trac Issues: #10164

Turns out we've been a bit too lazy and quite a few undocumented changes have
accumulated in `base` relative to GHC 7.10's `base-4.8.0.0`...

[skip ci]

We've accumulated enough to justify a minor version bump to 4.8.1.0,
but not enough to justify a major version bump yet as far as I can see.

[ci skip]

The `configure` script checks for presence of `install-sh` even if
it's not used, so we simply add it to the distribution to make `configure`
happy.

[skip ci]

(cherry picked from commit 7bd3efe3)

There were some flags of the RTS that when given an argument (which they
don't have) were not firing an error.
e.g -Targument when the flag -T has no argument.
Now this is an error and affects the following flags:
-B -w -T -Z -P -Pa -c -t
Signed-off-by: Carlos Tomé <carlostome1990@gmail.com>

Reviewed By: austin, thomie, hvr

Differential Revision: https://phabricator.haskell.org/D748

GHC Trac Issues: #9839

Reviewers: austin

Subscribers: thomie

Differential Revision: https://phabricator.haskell.org/D749

Signed-off-by: Austin Seipp <austin@well-typed.com>

to not accidentially invalidate a strictness signature with a Diverges
result info. This seems to fix #10176.

Differential Revision: https://phabricator.haskell.org/D747

originally provided by Neil Mitchell. Despite what he observed, I can
observe the bug even with all in one module.

In #9261, there was some confusion about the meaning of the taskCount
stats variable in the rts.

It turns out that taskCount is not decremented when a worker task is
stopped (i.e. from workerTaskStop), but only when freeMyTask is called,
which frees the task bound to the current thread. So taskCount is the
current number of bound tasks + the total number of worker tasks.

This makes the calculation of the current number of bound tasks in
rts/Stats.c correct _as is_.

[skip ci]

Reviewed By: austin

Differential Revision: https://phabricator.haskell.org/D746

This fixes compilation under windows with pre-AMP GHCs
although it's not clear if bootstrapping GHC was affected.
(see https://github.com/judah/haskeline/issues/20 for details)

Signed-off-by: Austin Seipp <austin@well-typed.com>

Removed a trailing `in` from the final line which caused a compilation
error. [skip ci]

Reviewed by: thomie

Differential Revision: https://phabricator.haskell.org/D744