<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">

<html lang="en">

<head>

<meta content="text/html; charset=US-ASCII" http-equiv="Content-Type">

<title>

GitLab

</title>

<style>img {

max-width: 100%; height: auto;

}

</style>

</head>

<body>

<div class="content">

<h3>

Shayne Fletcher pushed to branch wip/T18599

at <a href="https://gitlab.haskell.org/ghc/ghc">Glasgow Haskell Compiler / GHC</a>

</h3>

<h4>

Commits:

</h4>

<ul>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8b86509270227dbc61f0700c7d9261a4c7672361">8b865092</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-23T14:12:53+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Do not print synonyms in :i (->), :i Type (#18594)

This adds a new printing flag `sdocPrintTypeAbbreviations` that is used

specifically to avoid ghci printing 'type (->) = (->)' and 'type Type = Type'.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d8f61182c3bdd1b6121c83be632b4941b907de88">d8f61182</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-23T14:12:56+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move pprTyTcApp' inside pprTyTcApp

No semantic change

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/364258e0ad25bc95e69745554f5ca831ce80baf8">364258e0</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-24T00:32:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix types in silly shifts (#18589)

Patch written by Simon. I have only added a testcase.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b1eb38a0a7168d7612c791c4289cc02d900d402f">b1eb38a0</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-24T00:33:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Perf: make SDoc monad one-shot (#18202)

With validate-x86_64-linux-deb9-hadrian:

   T1969  -3.4% (threshold: +/-1%)

   T3294  -3.3% (threshold: +/-1%)

   T12707 -1.4% (threshold: +/-1%)

Additionally with validate-x86_64-linux-deb9-unreg-hadrian:

   T4801  -2.4% (threshold: +/-2%)

   T13035 -1.4% (threshold: +/-1%)

   T13379 -2.4% (threshold: +/-2%)

   ManyAlternatives -2.5% (threshold: +/-2%)

   ManyConstructors -3.0% (threshold: +/-2%)

Metric Decrease:

    T12707

    T1969

    T3294

    ManyAlternatives

    ManyConstructors

    T13035

    T13379

    T4801

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a77b9ec2a6153065565bca7bb154fff35b830b82">a77b9ec2</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-24T10:04:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add a test for #18397

The bug was fixed by !3421.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/05550a5abc369e1cc4fc48def532ca9ba9adcad7">05550a5a</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-24T10:04:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Avoid roundtrip through SDoc

As found by @monoidal on https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3885#note_295126

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0a1ecc5fd45a46372c3935df596f05432db1b270">0a1ecc5f</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-25T07:37:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">SysTools.Process: Handle exceptions in readCreateProcessWithExitCode'

In #18069 we are observing MVar deadlocks from somewhere in ghc.exe.

This use of MVar stood out as being one of the more likely culprits.

Here we make sure that it is exception-safe.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/db8793ad417ebfcb57d42e8111674a90706a7918">db8793ad</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-08-25T07:37:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use tcView, not coreView, in the pure unifier.

Addresses a lingering point within #11715.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fb77207a23deade8e3f8598c34598535711264cc">fb77207a</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-08-25T07:38:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use LIdP rather than (XRec p (IdP p))

This patch mainly just replaces use of

    XRec p (IdP p)

with

    LIdP p

One slightly more significant change is to parameterise

HsPatSynDetails over the pass rather than the argument type,

so that it's uniform with HsConDeclDetails and HsConPatDetails.

I also got rid of the dead code GHC.Hs.type.conDetailsArgs

But this is all just minor refactoring. No change in functionality.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8426a1364ba450fe48fc41a95b2ba76c8d1bb7c8">8426a136</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-25T07:38:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add a test for #18585

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2d635a50b81732b2512b68c652aee36f489b5969">2d635a50</a></strong>

<div>

<span>by Takenobu Tani</span>

<i>at 2020-08-26T04:50:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">linters: Make CPP linter skip image files

This patch adds an exclusion rule for `docs/users_guide/images`,

to avoid lint errors of PDF files.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b7d98cb2606997e05ad6406929dae3aba746fbb9">b7d98cb2</a></strong>

<div>

<span>by Takenobu Tani</span>

<i>at 2020-08-26T04:50:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: Color the logo on the front page of the PDF

This patch updates the logo with a recent color scheme.

This affects only the PDF version of the user's guide.

See also:

* https://mail.haskell.org/pipermail/ghc-devs/2020-August/019139.html

* https://gitlab.haskell.org/ghc/ghc/-/wikis/logo

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0b17fa185aec793861364afd9a05aa4219fbc019">0b17fa18</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-26T04:50:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor UnitId pretty-printing

When we pretty-print a UnitId for the user, we try to map it back to its

origin package name, version and component to print

"package-version:component" instead of some hash.

The UnitId type doesn't carry these information, so we have to look into

a UnitState to find them. This is why the Outputable instance of

UnitId used `sdocWithDynFlags` in order to access the `unitState` field

of DynFlags.

This is wrong for several reasons:

1. The DynFlags are accessed when the message is printed, not when it is

   generated. So we could imagine that the unitState may have changed

   in-between. Especially if we want to allow unit unloading.

2. We want GHC to support several independent sessions at once, hence

   several UnitState. The current approach supposes there is a unique

   UnitState as a UnitId doesn't indicate which UnitState to use.

See the Note [Pretty-printing UnitId] in GHC.Unit for the new approach

implemented by this patch.

One step closer to remove `sdocDynFlags` field from `SDocContext`

(#10143).

Fix #18124.

Also fix some Backpack code to use SDoc instead of String.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/dc476a5040cdc64c177de0f78edaafec0972cff4">dc476a50</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-26T04:51:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: fix BigNat subtraction (#18604)

There was a confusion between the boolean expected by

withNewWordArrayTrimedMaybe and the boolean returned by subtracting

functions.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fcb10b6c69e388d8c6e777baf39920e2cc694501">fcb10b6c</a></strong>

<div>

<span>by Peter Trommler</span>

<i>at 2020-08-26T10:42:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PPC and X86: Portable printing of IEEE floats

GNU as and the AIX assembler support floating point literals.

SPARC seems to have support too but I cannot test on SPARC.

Curiously, `doubleToBytes` is also used in the LLVM backend.

To avoid endianness issues when cross-compiling float and double literals

are printed as C-style floating point values. The assembler then takes

care of memory layout and endianness.

This was brought up in #18431 by @hsyl20.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/770100e0266750a313b34a52a60968410fcf0769">770100e0</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-26T10:43:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">primops: Remove Monadic and Dyadic categories

There were four categories of primops: Monadic, Dyadic, Compare, GenPrimOp.

The compiler does not treat Monadic and Dyadic in any special way,

we can just replace them with GenPrimOp.

Compare is still used in isComparisonPrimOp.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/01ff8c89727a91cbc1571ae54f73f5919d6aaa71">01ff8c89</a></strong>

<div>

<span>by Aditya Gupta</span>

<i>at 2020-08-27T14:19:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Consolidate imports in getMinimalImports (#18264)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bacccb73c9b080c3c01a5e55ecb0a00cd8a77e55">bacccb73</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-08-27T14:20:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make {hsExpr,hsType,pat}NeedsParens aware of boxed 1-tuples

`hsExprNeedsParens`, `hsTypeNeedsParens`, and `patNeedsParens`

previously assumed that all uses of explicit tuples in the source

syntax never need to be parenthesized. This is true save for one

exception: boxed one-tuples, which use the `Solo` data type from

`GHC.Tuple` instead of special tuple syntax. This patch adds the

necessary logic to the three `*NeedsParens` functions to handle

`Solo` correctly.

Fixes #18612.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c6f50cea42a9ffc947bf4243986663cc820b0ec8">c6f50cea</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-28T02:22:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add missing primop documentation (#18454)

- Add three pseudoops to primops.txt.pp, so that Haddock renders

  the documentation

- Update comments

- Remove special case for "->" - it's no longer exported from GHC.Prim

- Remove reference to Note [Compiling GHC.Prim] - the ad-hoc fix is no

  longer there after updates to levity polymorphism.

- Document GHC.Prim

- Remove the comment that lazy is levity-polymorphic.

  As far as I can tell, it never was: in 80e399639,

  only the unfolding was given an open type variable.

- Remove haddock hack in GHC.Magic - no longer neccessary after

  adding realWorld# to primops.txt.pp.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f065b6b012fb8f73689bc5c2a4904d5e6e377af8">f065b6b0</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-08-28T02:23:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix use distro toolchian

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4517a38215eb72a4824c72d97377b9325059bf55">4517a382</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-08-28T02:23:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">document how build system find toolchains on Windows

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/329f7cb958551f5b384e2765a823770150152da2">329f7cb9</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-31T22:59:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">base: Better error message on invalid getSystemTimerManager call

Previously we would produce a rather unhelpful pattern match failure

error in the case where the user called `getSystemTimerManager` in a

program which isn't built with `-threaded`. This understandably confused

the user in #15616.

Fixes #15616.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f6d70a8ff6a6cd628738fec902fc984936105264">f6d70a8f</a></strong>

<div>

<span>by Roland Senn</span>

<i>at 2020-08-31T22:59:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add tests for #15617.

Avoid a similar regression in the future.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e5969fd06ad4b4c31a8bdce51d35f9aa05594b49">e5969fd0</a></strong>

<div>

<span>by Roland Senn</span>

<i>at 2020-08-31T23:00:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add additional tests for #18172 (Followup MR 3543)

There was still one active discussion [thread](https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3543#note_284325) when MR !3543 got merged.

This MR adds the requested tests exercising the changes in

`compiler/GHC/HsToCore/Match/Literal.hs:warnAboutEmptyEnumerations` and its sub-functions.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fe18b4825c3289089a65b7b16b25e9d216a5b0fd">fe18b482</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-31T23:01:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump Win32 and process submodules

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2da933084b766fc424b11f5b671574d4c7317134">2da93308</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-31T23:01:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: fix slow-validate flavour (#18586)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/85e13008fb9a319c0b79db7c626f37bf20731beb">85e13008</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-08-31T23:02:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update dominator code with fixes from the dom-lt package.

Two bugs turned out in the package that have been fixed since.

This MR includes this fixes in the GHC port of the code.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/dffb38fab00ac1cd1cbc75156abcf373976581f7">dffb38fa</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-08-31T23:02:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Dominators.hs: Use unix line endings

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6189cc04ca6c3d79126744e988b487f75ccef9e2">6189cc04</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-08-31T23:02:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[fixup 3433] move debugBelch into IF_DEBUG(linker)

The commit in dff1cb3d9c111808fec60190747272b973547c52 incorrectly left

the `debugBelch` function without a comment or IF_DEBUG(linker,)

decoration. This rectifies it.

Needs at least a 8.10 backport, as it was backported in 6471cc6aff80d5deebbdb1bf7b677b31ed2af3d5

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bcb68a3f7f85b9fdef6f4845e608d086b01e6a58">bcb68a3f</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-31T23:03:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't store HomeUnit in UnitConfig

Allow the creation of a UnitConfig (hence of a UnitState) without having

a HomeUnit. It's required for #14335.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0a3723876c6c79a0a407d50f4baa2818a13f232e">0a372387</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-31T23:04:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix documentation and fix "check" bignum backend (#18604)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/eb85f125a227f6b5703d4a2e997c5ea320dfa31f">eb85f125</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-08-31T23:04:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Set the dynamic-system-linker flag to Manual

This flag should be user controllable, hence Manual: True.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/380ef84587fb6890d100c338d1992a6994a4f02a">380ef845</a></strong>

<div>

<span>by Sven Tennie</span>

<i>at 2020-08-31T23:05:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Ignore more files

Ignore files from "new style" cabal builds (dist-newstyle folders) and

from clangd (C language server).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/74a7fbff5a8f244cd44345bf987e26413bb1989e">74a7fbff</a></strong>

<div>

<span>by Takenobu Tani</span>

<i>at 2020-08-31T23:05:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Limit upper version of Happy for ghc-9.0 and earlier (#18620)

This patch adds the upper bound of a happy version for ghc-9.0

and earlier.

Currently, we can't use happy-1.20.0 for ghc-9.0.

See #18620.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a4473f02ae2e685601e257b8668bea2ec721b294">a4473f02</a></strong>

<div>

<span>by Takenobu Tani</span>

<i>at 2020-08-31T23:05:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Limit upper version of Happy for ghc-9.2 (#18620)

This patch adds the upper bound of a happy version for ghc-9.2.

Currently, We can use happy-1.19 or happy-1.20 for ghc-9.2.

See #18620.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a8a2568b7b64e5b9fca5b12df7da759de4db39ae">a8a2568b</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-31T23:06:28-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add BigNat compat functions (#18613)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/884245dd29265b7bee12cda8c915da9c916251ce">884245dd</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-01T12:39:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix FastString lexicographic ordering (fix #18562)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4b4fbc58d37d37457144014ef82bdd928de175df">4b4fbc58</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-01T12:39:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove "Ord FastString" instance

FastStrings can be compared in 2 ways: by Unique or lexically. We don't

want to bless one particular way with an "Ord" instance because it leads

to bugs (#18562) or to suboptimal code (e.g. using lexical comparison

while a Unique comparison would suffice).

UTF-8 encoding has the advantage that sorting strings by their encoded

bytes also sorts them by their Unicode code points, without having to

decode the actual code points. BUT GHC uses Modified UTF-8 which

diverges from UTF-8 by encoding \0 as 0xC080 instead of 0x00 (to avoid

null bytes in the middle of a String so that the string can still be

null-terminated). This patch adds a new `utf8CompareShortByteString`

function that performs sorting by bytes but that also takes Modified

UTF-8 into account. It is much more performant than decoding the strings

into [Char] to perform comparisons (which we did in the previous patch).

Bump haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b4edcde70160820dd23c53d9019f895930e2c0e7">b4edcde7</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-01T14:53:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add broken test for #18302

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bfab2a30be5cc68e7914c3f6bb9ae4ad33283ffc">bfab2a30</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-02T15:54:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Turn on -XMonoLocalBinds by default (#18430)

And fix the resulting type errors.

Co-authored-by: Krzysztof Gogolewski <krz.gogolewski@gmail.com>

Metric Decrease:

    parsing001

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c30cc0e9c3704b24ad0f6d9a0199bf8b5835bd40">c30cc0e9</a></strong>

<div>

<span>by David Feuer</span>

<i>at 2020-09-02T15:55:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove potential space leak from Data.List.transpose

Previously, `transpose` produced a list of heads

and a list of tails independently. This meant that

a function using only some heads, and only some tails,

could potentially leak space. Use `unzip` to work

around the problem by producing pairs and selector

thunks instead. Time and allocation behavior will

be worse, but there should be no more leak potential.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ffc3da474bd6febf8a120ebd432ad69f92fe03e0">ffc3da47</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-02T15:56:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove outdated note

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/85e621234916e9b5d40174831a3b422bd99f8f83">85e62123</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-02T15:56:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add missing compat import/export functions

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/397c2b03e90e74c94ff55849adb6aa2a84e3e783">397c2b03</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-03T17:31:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Work around Raspbian's silly packaging decisions

See #17856.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4891c18a49876958b44e50dc6e2f24326d92052f">4891c18a</a></strong>

<div>

<span>by Kathryn Spiers</span>

<i>at 2020-09-03T17:32:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">expected-undocumented-flags remove kill flags

It looks like the flags were removed in https://gitlab.haskell.org/ghc/ghc/-/commit/3e27205a66b06a4501d87eb31e285eadbc693eb7

and can safely be removed here</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1d6d648866da9e7754859c48235f8009b8c130fd">1d6d6488</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-04T16:24:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't rely on CLabel's Outputable instance in CmmToC

This is in preparation of the removal of sdocWithDynFlags (#10143),

hence of the refactoring of CLabel's Outputable instance.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/89ce7cdf977304cb7d0f325a013f822600c1bfbf">89ce7cdf</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-04T16:24:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: use Platform in foldRegs*

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/220ad8d67af345cf3decf82ff26c1e696d21ac93">220ad8d6</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-04T16:24:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: don't pass DynFlags to cmmImplementSwitchPlans

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c1e54439be3d38a1f972ac772cca7eec5e1519a9">c1e54439</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-04T16:25:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Introduce isBoxedTupleDataCon and use it to fix #18644

The code that converts promoted tuple data constructors to

`IfaceType`s in `GHC.CoreToIface` was using `isTupleDataCon`, which

conflates boxed and unboxed tuple data constructors. To avoid this,

this patch introduces `isBoxedTupleDataCon`, which is like

`isTupleDataCon` but only works for _boxed_ tuple data constructors.

While I was in town, I was horribly confused by the fact that there

were separate functions named `isUnboxedTupleCon` and

`isUnboxedTupleTyCon` (similarly, `isUnboxedSumCon` and

`isUnboxedSumTyCon`). It turns out that the former only works for

data constructors, despite its very general name! I opted to rename

`isUnboxedTupleCon` to `isUnboxedTupleDataCon` (similarly, I renamed

`isUnboxedSumCon` to `isUnboxedSumDataCon`) to avoid this potential

confusion, as well as to be more consistent with

the naming convention I used for `isBoxedTupleDataCon`.

Fixes #18644.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/07bdcac38c90e79db9e4327f87c5400630dfe74b">07bdcac3</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-04T22:26:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Avoid hard-coded ld path on Windows

The fix to #17962 ended up regressing on Windows as it failed to

replicate the logic responsible for overriding the toolchain paths on

Windows. This resulted in a hard-coded path to a directory that likely

doesn't exist on the user's system (#18550).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0be8e746b820662a09bf9e406bb7e86da3b548e6">0be8e746</a></strong>

<div>

<span>by Benjamin Maurer</span>

<i>at 2020-09-04T22:27:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Documented the as of yet undocumented '--print-*'  GHC flags,

as well as `-split-objs`, since that is related to

`--print-object-splitting-supported`.

See #18641

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4813486f8756fde7889b214e6e41ae63465f7ad7">4813486f</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-04T22:27:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move Hadrian's wiki pages in tree (fix #16165)

Only the debugging page contains interesting stuff. Some of this stuff

looks old (e.g. recommending "cabal install")...

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7980ae23696f2406c65ee498155b26c09d3d4394">7980ae23</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-05T14:50:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Consistently use stgMallocBytes instead of malloc

This can help in debugging RTS memory leaks since all allocations go

through the same interface.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/67059893a232e682aa5eca7a3d13042b1c884d55">67059893</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Fix whitespace

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/be2cc0ad2109894d2f576c73e3f037b6b79a6bdc">be2cc0ad</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: More intelligent detection of locale availability

Previously ci.sh would unconditionally use C.UTF-8. However, this fails

on Centos 7, which appears not to provide this locale. Now we first try

C.UTF-8, then try en_US.UTF-8, then fail.

Works around #18607.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15dca84793d5ec4ff922726477923e40caa075eb">15dca847</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Rename RELEASE variable to RELEASE_JOB

This interfered with the autoconf variable of the same name, breaking

pre-release builds.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bec0d1701673a80d9517acabf559738613ba4e9c">bec0d170</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Bump Windows toolchain version

This should have been done when we bumped the bootstrap compiler to

8.8.4.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9fbaee212ff527c3a91c350c7e54c75c1484d778">9fbaee21</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Drop Windows make job

These are a significant burden on our CI resources and end up failing

quite often due to #18274. Here I drop the make jobs during

validaion; it is now run only during the nightly builds.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/869f6e193d302c566ff0fbd530e8427440d0d2e3">869f6e19</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Drop Windows-specific output for parseTree

The normalise_slashes normaliser should handle this.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2c9f743c0d034b1a99b22d48e4ff7a3b6670aaa5">2c9f743c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:28-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T5975[ab] as broken on Windows

Due to #7305.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/643785e3835de2de6c575e6418db0d4598b72a7d">643785e3</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:28-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Fix typo

A small typo in a rule regular expression.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c5413fc62342f05d48e62f92c81a7f8a3259d3d7">c5413fc6</a></strong>

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-07T09:33:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add clarification regarding poll/kqueue flags

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/10434d60c62fee7212f08bffde624702f81e93cf">10434d60</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-07T09:34:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Configure bignum backend in Hadrian builds

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d4bc9f0de7992f60bce403731019829f6248cc2c">d4bc9f0d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-07T09:34:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Use hadrian builds for Windows release artifacts

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4ff93292243888545da452ea4d4c1987f2343591">4ff93292</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-09-07T21:18:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[macOS] improved runpath handling

In b592bd98ff25730bbe3c13d6f62a427df8c78e28 we started using

-dead_strip_dylib on macOS when lining dynamic libraries and binaries.

The underlying reason being the Load Command Size Limit in macOS

Sierra (10.14) and later.

GHC will produce @rpath/libHS... dependency entries together with a

corresponding RPATH entry pointing to the location of the libHS...

library. Thus for every library we produce two Load Commands.  One to

specify the dependent library, and one with the path where to find it.

This makes relocating libraries and binaries easier, as we just need to

update the RPATH entry with the install_name_tool. The dynamic linker

will then subsitute each @rpath with the RPATH entries it finds in the

libraries load commands or the environement, when looking up @rpath

relative libraries.

-dead_strip_dylibs intructs the linker to drop unused libraries. This in

turn help us reduce the number of referenced libraries, and subsequently

the size of the load commands.  This however does not remove the RPATH

entries.  Subsequently we can end up (in extreme cases) with only a

single @rpath/libHS... entry, but 100s or more RPATH entries in the Load

Commands.

This patch rectifies this (slighly unorthodox) by passing *no* -rpath

arguments to the linker at link time, but -headerpad 8000.  The

headerpad argument is in hexadecimal and the maxium 32k of the load

command size.  This tells the linker to pad the load command section

enough for us to inject the RPATHs later.  We then proceed to link the

library or binary with -dead_strip_dylibs, and *after* the linking

inspect the library to find the left over (non-dead-stripped)

dependencies (using otool).  We find the corresponding RPATHs for each

@rpath relative dependency, and inject them into the library or binary

using the install_name_tool.  Thus achieving a deadstripped dylib (and

rpaths) build product.

We can not do this in GHC, without starting to reimplement a dynamic

linker as we do not know which symbols and subsequently libraries are

necessary.

Commissioned-by: Mercury Technologies, Inc. (mercury.com)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/df04b81e12dac85292aa18c07e6afac7a8bd2fd5">df04b81e</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-07T21:19:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move DynFlags test into updateModDetailsIdInfos's caller (#17957)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ea1cbb8f2ac9e077ed19530911c3a35c5f46ee8a">ea1cbb8f</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-08T15:42:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Add stg_copyArray_barrier to RtsSymbols list

It's incredible that this wasn't noticed until now.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d7b2f799469a969ad7a2535be57f105186946c40">d7b2f799</a></strong>

<div>

<span>by Daishi Nakajima</span>

<i>at 2020-09-08T15:42:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Output performance test results in tabular format

this was suggested in #18417.

Change the print format of the values.

* Shorten commit hash

* Reduce precision of the "Value" field

* Shorten metrics name

  * e.g. runtime/bytes allocated -> run/alloc

* Shorten "MetricsChange"

  * e.g. unchanged -> unch, increased -> incr

And, print the baseline environment if there are baselines that were

measured in a different environment than the current environment.

If all "Baseline commit" are the same, print it once.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/44472daf500bf862921e89ad45c9741a07a64f61">44472daf</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-08T15:43:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make the forall-or-nothing rule only apply to invisible foralls (#18660)

This fixes #18660 by changing `isLHsForAllTy` to

`isLHsInvisForAllTy`, which is sufficient to make the

`forall`-or-nothing rule only apply to invisible `forall`s. I also

updated some related documentation and Notes while I was in the

neighborhood.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0c61cbfff985723240671b54d6f80075e4907e85">0c61cbff</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-08T15:43:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Handle distributions without locales

Previously we would assume that the `locale` utility exists. However,

this is not so on Alpine as musl's locale support is essentially

non-existent.

(cherry picked from commit 17cdb7ac3b557a245fee1686e066f9f770ddc21e)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d989c84225090f850591e9f4f82adffbf8c96cac">d989c842</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-08T15:43:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Accept Centos 7 C.utf8 locale

Centos apparently has C.utf8 rather than C.UTF-8.

(cherry picked from commit d9f85dd25a26a04d3485470afb3395ee2dec6464)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e5a2899ce8e06b8645946fbb67041807cd3a4fe5">e5a2899c</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-09-09T00:46:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use "to" instead of "2" in internal names of conversion ops

Change the constructors for the primop union, and also names of the

literal conversion functions.

"2" runs into trouble when we need to do conversions from fixed-width

types, and end up with thing like "Int642Word".

Only the names internal to GHC are changed, as I don't want to worry

about breaking changes ATM.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/822f10575d207a2a47b21ac853dcf28c655041c4">822f1057</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-09T00:46:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Postpone associated tyfam default checks until after typechecking

Previously, associated type family defaults were validity-checked

during typechecking. Unfortunately, the error messages that these

checks produce run the risk of printing knot-tied type constructors,

which will cause GHC to diverge. In order to preserve the current

error message's descriptiveness, this patch postpones these validity

checks until after typechecking, which are now located in the new

function `GHC.Tc.Validity.checkValidAssocTyFamDeflt`.

Fixes #18648.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8c892689058912c35ed36e07b5a9ed0df86abc03">8c892689</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-09T11:19:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: add OptCoercionOpts

Use OptCoercionOpts to avoid threading DynFlags all the way down to

GHC.Core.Coercion.Opt

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3f32a9c0f4ddceab14a381bfd3732bcad6be43f7">3f32a9c0</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-09T11:19:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: add UnfoldingOpts and SimpleOpts

Milestone: after this patch, we only use 'unsafeGlobalDynFlags' for the

state hack and for debug in Outputable.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b3df72a699727b00d5dd8212fcbe46cbbec05f9b">b3df72a6</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-09T11:19:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: add sm_pre_inline field into SimplMode (#17957)

It avoids passing and querying DynFlags down in the simplifier.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ffae57921168365272bf7ce8aaa645917bfdf218">ffae5792</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-09T11:19:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add comments about sm_dflags and simpleOptExpr

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7911d0d983a68eb0d54d7c1ba51326d6be737aae">7911d0d9</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-09-09T11:20:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove GENERATED pragma, as it is not being used

@alanz pointed out on ghc-devs that the payload of this pragma does

not appear to be used anywhere.

I (@bgamari) did some digging and traced the pragma's addition back to

d386e0d2 (way back in 2006!).

It appears that it was intended to be used by code generators for use

in informing the code coveraging checker about generated code

provenance. When it was added it used the pragma's "payload" fields as

source location information to build an "ExternalBox". However, it

looks like this was dropped a year later in 55a5d8d9.  At this point

it seems like the pragma serves no useful purpose.

Given that it also is not documented, I think we should remove it.

Updates haddock submodule

Closes #18639

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5aae5b325ccef857800f1840665a0e1b152e9b88">5aae5b32</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-09T18:31:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Bump Docker images

We now generate our Docker images via Dhall definitions, as described in

ghc/ci-images!52. Additionally, we are far more careful about where tools

come from, using the ALEX, HAPPY, HSCOLOR, and GHC environment variables

(set in the Dockerfiles) to find bootstrapping tools.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4ce9fe88e7e98178d5fd6b18ac9cba666a1f8306">4ce9fe88</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-09T18:31:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Fix leakage of GHC in PATH into build

Previously hadrian would use GHC on PATH when configuring packages (or

fail if there is no such GHC). Fix this. Unfortunately this runs into

another bug in Cabal which we workaround.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/291a15dd8dfc03d493c0db36a9cb62fd4867db10">291a15dd</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-09T18:31:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">utils: Bump cabal-version of hp2ps and unlit

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4798caa0fefd7adf4c5b85fa84a6f28fcc6b350b">4798caa0</a></strong>

<div>

<span>by David Himmelstrup</span>

<i>at 2020-09-09T18:32:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts comment: RTS_TICKY_SYMBOLS moved from rts/Linker.c to rts/RtsSymbols.c

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/67ce72da1689058cb689ffbb6fcbd5cd12af56df">67ce72da</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-10T10:35:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add long-distance info for pattern bindings (#18572)

We didn't consider the RHS of a pattern-binding before, which led to

surprising warnings listed in #18572.

As can be seen from the regression test T18572, we get the expected

output now.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1207576ac0cfdd3fe1ea00b5505f7c874613451e">1207576a</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-10T10:35:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Big refactor using guard tree variants more closely following source syntax (#18565)

Previously, we desugared and coverage checked plain guard trees as

described in Lower Your Guards. That caused (in !3849) quite a bit of

pain when we need to partially recover tree structure of the input

syntax to return covered sets for long-distance information, for

example.

In this refactor, I introduced a guard tree variant for each relevant

source syntax component of a pattern-match (mainly match groups, match,

GRHS, empty case, pattern binding). I made sure to share as much

coverage checking code as possible, so that the syntax-specific checking

functions are just wrappers around the more substantial checking

functions for the LYG primitives (`checkSequence`, `checkGrds`).

The refactoring payed off in clearer code and elimination of all panics

related to assumed guard tree structure and thus fixes #18565.

I also took the liberty to rename and re-arrange the order of functions

and comments in the module, deleted some dead and irrelevant Notes,

wrote some new ones and gave an overview module haddock.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/95455982df1ef15c6d4585a7d3e93b5e75146a07">95455982</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-10T10:36:09-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Don't include -fdiagnostics-color in argument hash

Otherwise the input hash will vary with whether colors are requested,

which changed with `isatty`.

Fixes #18672.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6abe4a1c427a511aa698424055639ea789fccf97">6abe4a1c</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-10T17:02:00+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">.gitignore *.hiedb files

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3777be14e104f040b826762f5ab42a8b898d85ae">3777be14</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-10T17:03:12+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Handle ⊥ and strict fields correctly (#18341)

In #18341, we discovered an incorrect digression from Lower Your Guards.

This MR changes what's necessary to support properly fixing #18341.

In particular, bottomness constraints are now properly tracked in the

oracle/inhabitation testing, as an additional field

`vi_bot :: Maybe Bool` in `VarInfo`. That in turn allows us to

model newtypes as advertised in the Appendix of LYG and fix #17725.

Proper handling of ⊥ also fixes #17977 (once again) and fixes #18670.

For some reason I couldn't follow, this also fixes #18273.

I also added a couple of regression tests that were missing. Most of

them were already fixed before.

In summary, this patch fixes #18341, #17725, #18273, #17977 and #18670.

Metric Decrease:

    T12227

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1bd28931903c2fbc10a4b2ecbf9dffd0a3585ac8">1bd28931</a></strong>

<div>

<span>by David Himmelstrup</span>

<i>at 2020-09-11T09:59:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Define TICKY_TICKY when compiling cmm RTS files.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15e67801ee72b94c6c826f641464c6be511685cc">15e67801</a></strong>

<div>

<span>by David Himmelstrup</span>

<i>at 2020-09-11T09:59:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix typos in TICKY_TICKY symbol names.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8a5a91cb67e8c4e2558031c04efccf3c378ba254">8a5a91cb</a></strong>

<div>

<span>by David Himmelstrup</span>

<i>at 2020-09-11T09:59:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enable TICKY_TICKY for debug builds when building with makefiles.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fc965c0910757410d624229419f36f0829cf73f6">fc965c09</a></strong>

<div>

<span>by Sandy Maguire</span>

<i>at 2020-09-12T00:31:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add clamp function to Data.Ord

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fb6e29e8d19deaf7581fdef14adc88a02573c83e">fb6e29e8</a></strong>

<div>

<span>by Sandy Maguire</span>

<i>at 2020-09-12T00:31:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add tests

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2a9422859e0c079aaa38bb9a760034f887501fce">2a942285</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-12T00:32:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Disattach COMPLETE pragma lookup from TyCons

By not attaching COMPLETE pragmas with a particular TyCon and instead

assume that every COMPLETE pragma is applicable everywhere, we can

drastically simplify the logic that tries to initialise available

COMPLETE sets of a variable during the pattern-match checking process,

as well as fixing a few bugs.

Of course, we have to make sure not to report any of the

ill-typed/unrelated COMPLETE sets, which came up in a few regression

tests.

In doing so, we fix #17207, #18277 and #14422.

There was a metric decrease in #18478 by ~20%.

Metric Decrease:

    T18478

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/389a668343c0d4f5fa095112ff98d0da6998e99d">389a6683</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-12T00:32:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Pass input file to makeindex

Strangely I find that on Alpine (and apparently only on Alpine) the

latex makeindex command expects to be given a filename, lest it reads

from stdin.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/853d121acfcdae208e852edacac65a1b3e8cab83">853d121a</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-12T00:33:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't quote argument to Hadrian's test-env flag (#18656)

Doing so causes the name of the test environment to gain an extra

set of double quotes, which changes the name entirely.

Fixes #18656.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8440b5fa1397940f2f293935927e690b34110a73">8440b5fa</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-12T00:33:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make sure we can read past perf notes

See #18656.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2157be52cd454353582b04d89492b239b90f91f7">2157be52</a></strong>

<div>

<span>by theobat</span>

<i>at 2020-09-12T21:27:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Avoid iterating twice in `zipTyEnv` (#18535)

zipToUFM is a new function to replace `listToUFM (zipEqual ks vs)`.

An explicit recursion is preferred due to the sensible nature of fusion.

    T12227 -6.0%

    T12545 -12.3%

    T5030  -9.0%

    T9872a -1.6%

    T9872b -1.6%

    T9872c -2.0%

 -------------------------

Metric Decrease:

    T12227

    T12545

    T5030

    T9872a

    T9872b

    T9872c

-------------------------

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/69ea2fee35b4bcfd9253ee608f7135024186aeed">69ea2fee</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-12T21:27:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make `tcCheckSatisfiability` incremental (#18645)

By taking and returning an `InertSet`.

Every new `TcS` session can then pick up where a prior session left with

`setTcSInerts`.

Since we don't want to unflatten the Givens (and because it leads to

infinite loops, see !3971), we introduced a new variant of `runTcS`,

`runTcSInerts`, that takes and returns the `InertSet` and makes

sure not to unflatten the Givens after running the `TcS` action.

Fixes #18645 and #17836.

Metric Decrease:

    T17977

    T18478

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a77e48d291b35a92731f106d79ea75117ec380e1">a77e48d2</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-12T21:27:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Extract definition of DsM into GHC.HsToCore.Types

`DsM` was previously defined in `GHC.Tc.Types`, along with `TcM`. But

`GHC.Tc.Types` is in the set of transitive dependencies of `GHC.Parser`,

a set which we aim to minimise. Test case `CountParserDeps` checks for

that.

Having `DsM` in that set means the parser also depends on the innards of

the pattern-match checker in `GHC.HsToCore.PmCheck.Types`, which is the

reason we have that module in the first place.

In the previous commit, we represented the `TyState` by an `InertSet`,

but that pulls the constraint solver as well as 250 more modules into

the set of dependencies, triggering failure of `CountParserDeps`.

Clearly, we want to evolve the pattern-match checker (and the desugarer)

without being concerned by this test, so this patch includes a small

refactor that puts `DsM` into its own module.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fd5d622a5ee283d3c1f1ccd28b4f73aab30d7d9f">fd5d622a</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-12T21:27:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hackily decouple the parser from the desugarer

In a hopefully temporary hack, I re-used the idea from !1957 of using a

nullary type family to break the dependency from GHC.Driver.Hooks on the

definition of DsM ("Abstract Data").

This in turn broke the last dependency from the parser to the desugarer.

More details in `Note [The Decoupling Abstract Data Hack]`.

In the future, we hope to undo this hack again in favour of breaking the

dependency from the parser to DynFlags altogether.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/35a7b7ecabeba39e53d6dea78ecc2d3eca8b1b24">35a7b7ec</a></strong>

<div>

<span>by Adam Sandberg Eriksson</span>

<i>at 2020-09-14T17:46:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs: -B rts option sounds the bell on every GC (#18351)</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5ae8212c3d2f284bc18a562625be3f4640984497">5ae8212c</a></strong>

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-14T17:46:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Populate gitlab cache after building

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a5ffb39afc386729c821b924dd2c6a93917e1b5f">a5ffb39a</a></strong>

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-14T17:46:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move ahead cabal cache restoration to before use of cabal

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e8b37c21fdcb9ca515e3dd2fab1661b7792fb728">e8b37c21</a></strong>

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-14T17:46:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Do the hadrian rebuild multicore

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/07762eb5cfe735e131a7f017939a6b0ccfb28389">07762eb5</a></strong>

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-14T17:46:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Also cache other hadrian builds

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8610bcbeb11b898f85f228b755fa8421b5ae3e34">8610bcbe</a></strong>

<div>

<span>by DenisFrezzato</span>

<i>at 2020-09-15T15:19:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix rtsopts documentation

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c7182a5c67fe8b5bd256cb8eb805562636853ea2">c7182a5c</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-15T15:19:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Care with implicit-parameter superclasses

Two bugs, #18627 and #18649, had the same cause: we were not

account for the fact that a constaint tuple might hide an implicit

parameter.

The solution is not hard: look for implicit parameters in

superclasses.  See Note [Local implicit parameters] in

GHC.Core.Predicate.

Then we use this new function in two places

* The "short-cut solver" in GHC.Tc.Solver.Interact.shortCutSolver

  which simply didn't handle implicit parameters properly at all.

  This fixes #18627

* The specialiser, which should not specialise on implicit parameters

  This fixes #18649

There are some lingering worries (see Note [Local implicit

parameters]) but things are much better.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0f3884b0b72fb1e4641450e68f63580c0e86f515">0f3884b0</a></strong>

<div>

<span>by Zubin Duggal</span>

<i>at 2020-09-15T15:20:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Export enrichHie from GHC.Iface.Ext.Ast

This is useful for `ghcide`

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b3143f5a0827b640840ef241a30933dc23b69d91">b3143f5a</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-15T15:21:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enhance metrics output

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4283feaa9e0826211f7a71d543054c989ea32965">4283feaa</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-15T15:21:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Introduce and use DerivClauseTys (#18662)

This switches `deriv_clause_tys` so that instead of using a list of

`LHsSigType`s to represent the types in a `deriving` clause, it now

uses a sum type. `DctSingle` represents a `deriving` clause with no

enclosing parentheses, while `DctMulti` represents a clause with

enclosing parentheses. This makes pretty-printing easier and avoids

confusion between `HsParTy` and the enclosing parentheses in

`deriving` clauses, which are different semantically.

Fixes #18662.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/90229c4b781184d0e59ac67afda90ed316f62bcd">90229c4b</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-16T04:53:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Include -f{write,validate}-ide-info in the User's Guide flag reference

Previously, these were omitted from the flag reference due to a

layout oversight in `docs/users_guide/flags.{rst,py}`.

Fixes #18426.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ce42e187ebfc81174ed477f247f023ae094c9b24">ce42e187</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-16T04:53:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Fix erroneous usage of vsnprintf

As pointed out in #18685, this should be snprintf not vsnprintf. This

appears to be due to a cut-and-paste error.

Fixes #18658.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b695e7d73617ab19170d37b383315e8ede289c5e">b695e7d7</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-16T04:54:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename ghci flag into internal-interpreter

"ghci" as a flag name was confusing because it really enables the

internal-interpreter. Even the ghci library had a "ghci" flag...

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8af954d202de1de0671062c3f55e43fc783f8192">8af954d2</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-16T04:55:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make ghc-boot reexport modules from ghc-boot-th

Packages don't have to import both ghc-boot and ghc-boot-th. It makes

the dependency graph easier to understand and to refactor.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6baa67f5500da6ca74272016ec8fd62a4b5b5050">6baa67f5</a></strong>

<div>

<span>by Adam Sandberg Eriksson</span>

<i>at 2020-09-16T07:45:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs: correct haddock reference

[skip ci]</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7cf09ab013778227caa07b5d7ec9acd5dedd1817">7cf09ab0</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-17T01:27:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Do absence analysis on stable unfoldings

Ticket #18638 showed that Very Bad Things happen if we fail

to do absence analysis on stable unfoldings.  It's all described

in Note [Absence analysis for stable unfoldings and RULES].

I'm a bit surprised this hasn't bitten us before. Fortunately

the fix is pretty simple.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/76d3bcbcef61ac71677855d6f90754ef019b9b4f">76d3bcbc</a></strong>

<div>

<span>by Leif Metcalf</span>

<i>at 2020-09-17T01:28:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Replace deprecated git --recursive

The --recursive flag of git-clone has been replaced by the

--recurse-submodules flag since git 1.7.4, released in 2011.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/da8f4ddd76bac18c721aeaa247725953604206d3">da8f4ddd</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-09-17T01:28:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document IfaceTupleTy

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3c94c81629ac9159775b8b70baf2c635f0331708">3c94c816</a></strong>

<div>

<span>by HaskellMouse</span>

<i>at 2020-09-17T08:49:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Added explicit fixity to (~).

Solves #18252

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b612e396ed1141dadfabc8486876abb713628f06">b612e396</a></strong>

<div>

<span>by Cary Robbins</span>

<i>at 2020-09-17T08:50:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make the 'IsString (Const a b)' instance polykinded on 'b'

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8d0c26c463fc1512ad90788345b002b23e53555a">8d0c26c4</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-17T08:51:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/win32: Fix missing #include's

These slipped through CI.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/76009ec84652f9b5c085f320ad9476e3693549f1">76009ec8</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-17T08:51:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump Win32 submodule to 2.9.0.0

Also bumps Cabal, directory

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/147bb59826087300f989addfcf79e3956f6ed66b">147bb598</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-17T08:51:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump version to 9.0

Bumps haskeline and haddock submodules.

(cherry picked from commit f218cfc92f7b1a1e01190851972bb9a0e0f3c682)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5c7387f6f8896a34af25f8a28a78095e22287752">5c7387f6</a></strong>

<div>

<span>by Leif Metcalf</span>

<i>at 2020-09-17T08:51:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make Z-encoding comment into a note

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c12b3041e533962b8d0ac9ee44e928f874c11671">c12b3041</a></strong>

<div>

<span>by Leif Metcalf</span>

<i>at 2020-09-17T08:51:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Cosmetic

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4f461e1a31263f052effd03738b11ea123512cb0">4f461e1a</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-17T08:52:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Parser.y: clarify treatment of @{-# UNPACK #-}

Before this patch, we had this parser production:

        ftype : ...

              | ftype PREFIX_AT tyarg  { ... }

And 'tyarg' is defined as follows:

        tyarg : atype              { ... }

              | unpackedness atype { ... }

So one might get the (false) impression that that parser production is

intended to parse things like:

        F @{-# UNPACK #-} X

However, the lexer wouldn't produce PREFIX_AT followed by 'unpackedness',

as the '@' operator followed by '{-' is not considered prefix.

Thus there's no point using 'tyarg' after PREFIX_AT,

and a simple 'atype' will suffice:

        ftype : ...

              | ftype PREFIX_AT atype  { ... }

This change has no user-facing consequences. It just makes the grammar a

bit more clear.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9dec8600ad4734607bea2b4dc3b40a5af788996b">9dec8600</a></strong>

<div>

<span>by Benjamin Maurer</span>

<i>at 2020-09-17T08:52:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Documented '-m' flags for machine specific instruction extensions.

See #18641 'Documenting the Expected Undocumented Flags'

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ca48076ae866665913b9c81cbc0c76f0afef7a00">ca48076a</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-17T20:04:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Introduce OutputableP

Some types need a Platform value to be pretty-printed: CLabel, Cmm

types, instructions, etc.

Before this patch they had an Outputable instance and the Platform value

was obtained via sdocWithDynFlags. It meant that the *renderer* of the

SDoc was responsible of passing the appropriate Platform value (e.g. via

the DynFlags given to showSDoc).  It put the burden of passing the

Platform value on the renderer while the generator of the SDoc knows the

Platform it is generating the SDoc for and there is no point passing a

different Platform at rendering time.

With this patch, we introduce a new OutputableP class:

   class OutputableP a where

      pdoc :: Platform -> a -> SDoc

With this class we still have some polymorphism as we have with `ppr`

(i.e. we can use `pdoc` on a variety of types instead of having a

dedicated `pprXXX` function for each XXX type).

One step closer removing `sdocWithDynFlags` (#10143) and supporting

several platforms (#14335).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e45c85446de7589e17acf5654c2b33f766043eb1">e45c8544</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-17T20:04:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Generalize OutputableP

Add a type parameter for the environment required by OutputableP. It

avoids tying Platform with OutputableP.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/37aa224ad5b1cfb17d472c7b88c5c76bf22a52f3">37aa224a</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-17T20:04:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add note about OutputableP

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7f2785f2d6c6947d22d4d8b71d205c7c4b025680">7f2785f2</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-17T20:04:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove pprPrec from Outputable (unused)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b689f3db0229ac58af5383796fb13c6d40e358ce">b689f3db</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-17T20:04:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add clamping naturalToWord (fix #18697)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0799b3de3e3462224bddc0e4b6a3156d04a06361">0799b3de</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-18T15:55:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/nonmoving: Add missing STM write barrier

When updating a TRec for a TVar already part of a transaction we

previously neglected to add the old value to the update remembered set.

I suspect this was the cause of #18587.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c492134912e5270180881b7345ee86dc32756bdd">c4921349</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-18T15:56:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Refactor foreign export tracking

This avoids calling `libc` in the initializers which are responsible for

registering foreign exports. We believe this should avoid the corruption

observed in #18548.

See Note [Tracking foreign exports] in rts/ForeignExports.c for an

overview of the new scheme.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/40dc91069d15bfc1d81f1722b39e06cac8fdddd1">40dc9106</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-18T15:56:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Refactor unloading of foreign export StablePtrs

Previously we would allocate a linked list cell for each foreign export.

Now we can avoid this by taking advantage of the fact that they are

already broken into groups.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/45fa82182bc61e3966fd51496c35130cd067a5df">45fa8218</a></strong>

<div>

<span>by Simon Jakobi</span>

<i>at 2020-09-19T06:57:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Deprecate Data.Semigroup.Option

Libraries email: https://mail.haskell.org/pipermail/libraries/2018-April/028724.html

GHC issue: https://gitlab.haskell.org/ghc/ghc/issues/15028

Corresponding PRs for deepseq:

* https://github.com/haskell/deepseq/pull/55

* https://github.com/haskell/deepseq/pull/57

Bumps the deepseq submodule.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2229d570fc78867190febb4f13c799b258a41f6d">2229d570</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-19T15:47:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Require happy >=1.20

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a89c2fbab9bcf7d769e9d27262ab29f93342f114">a89c2fba</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-19T15:47:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ci.sh: Enforce minimum happy/alex versions

Also, always invoke cabal-install to ensure that happy/alex symlinks are

up-to-date.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2f7ef2fb3234cdfb89b3da1298fc9c1b7381e418">2f7ef2fb</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-19T15:47:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Ensure that cabal-install overwrites existing executables

Previously cabal-install wouldn't overwrite toolchain executables if

they already existed (as they likely would due to caching).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ac213d267140e747a391f68bc9f060e117395547">ac213d26</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-19T15:48:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Wire in constraint tuples

This wires in the definitions of the constraint tuple classes. The

key changes are in:

* `GHC.Builtin.Types`, where the `mk_ctuple` function is used to

  define constraint tuple type constructors, data constructors, and

  superclass selector functions, and

* `GHC.Builtin.Uniques`. In addition to wiring in the `Unique`s for

  constraint tuple type and data constructors, we now must wire in

  the superclass selector functions. Luckily, this proves to be not

  that challenging. See the newly added comments.

Historical note: constraint tuples used to be wired-in until about

five years ago, when commit 130e93aab220bdf14d08028771f83df210da340b

turned them into known-key names. This was done as part of a larger

refactor to reduce the number of special cases for constraint tuples,

but the commit message notes that the main reason that constraint

tuples were made known-key (as opposed to boxed/unboxed tuples, which

are wired in) is because it was awkward to wire in the superclass

selectors. This commit solves the problem of wiring in superclass

selectors.

Fixes #18635.

-------------------------

Metric Decrease:

    T10421

    T12150

    T12227

    T12234

    T12425

    T13056

    T13253-spj

    T18282

    T18304

    T5321FD

    T5321Fun

    T5837

    T9961

Metric Decrease (test_env='x86_64-linux-deb9-unreg-hadrian'):

    T12707

Metric Decrease (test_env='x86_64-darwin'):

    T4029

-------------------------

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e195dae6d959e2a9b1a22a2ca78db5955e1d7dea">e195dae6</a></strong>

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-19T15:48:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Export singleton function from Data.List

Data.OldList exports a monomorphized singleton function but

it is not re-exported by Data.List. Adding the export to

Data.List causes a conflict with a 14-year old function of the

same name and type by SPJ in GHC.Utils.Misc. We can't just remove

this function because that leads to a problems when building

GHC with a stage0 compiler that does not have singleton in

Data.List yet. We also can't hide the function in GHC.Utils.Misc

since it is not possible to hide a function from a module if the

module does not export the function. To work around this, all

places where the Utils.Misc singleton was used now use a qualified

version like Utils.singleton and in GHC.Utils.Misc we are very

specific about which version we export.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9c1b8ad931e7bfabe521bc17e74ac9869b21a748">9c1b8ad9</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-19T15:49:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump Stack resolver

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d05d13ce6b5be54f3aa1c23f4377920a4965fc50">d05d13ce</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-09-19T15:49:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Cinch -fno-warn-name-shadowing down to specific GHCi module

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f1accd00969e0b2993f14ee4ed858cea0c13357e">f1accd00</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-19T15:49:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add quick-validate Hadrian flavour (quick + -Werror)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8f8d51f137ffcdbc4432febc5d1a11a564807b1b">8f8d51f1</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-09-19T15:50:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix docs who misstated how the RTS treats size suffixes.

They are parsed as multiples of 1024. Not 1000. The docs

used to imply otherwise.

See decodeSize in rts/RtsFlags.c for the logic for this.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2ae0edbdfaf920d0c4da4edf721b947e11eb054c">2ae0edbd</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-09-19T15:50:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix a codeblock in ghci.rst

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4df3aa956260e3d84232f43546e297cf425081dd">4df3aa95</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-19T15:51:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users guide: Fix various documentation issues

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/885ecd18e084e4e2b15fbc5de0aa5222f2573387">885ecd18</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-19T15:51:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Fail on Sphinx syntax errors

Specifically the "Inline literal start-string without end-string"

warning, which typically means that the user neglected to separate

an inline code block from suffix text with a backslash.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b26cd86795d86850bfa97aa020d0a46b8ac043da">b26cd867</a></strong>

<div>

<span>by David Feuer</span>

<i>at 2020-09-19T15:51:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Unpack the MVar in Compact

The `MVar` lock in `Compact` was unnecessarily lazy, creating an extra indirection and wasting two words. Make it strict.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/760307cf5511d970dfddf7fa4b502b4e3394b197">760307cf</a></strong>

<div>

<span>by Artyom Kuznetsov</span>

<i>at 2020-09-19T15:52:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove GADT self-reference check (#11554, #12081, #12174, fixes #15942)

Reverts 430f5c84dac1eab550110d543831a70516b5cac8

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/057db94ce038970b14df1599fe83097c284b9c1f">057db94c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-19T15:52:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Drop field initializer on thread_basic_info_data_t

This struct has a number of fields and we only care that the value is

initialized with zeros. This eliminates the warnings noted in #17905.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/87e2e2b17afed82d30841d5b44c977123b93ecc4">87e2e2b1</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-19T23:55:30+03:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Resolve shift/reduce conflicts with %shift (#17232)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/66cba46e7049d907fe5c8614bddb60288421d358">66cba46e</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Unmark T12971 as broken on Windows

It's unclear why, but this no longer seems to fail.

Closes #17945.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/816811d45897afec3543ade30c63dcddf56828a8">816811d4</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Unmark T5975[ab] as broken on Windows

Sadly it's unclear *why* they have suddenly started working.

Closes #7305.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/43a43d396e30931c1fa68b054ae032d2bd1daa98">43a43d39</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">base/testsuite: Add missing LANGUAGE pragma in ThreadDelay001

Only affected the Windows codepath.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ced8f113cc6421dfc36dd322ea85a78bfa3ff37e">ced8f113</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Update expected output for outofmem on Windows

The error originates from osCommitMemory rather than getMBlocks.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ea08aead19087d21c5f7334e192cd4016ae57462">ea08aead</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark some GHCi/Makefile tests as broken on Windows

See #18718.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/caf6a5a30291d80660d6ff73efc35c04eaced789">caf6a5a3</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Fix WinIO error message normalization

This wasn't being applied to stderr.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/93ab3e8d235610b2cb339a5bad9ad2848eab18d4">93ab3e8d</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark tempfiles as broken on Win32 without WinIO

The old POSIX emulation appears to ignore the user-requested prefix.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9df77fed8918bb335874a584a829ee32325cefb5">9df77fed</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark TH_spliceE5_prof as broken on Windows

Due to #18721.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1a0f8243efc9873a949bb6f082b4dfdf563fc1ea">1a0f8243</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-21T16:45:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove unused ThBrackCtxt and ResSigCtxt

Fixes #18715.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2f222b120e48df1b3d78f5501612d21c2a2dc470">2f222b12</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-21T16:45:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Disallow constraints in KindSigCtxt

This patch cleans up how `GHC.Tc.Validity` classifies `UserTypeCtxt`s

that can only refer to kind-level positions, which is important for

rejecting certain classes of programs. In particular, this patch:

* Introduces a new `TypeOrKindCtxt` data type and

  `typeOrKindCtxt :: UserTypeCtxt -> TypeOrKindCtxt` function, which

  determines whether a `UserTypeCtxt` can refer to type-level

  contexts, kind-level contexts, or both.

* Defines the existing `allConstraintsAllowed` and `vdqAllowed`

  functions in terms of `typeOrKindCtxt`, which avoids code

  duplication and ensures that they stay in sync in the future.

The net effect of this patch is that it fixes #18714, in which it was

discovered that `allConstraintsAllowed` incorrectly returned `True`

for `KindSigCtxt`. Because `typeOrKindCtxt` now correctly classifies

`KindSigCtxt` as a kind-level context, this bug no longer occurs.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/aaa51dcfdb729f130aeefeaeac15029b62096a74">aaa51dcf</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-21T16:46:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Add extra-deps: happy-1.20 to stack.yaml

GHC now requires happy-1.20, which isn't available in LTS-16.14.

Fixes #18726.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6de40f83c53c3b1899f7b4912badbe98e4fbde88">6de40f83</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-22T05:37:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Better eta-expansion (again) and don't specilise DFuns

This patch fixes #18223, which made GHC generate an exponential

amount of code.  There are three quite separate changes in here

1.  Re-engineer eta-expansion (again).  The eta-expander was

    generating lots of intermediate stuff, which could be optimised

    away, but which choked the simplifier meanwhile.  Relatively

    easy to kill it off at source.

    See Note [The EtaInfo mechanism] in GHC.Core.Opt.Arity.

    The main new thing is the use of pushCoArg in getArg_maybe.

2.  Stop Specialise specalising DFuns.  This is the cause of a huge

    (and utterly unnecessary) blowup in program size in #18223.

    See Note [Do not specialise DFuns] in GHC.Core.Opt.Specialise.

    I also refactored the Specialise monad a bit... it was silly,

    because it passed on unchanging values as if they were mutable

    state.

3.  Do an extra Simplifer run, after SpecConstra and before

    late-Specialise.  I found (investigating perf/compiler/T16473)

    that failing to do this was crippling *both* SpecConstr *and*

    Specialise.  See Note [Simplify after SpecConstr] in

    GHC.Core.Opt.Pipeline.

    This change does mean an extra run of the Simplifier, but only

    with -O2, and I think that's acceptable.

    T16473 allocates *three* times less with this change.  (I changed

    it to check runtime rather than compile time.)

Some smaller consequences

* I moved pushCoercion, pushCoArg and friends from SimpleOpt

  to Arity, because it was needed by the new etaInfoApp.

  And pushCoValArg now returns a MCoercion rather than Coercion for

  the argument Coercion.

* A minor, incidental improvement to Core pretty-printing

This does fix #18223, (which was otherwise uncompilable. Hooray.  But

there is still a big intermediate because there are some very deeply

nested types in that program.

Modest reductions in compile-time allocation on a couple of benchmarks

    T12425     -2.0%

    T13253    -10.3%

Metric increase with -O2, due to extra simplifier run

    T9233     +5.8%

    T12227    +1.8%

    T15630    +5.0%

There is a spurious apparent increase on heap residency on T9630,

on some architectures at least.  I tried it with -G1 and the residency

is essentially unchanged.

Metric Increase

    T9233

    T12227

    T9630

Metric Decrease

    T12425

    T13253

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/416bd50e58b23ad70813b18a913ca77a3ab6e936">416bd50e</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-22T05:37:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix the occurrence analyser

Ticket #18603 demonstrated that the occurrence analyser's

handling of

  local RULES for imported Ids

(which I now call IMP-RULES) was inadequate.  It led the simplifier

into an infnite loop by failing to label a binder as a loop breaker.

The main change in this commit is to treat IMP-RULES in a simple and

uniform way: as extra rules for the local binder.  See

  Note [IMP-RULES: local rules for imported functions]

This led to quite a bit of refactoring.  The result is still tricky,

but it's much better than before, and better documented I think.

Oh, and it fixes the bug.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6fe8a0c756f8b12df5cf192ea9b0c33feb150843">6fe8a0c7</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-22T05:38:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck - Comments only: Replace /~ by ≁

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e9501547a8be6af97bcbf38a7ed66dadf02ea27b">e9501547</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-22T05:38:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Rewrite inhabitation test

We used to produce inhabitants of a pattern-match refinement type Nabla

in the checker in at least two different and mostly redundant ways:

  1. There was `provideEvidence` (now called

     `generateInhabitingPatterns`) which is used by

     `GHC.HsToCore.PmCheck` to produce non-exhaustive patterns, which

     produces inhabitants of a Nabla as a sub-refinement type where all

     match variables are instantiated.

  2. There also was `ensure{,All}Inhabited` (now called

     `inhabitationTest`) which worked slightly different, but was

     whenever new type constraints or negative term constraints were

     added. See below why `provideEvidence` and `ensureAllInhabited`

     can't be the same function, the main reason being performance.

  3. And last but not least there was the `nonVoid` test, which tested

     that a given type was inhabited. We did use this for strict fields

     and -XEmptyCase in the past.

The overlap of (3) with (2) was always a major pet peeve of mine. The

latter was quite efficient and proven to work for recursive data types,

etc, but could not handle negative constraints well (e.g. we often want

to know if a *refined* type is empty, such as `{ x:[a] | x /= [] }`).

Lower Your Guards suggested that we could get by with just one, by

replacing both functions with `inhabitationTest` in this patch.

That was only possible by implementing the structure of φ constraints

as in the paper, namely the semantics of φ constructor constraints.

This has a number of benefits:

  a. Proper handling of unlifted types and strict fields, fixing #18249,

     without any code duplication between

     `GHC.HsToCore.PmCheck.Oracle.instCon` (was `mkOneConFull`) and

     `GHC.HsToCore.PmCheck.checkGrd`.

  b. `instCon` can perform the `nonVoid` test (3) simply by emitting

     unliftedness constraints for strict fields.

  c. `nonVoid` (3) is thus simply expressed by a call to

     `inhabitationTest`.

  d. Similarly, `ensureAllInhabited` (2), which we called after adding

     type info, now can similarly be expressed as the fuel-based

     `inhabitationTest`.

See the new `Note [Why inhabitationTest doesn't call generateInhabitingPatterns]`

why we still have tests (1) and (2).

Fixes #18249 and brings nice metric decreases for `T17836` (-76%) and

`T17836b` (-46%), as well as `T18478` (-8%) at the cost of a few very

minor regressions (< +2%), potentially due to the fact that

`generateInhabitingPatterns` does more work to suggest the minimal

COMPLETE set.

Metric Decrease:

    T17836

    T17836b

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/086ef01813069fad84cafe81cab37527d41c8568">086ef018</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-09-23T06:52:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove the list of loaded modules from the ghci prompt

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d7385f7077c6258c2a76ae51b4ea80f6fa9c7015">d7385f70</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-23T06:52:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump submodules

* Bump bytestring to 0.10.12.0

* Bump Cabal to 3.4.0.0-rc3

* Bump Win32 to 2.10.0.0

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/667d63558a694e12974ace723b553950f6080365">667d6355</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-23T20:43:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor CLabel pretty-printing

* Don't depend on the selected backend to know if we print Asm or C

  labels: we already have PprStyle to determine this. Moreover even when

  a native backend is used (NCG, LLVM) we may want to C headers

  containing pretty-printed labels, so it wasn't a good predicate

  anyway.

* Make pretty-printing code clearer and avoid partiality

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a584366b1d363039247f73f6dcdd3514994ad600">a584366b</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-23T20:43:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove sdocWithDynFlags (fix #10143)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a997fa01d907fc1992dc8c3ebc73f98e7a1486f7">a997fa01</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-23T20:43:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Preliminary work towards removing DynFlags -> Driver.Ppr dependency

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/31fea307499009977fdf3dadedc98cfef986077a">31fea307</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-09-23T20:44:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove redundant "do", "return" and language extensions from base

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/04d6433158d95658684cf419c4ba5725d2aa539e">04d64331</a></strong>

<div>

<span>by syd@cs-syd.eu</span>

<i>at 2020-09-24T13:15:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update Lock.hs with more documentation to make sure that the Boolean return value is clear.

[skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/97cff9190d346c3b51c32c88fd145fcf1e6678f1">97cff919</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-24T13:16:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement Quick Look impredicativity

This patch implements Quick Look impredicativity (#18126), sticking

very closely to the design in

    A quick look at impredicativity, Serrano et al, ICFP 2020

The main change is that a big chunk of GHC.Tc.Gen.Expr has been

extracted to two new modules

    GHC.Tc.Gen.App

    GHC.Tc.Gen.Head

which deal with typechecking n-ary applications, and the head of

such applications, respectively.  Both contain a good deal of

documentation.

Three other loosely-related changes are in this patch:

* I implemented (partly by accident) points (2,3)) of the accepted GHC

  proposal "Clean up printing of foralls", namely

  https://github.com/ghc-proposals/ghc-proposals/blob/

        master/proposals/0179-printing-foralls.rst

  (see #16320).

  In particular, see Note [TcRnExprMode] in GHC.Tc.Module

  - :type instantiates /inferred/, but not /specified/, quantifiers

  - :type +d instantiates /all/ quantifiers

  - :type +v is killed off

  That completes the implementation of the proposal,

  since point (1) was done in

    commit df08468113ab46832b7ac0a7311b608d1b418c4d

    Author: Krzysztof Gogolewski <krzysztof.gogolewski@tweag.io>

    Date:   Mon Feb 3 21:17:11 2020 +0100

    Always display inferred variables using braces

* HsRecFld (which the renamer introduces for record field selectors),

  is now preserved by the typechecker, rather than being rewritten

  back to HsVar.  This is more uniform, and turned out to be more

  convenient in the new scheme of things.

* The GHCi debugger uses a non-standard unification that allows the

  unification variables to unify with polytypes.  We used to hack

  this by using ImpredicativeTypes, but that doesn't work anymore

  so I introduces RuntimeUnkTv.  See Note [RuntimeUnkTv] in

  GHC.Runtime.Heap.Inspect

Updates haddock submodule.

WARNING: this patch won't validate on its own.  It was too

hard to fully disentangle it from the following patch, on

type errors and kind generalisation.

Changes to tests

* Fixes #9730 (test added)

* Fixes #7026 (test added)

* Fixes most of #8808, except function `g2'` which uses a

  section (which doesn't play with QL yet -- see #18126)

  Test added

* Fixes #1330. NB Church1.hs subsumes Church2.hs, which is now deleted

* Fixes #17332 (test added)

* Fixes #4295

* This patch makes typecheck/should_run/T7861 fail.

  But that turns out to be a pre-existing bug: #18467.

  So I have just made T7861 into expect_broken(18467)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9fa26aa16f9eee0b56b5d9e65c16367d7b789996">9fa26aa1</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-24T13:16:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve kind generalisation, error messages

This patch does two things:

* It refactors GHC.Tc.Errors a bit.  In debugging Quick Look I was

  forced to look in detail at error messages, and ended up doing a bit

  of refactoring, esp in mkTyVarEqErr'.  It's still quite a mess, but

  a bit better, I think.

* It makes a significant improvement to the kind checking of type and

  class declarations. Specifically, we now ensure that if kind

  checking fails with an unsolved constraint, all the skolems are in

  scope.  That wasn't the case before, which led to some obscure error

  messages; and occasional failures with "no skolem info" (eg #16245).

Both of these, and the main Quick Look patch itself, affect a /lot/ of

error messages, as you can see from the number of files changed.  I've

checked them all; I think they are as good or better than before.

Smaller things

* I documented the various instances of VarBndr better.

  See Note [The VarBndr tyep and its uses] in GHC.Types.Var

* Renamed GHC.Tc.Solver.simpl_top to simplifyTopWanteds

* A bit of refactoring in bindExplicitTKTele, to avoid the

  footwork with Either.  Simpler now.

* Move promoteTyVar from GHC.Tc.Solver to GHC.Tc.Utils.TcMType

Fixes #16245 (comment 211369), memorialised as

  typecheck/polykinds/T16245a

Also fixes the three bugs in #18640

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6d0ce0eb772bf69c57e14f30c16c606ab5035816">6d0ce0eb</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-24T13:17:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Desugar string literal patterns with -XRebindableSyntax correctly (#18708)

Fixes #18708.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/007940d2fa1ac4f8046989d4af1d088914612a78">007940d2</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-09-24T13:17:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Namespace the Hadrian linting rule for base

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5b72718953c289b6827e877e14d9f0f3f5c64267">5b727189</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-09-25T21:10:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make sizeExpr strict in the size threshold to facilitate WW.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/dd6640316865d84075b00013b8b97076705e5c44">dd664031</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-25T21:10:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ci.sh: Factor out common utilities

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5b78e8658c3f5042967cbe9d30a5a630946c4fd7">5b78e865</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-25T21:10:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ci: Add ad-hoc performance testing rule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/29885f076219d878d2c976e78b7960a1a5938a96">29885f07</a></strong>

<div>

<span>by Zubin Duggal</span>

<i>at 2020-09-25T21:11:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Stop removing definitions of record fields in GHC.Iface.Ext.Ast

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0d6519d9e8604d067f4a4f760e4bc3403727a498">0d6519d9</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-25T21:12:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Drop Darwin cleanup job

We now have a proper periodic clean-up script installed on the runners.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/277d20af1ce54c7e2c76dfe3b96c54babceeea41">277d20af</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-25T21:12:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add regression tests for #18371

They have been fixed by !3959, I believe.

Fixes #18371.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8edf60562720b91613a6ad6b949ae08416f81c9a">8edf6056</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-25T21:12:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add a regression test for #18609

The egregious performance hits are gone since !4050.

So we fix #18609.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4a1b89a40d553213c9722207608a07f8a4c07545">4a1b89a4</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-25T21:12:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Accept new test output for #17218

The expected test output was plain wrong.

It has been fixed for a long time.

Thus we can close #17218.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/516062366ed1957e499f27dfc6b685a073a18400">51606236</a></strong>

<div>

<span>by Sven Tennie</span>

<i>at 2020-09-25T21:13:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Print RET_BIG stack closures

A RET_BIG closure has a large bitmap that describes it's payload and can

be printed with printLargeBitmap().

Additionally, the output for payload closures of small and big bitmaps is

changed: printObj() is used to print a bit more information about what's

on the stack.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2707c4eae4cf99e6da2709e128f560d91e468357">2707c4ea</a></strong>

<div>

<span>by Arnaud Spiwack</span>

<i>at 2020-09-25T21:13:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Pattern guards BindStmt always use multiplicity Many

Fixes #18439 .

The rhs of the pattern guard was consumed with multiplicity one, while

the pattern assumed it was Many. We use Many everywhere instead.

This is behaviour consistent with that of `case` expression. See #18738.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/92daad241bf136a10346ecbf520d62921c82bf7d">92daad24</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-25T21:14:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: refactor backend modules

* move backends into GHC.Num.Backend.*

* split backend selection into GHC.Num.Backend and

  GHC.Num.Backend.Selected to avoid duplication with the Check backend

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/04bc50b3c8e40387a0d0f090ea23cd68923f1834">04bc50b3</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-25T21:14:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: implement extended GCD (#18427)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6a7dae4badcea5b3519005cf4e5fbf15f7e5df59">6a7dae4b</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-25T21:15:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix typed holes causing linearity errors (#18491)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/83407ffc7acc00cc025b9f6ed063add9ab9f9bcc">83407ffc</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-25T21:15:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Various documentation fixes

* Remove UnliftedFFITypes from conf. Some time ago, this extension

  was undocumented and we had to silence a warning.

  This is no longer needed.

* Use r'' in conf.py. This fixes a Sphinx warning:

  WARNING: Support for evaluating Python 2 syntax is deprecated and will be removed in Sphinx 4.0. Convert docs/users_guide/conf.py to Python 3 syntax.

* Mark GHCForeignImportPrim as documented

* Fix formatting in template_haskell.rst

* Remove 'recursive do' from the list of unsupported items in TH

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/af1e84e794591e09e20c661fa1d3df59f5b56e4a">af1e84e7</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-26T05:36:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Big refactor of module structure

  * Move everything from `GHC.HsToCore.PmCheck.*` to

    `GHC.HsToCore.Pmc.*` in analogy to `GHC.Tc`, rename exported

    `covCheck*` functions to `pmc*`

  * Rename `Pmc.Oracle` to `Pmc.Solver`

  * Split off the LYG desugaring and checking steps into their own

    modules (`Pmc.Desugar` and `Pmc.Check` respectively)

  * Split off a `Pmc.Utils` module with stuff shared by

    `Pmc.{,Desugar,Check,Solver}`

  * Move `Pmc.Types` to `Pmc.Solver.Types`, add a new `Pmc.Types` module

    with all the LYG types, which form the interfaces between

    `Pmc.{Desugar,Check,Solver,}`.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f08f98e821bc4b755a7b6ad3bad39ce1099c5405">f08f98e8</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-26T05:36:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Extract SharedIdEnv into its own module

It's now named `GHC.Types.Unique.SDFM.UniqSDFM`.

The implementation is more clear about its stated goals and supported

operations.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1cde295c543e209c3b81256b50e77f3c5132a4ad">1cde295c</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-26T05:37:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add bigNatFromWordArray

Reimplementation of integer-gmp's byteArrayToBigNat#

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bda55fa0444310079ab89f2d28ddb8982975b646">bda55fa0</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-26T13:18:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make 'undefined x' linear in 'x' (#18731)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/160fba4aa306c0649c72a6dcd7c98d9782a0e74b">160fba4a</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-26T13:19:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Disallow linear types in FFI (#18472)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e124f2a7d9a5932a4c2383fd3f9dd772b2059885">e124f2a7</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-26T13:19:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix handling of function coercions (#18747)

This was broken when we added multiplicity to the function type.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7ff433824ea4d265fca09de9c26f3fd77a34bb22">7ff43382</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-27T03:01:31+03:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Comments: change outdated reference to mergeOps

As of 686e06c59c3aa6b66895e8a501c7afb019b09e36,

GHC.Parser.PostProcess.mergeOps no longer exists.

[ci skip]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4edf5527dbdd9781260e8822cb11a3f758fc7e91">4edf5527</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-27T10:04:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't rearrange (->) in the renamer

The parser produces an AST where the (->)

is already associated correctly:

  1. (->) has the least possible precedence

  2. (->) is right-associative

Thus we don't need to handle it in mkHsOpTyRn.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a9ce159ba58ca7e8946b46e19b1361588b677a26">a9ce159b</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-27T10:04:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove outdated comment in rnHsTyKi

This comment dates back to 3df40b7b78044206bbcffe3e2c0a57d901baf5e8

and does not seem relevant anymore.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/583a2070f1ad9162a365b034b27c3b80daafb8df">583a2070</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-09-29T00:31:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Optimize NthCo (FunCo ...) in coercion opt

We were missing this case previously.

Close #18528.

Metric Decrease:

    T18223

    T5321Fun

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b31a3360e2ef12f3ec7eaf66b3600247c1eb36c3">b31a3360</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-29T00:32:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Linear types: fix kind inference when checking datacons

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5830a12c46e7227c276a8a71213057595ee4fc04">5830a12c</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-29T00:32:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">New linear types syntax: a %p -> b (#18459)

Implements GHC Proposal #356

Updates the haddock submodule.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bca4d36dd835c1c31c8f3364113586e1aedc6787">bca4d36d</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-29T00:32:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve error messages for (a %m) without LinearTypes

Detect when the user forgets to enable the LinearTypes

extension and produce a better error message.

Steals the (a %m) syntax from TypeOperators, the workaround

is to write (a % m) instead.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b9635d0a9bbb7f659c376b68cdc87223c864243c">b9635d0a</a></strong>

<div>

<span>by Benjamin Maurer</span>

<i>at 2020-09-29T00:32:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Description of flag `-H` was in 'verbosity options', moved to 'misc'.

Fixes #18699

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/74c797f6b72c4d01f5e0092dfac1461f3f3dd7a2">74c797f6</a></strong>

<div>

<span>by Benjamin Maurer</span>

<i>at 2020-09-29T00:33:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Workaround for #18623: GHC crashes bc. under rlimit for vmem it will reserve

_all_ of it, leaving nothing for, e.g., thread stacks.

Fix will only allocate 2/3rds and check whether remainder is at least large

enough for minimum amount of thread stacks.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4365d77a0b306ada61654c3648b844cfa0f4fdcf">4365d77a</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-29T00:33:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add regression test #18501

ghc/ghc!3220 ended up fixing #18501. This patch adds a regression

test for #18501 to ensure that it stays fixed.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8e3f00dd24936b6674d0a2322f8410125968583e">8e3f00dd</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-29T17:24:03+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make the parser module less dependent on DynFlags

Bump haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3ab0d8f77ec67676de40ebe6ff7e86756e5c761e">3ab0d8f7</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-30T02:48:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Long-distance information for LocalBinds (#18626)

Now `desugarLocalBind` (formerly `desugarLet`) reasons about

  * `FunBind`s that

    * Have no pattern matches (so which aren't functions)

    * Have a singleton match group with a single GRHS

    * (which may have guards)

  * and looks through trivial post-typechecking `AbsBinds` in doing so

    to pick up the introduced renamings.

And desugars to `PmLet` LYG-style guards. Since GRHSs are no longer

denoted simply by `NonEmpty PmGRHS`, but also need to carry a `[PmGrd]`

for the `PmLet`s from `LocalBind`s, I added `PmGRHSs` to capture that.

Since we call out to the desugarer more often, I found that there were

superfluous warnings emitted when desugaring e.g. case expressions.

Thus, I made sure that we deactivate any warnings in the LYG desugaring

steps by the new wrapper function `noCheckDs`.

There's a regression test in `T18626`. Fixes #18626.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f8f60efc831c6adb5bfee8449b76238ba6d582db">f8f60efc</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-30T02:49:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T12971 as broken on Windows

Due to #17945.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6527fc57b8e099703f5bdb5ec7f1dfd421651972">6527fc57</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-30T02:49:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump Cabal, hsc2hs, directory, process submodules

Necessary for recent Win32 bump.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/df3f58807580bc2762086e063e3823b05de6fd64">df3f5880</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-30T02:49:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove unsafeGlobalDynFlags (#17957, #14597)

There are still global variables but only 3 booleans instead of a single

DynFlags.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9befd94d79a78fd53a28a4ce051a91d2215d069c">9befd94d</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-30T02:49:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove unused global variables

Some removed globals variables were still declared in the RTS.

They were removed in the following commits:

* 4fc6524a2a4a0003495a96c8b84783286f65c198

* 0dc7985663efa1739aafb480759e2e2e7fca2a36

* bbd3c399939311ec3e308721ab87ca6b9443f358

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7c98699f685d8c53fd594b6de22b425ed951174f">7c98699f</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-09-30T02:50:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Omit redundant kind equality check in solver

See updated Note [Use loose types in inert set] in

GHC.Tc.Solver.Monad.

Close #18753.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/395498260ab444f5e1ec82d716bea3cc3ad887f7">39549826</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-30T02:50:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Pmc: Don't call exprType on type arguments (#18767)

Fixes #18767.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/235e410f63a4725bbc4466dbdef7d5f661793e84">235e410f</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-09-30T02:51:29-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Regression test for #10709.

Close #10709

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5c32655fffd0d8862f3ba693351f1e612daa0b6b">5c32655f</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-30T22:31:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian/doc: Clarify documentation of key-value configuration</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0bb02873eeeca41a64d26becb9057e988f444acd">0bb02873</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:34:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add test for T18574

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e393f213f5ccff4fd6034d5294e51aa5a2720890">e393f213</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:34:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow fusion with catMaybes (#18574)

Metric Decrease:

   T18574

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d2cfad96831edbe50aeddaefc1a3b0fb0dd73bc2">d2cfad96</a></strong>

<div>

<span>by Fendor</span>

<i>at 2020-10-01T18:35:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add mainModuleNameIs and demote mainModIs

Add `mainModuleNameIs` to DynFlags and demote

`mainModIs` to function which uses the homeUnit from DynFlags

it is created from.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fc351ab8fbf02eaf473e97b3ce8c4cddcba3a8a5">fc351ab8</a></strong>

<div>

<span>by Fendor</span>

<i>at 2020-10-01T18:35:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use HomeUnit for main module without module declaration

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/dca1cb22cab4fa7f5937e9ffdc0ee32313dbd01c">dca1cb22</a></strong>

<div>

<span>by Fendor</span>

<i>at 2020-10-01T18:35:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove mAIN completely

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a5aaceecaa04ce7ea5bade6eb96c0d129109c15a">a5aaceec</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:36:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use ADTs for parser errors/warnings

Haskell and Cmm parsers/lexers now report errors and warnings using ADTs

defined in GHC.Parser.Errors. They can be printed using functions in

GHC.Parser.Errors.Ppr.

Some of the errors provide hints with a separate ADT (e.g. to suggest to

turn on some extension). For now, however, hints are not consistent

across all messages. For example some errors contain the hints in the

main message. I didn't want to change any message with this patch. I

expect these changes to be discussed and implemented later.

Surprisingly, this patch enhances performance. On CI

(x86_64/deb9/hadrian, ghc/alloc):

   parsing001         -11.5%

   T13719             -2.7%

   MultiLayerModules  -3.5%

   Naperian           -3.1%

Bump haddock submodule

Metric Decrease:

    MultiLayerModules

    Naperian

    T13719

    parsing001

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a946c7ef9eec768878d261c20437b924cd3afda3">a946c7ef</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:36:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Less DynFlags in Header parsing

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/dafe79433c2ca884da3677194ee38913ee30e8dc">dafe7943</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:36:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Parser: remove some unused imports

These are not reported by GHC because Happy adds {-# OPTIONS_GHC -w #-}

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/93d5de165a81dfb335bf1646c2e29956f5ab55ea">93d5de16</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:36:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't import GHC.Unit to reduce the number of dependencies

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e3655f810b4eba1fb7d81a3227a08dae8b85dfc4">e3655f81</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-10-01T18:36:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't attach CPR signatures to NOINLINE data structures (#18154)

Because the generated `KindRep`s don't have an unfolding, !3230 did not

actually stop to compute, attach and serialise unnecessary CPR

signatures for them. As already said in

`Note [CPR for data structures]`, that leads to bloated interface

files which is ultimately quadratic for Nested CPR.

So we don't attach any CPR signature to bindings that

  * Are not thunks (because thunks are not in WHNF)

  * Have arity 0 (which means the top-level constructor is not a lambda)

If the data structure has an unfolding, we continue to look through it.

If not (as is the case for `KindRep`s), we look at the unchanged CPR

signature and see `topCprType`, as expected.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ba5965eb10967d21b992aac925fb772db2ddde12">ba5965eb</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-10-01T18:37:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add regression test for #18755.

Close #18755

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a8018c17747342444c67eeec21a506c89c1110e8">a8018c17</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-01T18:37:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix pretty-printing of the mult-polymorphic arrow

A follow-up to !4020 (5830a12c46e7227c276a8a71213057595ee4fc04)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e5523324d2c55e0091857e21bf5613b5f6b442a7">e5523324</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:38:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add integerNegate RULE

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1edd6d21c0abea34b498a627234a97df21648024">1edd6d21</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-01T18:39:10-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor: remove rnHsDoc

It did not do any useful work.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a9ae83af9e0cf48e860f2b7e1d50a057cb8a7890">a9ae83af</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-02T08:00:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix typos in comments

[skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b81350bb925f8cb309355ee46238dbc11b796faf">b81350bb</a></strong>

<div>

<span>by Icelandjack</span>

<i>at 2020-10-02T08:01:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Replaced MkT1 with T1 in type signatures.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3c9beab75aaa5fbbb11132c99e2af114f322152f">3c9beab7</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-02T13:51:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Minor TTG clean-up: comments, unused families, bottom

1. Fix and update section headers in GHC/Hs/Extension.hs

2. Delete the unused 'XCoreAnn' and 'XTickPragma' families

3. Avoid calls to 'panic' in 'pprStmt'

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/12c06927a03a2fdb516f7008c57d68568b02b576">12c06927</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-02T13:52:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: implement integerRecipMod (#18427)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8dd4f40512bb18e296280acde0507b4233a27b69">8dd4f405</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-02T13:52:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: implement integerPowMod (#18427)

Incidentally fix powModInteger which was crashing in integer-gmp for

negative exponents when the modular multiplicative inverse for the base

didn't exist. Now we compute it explicitly with integerRecipMod so that

every backend returns the same result without crashing.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1033a720abf4a23a30c5cb0dfcb18b2bae3acc68">1033a720</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-02T13:53:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Reject linearity in kinds in checkValidType (#18780)

Patch taken from https://gitlab.haskell.org/ghc/ghc/-/issues/18624#note_300673

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b0ccba66c4d7c16eba7e2fdc1857fc0f63cd33f9">b0ccba66</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-03T19:33:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Small documentation fixes

- Fix formatting of code blocks and a few sphinx warnings

- Move the Void# change to 9.2, it was done right after the branch was cut

- Fix typo in linear types documentation

- Note that -Wincomplete-uni-patterns affects lazy patterns

[skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/70dc2f09a33a4c3f485d8b63e92a21955643a0b7">70dc2f09</a></strong>

<div>

<span>by Karel Gardas</span>

<i>at 2020-10-03T19:33:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">fix rts.cabal to use real arch names and not aliasses (fixes #18654)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bc5de347bccd7a2691a9e4b927ab80acb7e15991">bc5de347</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-10-05T13:59:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Inline `integerDecodeDouble#` and constant-fold `decodeDouble_Int64#` instead

Currently, `integerDecodeDouble#` is known-key so that it can be

recognised in constant folding. But that is very brittle and doesn't

survive worker/wrapper, which we even do for

`NOINLINE` things since #13143.

Also it is a trade-off: The implementation of `integerDecodeDouble#`

allocates an `Integer` box that never cancels aways if we don't inline

it.

Hence we recognise the `decodeDouble_Int64#` primop instead in constant

folding, so that we can inline `integerDecodeDouble#`. As a result,

`integerDecodeDouble#` no longer needs to be known-key.

While doing so, I realised that we don't constant-fold

`decodeFloat_Int#` either, so I also added a RULE for it.

`integerDecodeDouble` is dead, so I deleted it.

Part of #18092. This improves the 32-bit `realToFrac`/`toRational`:

Metric Decrease:

    T10359

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/802b5e6fdd6dfc58396a9dca1903dc5a1d6634ca">802b5e6f</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-05T13:59:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix linear types in TH splices (#18465)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/18a3ddf75d25094096a7fe44fd250de973041187">18a3ddf7</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-05T13:59:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Fix integer width in TICK_BUMP_BY

Previously `TICK_BUMP_BY` was defined as

```c

 #define TICK_BUMP_BY(ctr,n) CLong[ctr] = CLong[ctr] + n

```

Yet the tickers themselves were defined as `StgInt`s. This happened to

work out correctly on Linux, where `CLong` is 64-bits. However, it

failed on Windows, where `CLong` is 32-bits, resulting in #18782.

Fixes #18783.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5fc4243bf2da2adbae3d01d163053e8895bc52d9">5fc4243b</a></strong>

<div>

<span>by Rachel</span>

<i>at 2020-10-07T14:59:45-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document profiling flags, warning flags, and no-pie

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b41f7c3814b2e0e765311babc851cd3d9b6a78d8">b41f7c38</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-10-07T15:00:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">WinIO: Small changes related to atomic request swaps.

Move the atomix exchange over the Ptr type to an internal module.

Fix a bug caused by us passing ptr-to-ptr instead of ptr to

atomic exchange.

Renamed interlockedExchange to exchangePtr.

I've also added an cas primitive. It turned out we don't need it

for WinIO but I'm leaving it in as it's useful for other things.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/948a14e1eaaf0c033e3f19d1b9eecb398ddc8661">948a14e1</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-07T15:00:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Fix name of Ubuntu 20.04 image</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/74d4017b744585a89709ac4b74dbe37b44741464">74d4017b</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-07T15:01:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix -flink-rts (#18651)

Before this patch -flink-rts could link with GHC's rts instead of the

selected one.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0e8b923d3c8a5ff415091b92c4c7b7e1e33d0ae6">0e8b923d</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-07T15:01:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Apply suggestion to compiler/GHC/SysTools.hs</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d6dff830754a97220eacf032c32cd54b18654917">d6dff830</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-10-07T15:02:10-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Preserve as-parsed arrow type for HsUnrestrictedArrow

When linear types are disabled, HsUnrestrictedArrow is treated as

HslinearArrow.

Move this adjustment into the type checking phase, so that the parsed

source accurately represents the source as parsed.

Closes #18791

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/030c5ce0a58e212eb7b973e1206b775085b74afb">030c5ce0</a></strong>

<div>

<span>by Karel Gardas</span>

<i>at 2020-10-07T15:02:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: use stage0 linker to merge objects when done during the stage0

Fixes #18800.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a94db588db5e2983112301e94b2133b5a3f03875">a94db588</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-07T15:03:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Allow whitespace before "Metric (in|de)crease"

Several people have struggled with metric change annotations

in their commit messages not being recognized due to the fact that

GitLab's job log inserts a space at the beginning of each line. Teach

the regular expression to accept this whitespace.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e91ddddd714b22df2569681fb033fbb151ec7e6b">e91ddddd</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-07T15:04:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Misc cleanup

* Include funTyCon in exposedPrimTyCons.

  Every single place using exposedPrimTyCons was adding funTyCon

  manually.

* Remove unused synTyConResKind and ieLWrappedName

* Add recordSelectorTyCon_maybe

* In exprType, panic instead of giving a trace message and dummy output.

  This prevents #18767 reoccurring.

* Fix compilation error in fragile concprog001 test (part of #18732)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/386c2d7ff80843051ad15eab5de3766430ee98a5">386c2d7f</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:40:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use UnitId in the backend instead of Unit

In Cmm we can only have real units identified with an UnitId.  Other

units (on-the-fly instantiated units and holes) are only used in

type-checking backpack sessions that don't produce Cmm.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a566c83d4fc3a90b209b33131a2972ea53ec81b2">a566c83d</a></strong>

<div>

<span>by Simon Jakobi</span>

<i>at 2020-10-09T08:41:09-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update containers to v0.6.4.1

Updates containers submodule.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fd984d68e5ec4b04bc79395c099434e653eb1060">fd984d68</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-09T08:41:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: fix race condition in StgCRun

On windows the stack has to be allocated 4k at a time, otherwise we get

a segfault. This is done by using a helper ___chkstk_ms that is provided

by libgcc. The Haskell side already knows how to handle this but we need

to do the same from STG. Previously we would drop the stack in StgRun

but would only make it valid whenever the scheduler loop ran.

This approach was fundamentally broken in that it falls apart when you

take a signal from the OS. We see it less often because you initially

get allocated a 1MB stack block which you have to blow past first.

Concretely this means we must always keep the stack valid.

Fixes #18601.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/accdb24a086b80fe74776246aa33bce5a920e3c8">accdb24a</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:42:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Expose RTS-only ways (#18651)

Some RTS ways are exposed via settings (ghcThreaded, ghcDebugged) but

not all. It's simpler if the RTS exposes them all itself.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d360f3438da7f6eb51e217c6697db6fb338c6fd7">d360f343</a></strong>

<div>

<span>by MaxGabriel</span>

<i>at 2020-10-09T08:43:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document -Wderiving-typeable

Tracking: #18641

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e48cab2a57f2342891f985bcb44817e17e985275">e48cab2a</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-09T08:43:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add a flag to indicate that gcc supports -no-pie

Fixes #17919.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f7e2fff96975128397e2dab7d57da3c9c6b8c76b">f7e2fff9</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-10-09T08:44:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add linting of `base` to the CI

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/45a1d493ec877f5fa0b3228deee3e019033c89db">45a1d493</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-10-09T08:45:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use proper RTS flags when collecting residency in perf tests.

Replace options like collect_stats(['peak_megabytes_allocated'],4) with

collect_runtime_residency(4) and so forth. Reason being that the later

also supplies some default RTS arguments which make sure residency does

not fluctuate too much.

The new flags mean we get new (hopefully more accurate) baselines so

accept the stat changes.

-------------------------

Metric Decrease:

     T4029

     T4334

     T7850

Metric Increase:

     T13218

     T7436

-------------------------

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ef65b1546ad01fdd10386f713fc246d49269a196">ef65b154</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-10-09T08:45:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite/timeout: Fix windows specific errors.

We now seem to use -Werror there. Which caused some long standing

warnings to become errors.

I applied changes to remove the warnings allowing the testsuite to

run on windows as well.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e691a5a04692beb601d480ccf9f283199a70ed62">e691a5a0</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:46:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: add quick-debug flavour

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/12191a99d3b978b697ec0fb4412276fbea5dce8f">12191a99</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:47:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: match on small Integer/Natural

Previously we only matched on *variables* whose unfoldings were a ConApp

of the form `IS lit#` or `NS lit##`. But we forgot to match on the

ConApp directly... As a consequence, constant folding only worked after

the FloatOut pass which creates bindings for most sub-expressions. With

this patch, matching on bignums works even with -O0 (see bignumMatch

test).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/36787bba78ae5acbb857c84b85b8feb7c83e54a5">36787bba</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-10-09T08:47:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ApiAnnotations : preserve parens in GADTs

A cleanup in 7f418acf61e accidentally discarded some parens in

ConDeclGADT.

Make sure these stay in the AST in a usable format.

Also ensure the AnnLolly does not get lost in a GADT.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/32dc7698a0c38afe2889119a2df0f2a2b8debe0a">32dc7698</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-09T08:48:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Linear types: fix roles in GADTs (#18799)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9657f6f34a1a00008a0db935dbf25733cb483cd4">9657f6f3</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-09T08:48:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">sdist: Include hadrian sources in source distribution

Previously the make build system's source distribution rules neglected

to include Hadrian's sources.

Fixes #18794.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c832f7e2a9314cfd61257cb161b1795b612d12b5">c832f7e2</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-09T08:49:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fixed timeouts non-threaded.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6f0243ae5b359124936a8ff3dd0a287df3d7aca2">6f0243ae</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-09T08:50:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fix array splat

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0fd3d360cab977e00fb6d90d0519962227b029bb">0fd3d360</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-09T08:50:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fixed bytestring reading interface.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/dfaef1cae7a4a0cb8783933274dae7f39d7165a0">dfaef1ca</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-09T08:51:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fixed more data error.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bfdccac6acce84e15292a454d12f4e0d87ef6f10">bfdccac6</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-10-09T08:52:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix desugaring of record updates on data families

This fixes a long-standing bug in the desugaring of record

updates for data families, when the latter involves a GADT. It's

all explained in Note [Update for GADTs] in GHC.HsToCore.Expr.

Building the correct cast is surprisingly tricky, as that Note

explains.

Fixes #18809.  The test case (in indexed-types/should_compile/T18809)

contains several examples that exercise the dark corners.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e5c7c9c8578de1248826c21ebd08e475d094a552">e5c7c9c8</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-09T08:52:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump win32-tarballs version to 0.3

This should fix #18774.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ef950b19c04bc9c41920ecc9f94382653981d4bb">ef950b19</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-10-09T08:53:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add TyCon Set/Env and use them in a few places.

Firstly this improves code clarity.

But it also has performance benefits as we no longer

go through the name of the TyCon to get at it's unique.

In order to make this work the recursion check for TyCon

has been moved into it's own module in order to avoid import

cycles.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fd302e938ebf48c73d9f715d67ce8cd990f972ff">fd302e93</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-09T08:54:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add -pgmlm and -optlm flags

!3798 added documentation and semantics for the flags,

but not parsing.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/db236ffc03e5e17f71295469040da96b03ec2f87">db236ffc</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:54:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Testsuite: increase timeout for T18223 (#18795)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6a243e9daaa6c17c0859f47ae3a098e680aa28cf">6a243e9d</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:55:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Cache HomeUnit in HscEnv (#17957)

Instead of recreating the HomeUnit from the DynFlags every time we need

it, we store it in the HscEnv.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5884fd325248e75d40c9da431b4069e43a2c182c">5884fd32</a></strong>

<div>

<span>by Fendor</span>

<i>at 2020-10-09T19:46:28+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move File Target parser to library #18596

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ea59fd4d0abe73e1127dcdd91855a39232e62d41">ea59fd4d</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-10-10T14:49:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Lint the compiler for extraneous LANGUAGE pragmas

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/22f218b729a751bc5e5965624a716fc542f502a5">22f218b7</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-10T14:50:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Linear types: fix quantification in GADTs (#18790)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/74ee1237bf243dd7d8b758a53695575c364c3088">74ee1237</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-10T14:51:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: fix bigNatCompareWord# bug (#18813)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/274e21f02fabb4b3761841972b1074d0c0146fae">274e21f0</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-10-11T10:55:56+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove the dependency on the ghc-linters stage

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/990ea991a1c35fdb894fcb91f919fb8f8fed33dd">990ea991</a></strong>

<div>

<span>by Daniel Rogozin</span>

<i>at 2020-10-11T22:20:04+03:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fall back to types when looking up data constructors (#18740)

Before this patch, referring to a data constructor in a term-level

context led to a scoping error:

    ghci> id Int

    <interactive>:1:4: error: Data constructor not in scope: Int

After this patch, the renamer falls back to the type namespace

and successfully finds the Int. It is then rejected in the type

checker with a more useful error message:

    <interactive>:1:4: error:

    • Illegal term-level use of the type constructor ‘Int’

        imported from ‘Prelude’ (and originally defined in ‘GHC.Types’)

    • In the first argument of ‘id’, namely ‘Int’

      In the expression: id Int

We also do this for type variables.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9bbc84d20d0f50901351246cbe97c45234ca7d95">9bbc84d2</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-12T18:21:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: refactor DmdAnal

Make demand analysis usable without having to provide DynFlags.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7fdcce6d4d13a10a1b2336c1d40482c64dba664d">7fdcce6d</a></strong>

<div>

<span>by Wander Hillen</span>

<i>at 2020-10-13T00:12:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Initial ShortText code and conversion of package db code

Metric Decrease:

    Naperian

    T10421

    T10421a

    T10547

    T12150

    T12234

    T12425

    T13035

    T18140

    T18304

    T5837

    T6048

    T13253-spj

    T18282

    T18223

    T3064

    T9961

Metric Increase

    T13701

HFSKJH

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0a5f29185921cf2af908988ab3608602bcb40290">0a5f2918</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-13T00:13:28-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Parser: don't require the HomeUnitId

The HomeUnitId is only used by the Cmm parser and this one has access to

the DynFlags, so it can grab the UnitId of the HomeUnit from them.

Bump haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8f4f5794eb3504bf2ca093dc5895742395fdbde9">8f4f5794</a></strong>

<div>

<span>by HaskellMouse</span>

<i>at 2020-10-13T13:05:49+03:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Unification of Nat and Naturals

This commit removes the separate kind 'Nat' and enables promotion

of type 'Natural' for using as type literal.

It partially solves #10776

Now the following code will be successfully typechecked:

    data C = MkC Natural

    type CC = MkC 1

Before this change we had to create the separate type for promotion

    data C = MkC Natural

    data CP = MkCP Nat

    type CC = MkCP 1

But CP is uninhabited in terms.

For backward compatibility type synonym `Nat` has been made:

    type Nat = Natural

The user's documentation and tests have been updated.

The haddock submodule also have been updated.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0fc1cb54d1afc0f002deb4d080c9b824f423b647">0fc1cb54</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-14T03:42:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Verify that Hadrian builds with Stack

As noted in #18726, this regularly breaks. Let's test it.

Note that we don't actually perform a build of GHC itself; we merely

test that the Hadrian executable builds and works (by invoking `hadrian

--version`).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/89f4d8e950a1ed2a3ffab424233d3bcd243b1771">89f4d8e9</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-14T12:03:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump LLVM version to 10.0

Fixes #18267.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/716385c90f2f89ac45e256cdb7cdada1981b31ad">716385c9</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-10-14T12:04:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make DataKinds the sole arbiter of kind-level literals (and friends)

Previously, the use of kind-level literals, promoted tuples,

and promoted lists required enabling both `DataKinds` and

`PolyKinds`. This made sense back in a `TypeInType` world, but not so

much now that `TypeInType`'s role has been superseded. Nowadays,

`PolyKinds` only controls kind polymorphism, so let's make `DataKinds`

the thing that controls the other aspects of `TypeInType`, which include

literals, promoted tuples and promoted lists.

There are some other things that overzealously required `PolyKinds`,

which this patch fixes as well:

* Previously, using constraints in kinds (e.g., `data T :: () -> Type`)

  required `PolyKinds`, despite the fact that this is orthogonal to kind

  polymorphism. This now requires `DataKinds` instead.

* Previously, using kind annotations in kinds

  (e.g., `data T :: (Type :: Type) -> Type`) required both `KindSignatures`

  and `PolyKinds`. This doesn't make much sense, so it only requires

  `KindSignatures` now.

Fixes #18831.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ac300a0d49343e6a558dc36d94fc558f51d43bb2">ac300a0d</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-14T12:05:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove "Operator sections" from docs/users_guide/bugs.rst

The issue described in that section was fixed by

2b89ca5b850b4097447cc4908cbb0631011ce979

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bf2411a3c198cb2df93a9e0aa0c3b8297f47058d">bf2411a3</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-14T12:05:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix PostfixOperators (#18151)

This fixes a regression introduced in 2b89ca5b850b4097447cc4908cbb0631011ce979

See the new T18151x test case.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e60ae8a38394370fd8818ad004a101466fc7d2dc">e60ae8a3</a></strong>

<div>

<span>by Fumiaki Kinoshita</span>

<i>at 2020-10-14T18:06:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add -Wnoncanonical-{monad,monoid}-instances to standardWarnings

-------------------------

Metric Decrease:

   T12425

Metric Increase:

   T17516

-------------------------

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15d2340cb9dc833adb87784e6de86dba235290f7">15d2340c</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-10-14T18:06:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix some missed opportunities for preInlineUnconditionally

There are two signficant changes here:

* Ticket #18815 showed that we were missing some opportunities for

  preInlineUnconditionally.  The one-line fix is in the code for

  GHC.Core.Opt.Simplify.Utils.preInlineUnconditionally, which now

  switches off only for INLINE pragmas.  I expanded

  Note [Stable unfoldings and preInlineUnconditionally] to explain.

* When doing this I discovered a way in which preInlineUnconditionally

  was occasionally /too/ eager.  It's all explained in

  Note [Occurrences in stable unfoldings] in GHC.Core.Opt.OccurAnal,

  and the one-line change adding markAllMany to occAnalUnfolding.

I also got confused about what NoUserInline meant, so I've renamed

it to NoUserInlinePrag, and changed its pretty-printing slightly.

That led to soem error messate wibbling, and touches quite a few

files, but there is no change in functionality.

I did a nofib run.  As expected, no significant changes.

        Program           Size    Allocs

----------------------------------------

         sphere          -0.0%     -0.4%

----------------------------------------

            Min          -0.0%     -0.4%

            Max          -0.0%     +0.0%

 Geometric Mean          -0.0%     -0.0%

I'm allowing a max-residency increase for T10370, which seems

very irreproducible. (See comments on !4241.)  There is always

sampling error for max-residency measurements; and in any case

the change shows up on some platforms but not others.

Metric Increase:

    T10370

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0c4bfed849d454bee707fcb2989eb7c6339eaedb">0c4bfed8</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-14T18:07:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: Add missing :ghc-flag: directive</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/51c4b851965abdece2f88f8e583256e15f3140fe">51c4b851</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-15T04:30:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove Proxy# argument in Data.Typeable.Internal

No longer neccessary - TypeRep is now indexed, there is no ambiguity.

Also fix a comment in Evidence.hs, IsLabel no longer takes a Proxy#.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/809f09e8a7060691b1f2f5d6b95ca75e66437e55">809f09e8</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-15T04:31:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix parsing of PIE flags

-fPIE and -fno-PIE flags were (un)setting Opt_PIC instead of Opt_PIE.

Original commit: 3625728a0e3a9b56c2b85ae7ea8bcabdd83ece6a

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3d7db1488c4bd7764e8b1fe3cfde4c5a548cde16">3d7db148</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-15T04:31:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add missing #include on <stdlib.h>

This otherwise fails on newer Clangs, which warn

more aggressively on undeclared symbols.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/998803dc4dbceb36074644483e11e6183fa5355a">998803dc</a></strong>

<div>

<span>by Andrzej Rybczak</span>

<i>at 2020-10-15T11:40:32+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add flags for annotating Generic{,1} methods INLINE[1] (#11068)

Makes it possible for GHC to optimize away intermediate Generic representation

for more types.

Metric Increase:

    T12227

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6b14c4185ca944295d5cfa60ebc6f7ab2a257fc9">6b14c418</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-10-15T21:57:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Extend mAX_TUPLE_SIZE to 64

As well a ctuples and sums.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d495f36a8fb96f26fae4043364b8a7f38b884e00">d495f36a</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-15T21:58:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Clean-up whitespace in Interpreter

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cf10becdff4f8dba9bfa35326a1a338dccdd2b20">cf10becd</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-15T21:58:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">compiler/ByteCode: Use strict Maps in bytecode assembler

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ae146b536445d20ef9983ff0e38ce1beaec6f321">ae146b53</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-15T21:58:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">compiler/ByteCode: Make LocalLabel a newtype

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cc536288c32df9c4b9f37020b76348f58a57b3cb">cc536288</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-15T21:58:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">compiler/ByteCode: Allow 2^32 local labels

This widens LocalLabel to 2^16, avoiding the crash observed in #14334.

Closes #14334.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1bb0512f319c1361e2c5a7ab3e1c2978d3a95b9b">1bb0512f</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">mingw: Extract zst toolchain archives

This should have been done when the toolchain was bumped.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bf7c5b6ddea5024baa2e04110ab2801f8797fafd">bf7c5b6d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">base: Reintroduce necessary LANGUAGE pragmas

These were incorrectly removed in a recent cleanup commit.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c6b4be4bfc9754050a8014851f5adde9721589bc">c6b4be4b</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Sort metrics by metric type

Closes #18838.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c7989c936390441886e9cd1cda1c093dd4b32413">c7989c93</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Account for -Wnoncanonical-monoid-instances changes on Windows

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/330a5433b709c0cc16eb5fe9a06c21f4b2009be7">330a5433</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Add __mingw_vfprintf to RtsSymbols.c

Following the model of the other printf symbols. See Note [Symbols for

MinGW's printf].

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c4a69f37acf5c04e3c4d912d01b25a06a71b224c">c4a69f37</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Remove allow_failure from Windows jobs

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9a9679dbfc77c600e6c2a031ccab37d203a19cf9">9a9679db</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Fix Hadrian bindist names

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/07b0db86595890dfca6f624e554cdb8c9b86d0cc">07b0db86</a></strong>

<div>

<span>by f-a</span>

<i>at 2020-10-16T10:14:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clarify Eq documentation #18713</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/aca0e63bce4b29ac6e0cd06dbd169b0c06b53e25">aca0e63b</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-17T10:20:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Allow doc-tarball job to fail

Currently the Hadrian build appears not to package documentation correctly,

causing doc-tarball to fail due to the Windows build.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b02a9ea79dddd98f6bbb42e1652d7ea38db7d55e">b02a9ea7</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-17T13:26:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: s/allow_newer/allow_failure

Silly mistake on my part.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/59d7c9f45b034809516703b57c84e3dac1834578">59d7c9f4</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-10-17T22:01:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Skip type family defaults with hs-boot and hsig files

Works around #17190, possible resolution for #17224. New design is is

according to accepted [GHC Propoal 320].

Instances in signatures currently unconditionally opt into associated

family defaults if no explicit instance is given. This is bad for two

reasons:

  1. It constrains possible instantiations to use the default, rather

  than possibly define the associated family differently.

  2. It breaks compilation as type families are unsupported in

  signatures.

This PR simply turns off the filling in of defaults in those cases.

Additionally, it squelches a missing definition warning for hs-boot too

that was only squelched for hsig before.

The downsides are:

  1. There is no way to opt into the default, other than copying its

  definition.

  2. If we fixed type classes in signatures, and wanted instances to

  have to explicitly *out of* rather than into the default, that would

  now be a breaking change.

The change that is most unambiguously goood is harmonizing the warning

squelching between hs-boot or hsig. Maybe they should have the warning

(opt out of default) maybe they shouldn't (opt in to default), but

surely it should be the same for both.

Add hs-boot version of a backpack test regarding class-specified

defaults in instances that appear in an hs-boot file.

The metrics increase is very slight and makes no sense --- at least no

one has figured anything out after this languishing for a while, so I'm

just going to accept it.

Metric Increase:

  T10421a

[GHC proposal 320]: https://github.com/ghc-proposals/ghc-proposals/pull/320

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7eb46a09e2188e64d226b75361b36ab732b5b372">7eb46a09</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-10-17T22:02:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Arity: Refactor fixed-point iteration in GHC.Core.Opt.Arity

Arity analysis used to propagate optimistic arity types during

fixed-point interation through the `ArityEnv`'s `ae_cheap_fun` field,

which is like `GHC.Core.Utils.exprIsCheap`, but also considers the

current iteration's optimistic arity, for the binder in question only.

In #18793, we have seen that this is a problematic design, because it

doesn't allow us to look through PAP bindings of that binder.

Hence this patch refactors to a more traditional form with an explicit

signature environment, in which we record the optimistic `ArityType` of

the binder in question (and at the moment is the *only* binder that is

recorded in the arity environment).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6b3eb06af41b7385737fb3a602acdb95a76d2eba">6b3eb06a</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-10-17T22:02:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Arity: Record arity types for non-recursive lets

In #18793, we saw a compelling example which requires us to look at

non-recursive let-bindings during arity analysis and unleash their arity

types at use sites.

After the refactoring in the previous patch, the needed change is quite

simple and very local to `arityType`'s defn for non-recurisve `Let`.

Apart from that, we had to get rid of the second item of

`Note [Dealing with bottoms]`, which was entirely a safety measure and

hindered optimistic fixed-point iteration.

Fixes #18793.

The following metric increases are all caused by this commit and a

result of the fact that we just do more work now:

Metric Increase:

    T3294

    T12545

    T12707

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/451455fd008500259f5d2207bdfdccf6dddb52c5">451455fd</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-10-17T22:02:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Testsuite: Add dead arity analysis tests

We didn't seem to test these old tests at all, judging from their

expected output.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/50e9df49b7cd637c4552ab34bf629a01af4767c0">50e9df49</a></strong>

<div>

<span>by Dylan Yudaken</span>

<i>at 2020-10-17T22:02:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">When using rts_setInCallCapability, lock incall threads

This diff makes sure that incall threads, when using `rts_setInCallCapability`, will be created as locked.

If the thread is not locked, the thread might end up being scheduled to a different capability.

While this is mentioned in the docs for `rts_setInCallCapability,`, it makes the method significantly less useful as there is no guarantees on the capability being used.

This commit also adds a test to make sure things stay on the correct capability.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0b995759ae2ba2161097a1c43efc650ccbce0276">0b995759</a></strong>

<div>

<span>by DylanZA</span>

<i>at 2020-10-17T22:02:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Apply suggestion to testsuite/tests/ffi/should_run/all.T</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a91dcb669b3b221c51e8ba8bb85b7ae9806bc4ca">a91dcb66</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-17T22:04:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't get host RTS ways via settings (#18651)

To correctly perform a linking hack for Windows we need to link with the

RTS GHC is currently using. We used to query the RTS ways via the

"settings" file but it is fragile (#18651). The hack hasn't been fixed

to take into account all the ways (Tracing) and it makes linking of GHC

with another RTS more difficult (we need to link with another RTS and to

regenerate the settings file).

So this patch uses the ways reported by the RTS itself

(GHC.Platform.Ways.hostWays) instead of the "settings" file.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d858a3aebee5adc447556b668b65b6e46370d8c0">d858a3ae</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-10-17T22:04:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Linting corrections

* Bring back LANGUAGE pragmas in GHC.IO.Handle.Lock.Windows

* Exclude some modules that are wrongfully reported

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b5b3e34ec39fc89a0bcd0b60cf9a4962c89ba72f">b5b3e34e</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-19T18:16:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement -Woperator-whitespace (#18834)

This patch implements two related warnings:

  -Woperator-whitespace-ext-conflict

      warns on uses of infix operators that would be parsed

      differently were a particular GHC extension enabled

  -Woperator-whitespace

      warns on prefix, suffix, and tight infix uses of infix

      operators

Updates submodules: haddock, containers.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9648d680b4b07d48cf8741e0847abf07b95c7c1d">9648d680</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-19T18:16:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove pdocPrec

pdocPrec was only used in GHC.Cmm.DebugBlock.pprUnwindExpr, so remove

it. OutputableP becomes a one-function class which might be better for

performance.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ee5dcdf95a7c408e9c339aacebf89a007a735f8f">ee5dcdf9</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-20T00:47:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add test for #18346

This was fixed by 4291bddaea3148908c55f235ee8978e1d9aa6f20.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6c7a5c0ca07085f31a3e2f8286bb57a0f35961cb">6c7a5c0c</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-20T00:48:29-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Minor comments, update linear types docs

- Update comments: placeHolderTypeTc no longer exists

  "another level check problem" was a temporary comment from linear types

- Use Mult type synonym (reported in #18676)

- Mention multiplicity-polymorphic fields in linear types docs

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/58a1ca3886b00630937d7f5073b2d7961f8e80ca">58a1ca38</a></strong>

<div>

<span>by nineonine</span>

<i>at 2020-10-20T00:49:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Compile modules with `-fobject-code` enabled to byte-code when loaded with `*` prefix in ghci (#8042)

The documentation states that when using :add and :load, the `*` prefix forces a module

to be loaded as byte-code. However, this seems to be ignored when -fobject-code has been

enabled. In that case, the compiled code is always used, regardless of whether the *-form

is used.

The idea is to consult the Targets in HscEnv and check the 'targetAllowObjCode' flag. If

the flag for given module is set, then patch up DynFlags and select compilation backend

accordingly.

This would require a linear scan of course, but that shouldn't be too costly.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/59b08a5d192e102f66a6d9260cc8466d7428cffe">59b08a5d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-20T00:49:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Rename FLAVOUR -> BUILD_FLAVOUR

Previously the Hadrian jobs used the `FLAVOUR` environment variable to

communicate which flavour `ci.sh` should build whereas `make` used

`BUILD_FLAVOUR`. This caused unnecessary confusion. Consolidate these

two.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ea736839d85594c95490dcf02d3325c2bbc68f33">ea736839</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-10-20T08:35:34+01:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">API Annotations: Keep track of unicode for linear arrow notation

The linear arrow can be parsed as `%1 ->` or a direct single token unicode

equivalent.

Make sure that this distinction is captured in the parsed AST by using

IsUnicodeSyntax where it appears, and introduce a new API Annotation,

AnnMult to represent its location when unicode is not used.

Updated haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cf3c3bcd93b3a515f3c2db81b5a7c42af480c9b6">cf3c3bcd</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-20T22:56:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T12971 as fragile on Windows

Due to #17945.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e2c4a94708e4d8789ce97bd8b034e62f0e8b81c6">e2c4a947</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-21T16:00:30+03:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Parser regression tests, close #12862 #12446

These issues were fixed by earlier parser changes, most likely related

to whitespace-sensitive parsing.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/711929e6bcbcd5439dbf748cb57f56088b9a9f16">711929e6</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-10-23T02:42:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix error message location in tcCheckPatSynDecl

Ticket #18856 showed that we were failing to set the right location

for an error message.  Easy to fix, happily.

Turns out that this also improves the error location in test T11010,

which was bogus before but we had never noticed.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/730bb59086ad1036143983c3fba61bd851bebc03">730bb590</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-23T02:43:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">cmm: Add Note reference to ForeignHint</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b9d4dd9cbc4f1dd40e6beaf5d8301ac9d3034fca">b9d4dd9c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T20:44:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">SMP.h: Add C11-style atomic operations

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ccf2d4b091284a60acc6c16d166ea7cafade209f">ccf2d4b0</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T20:59:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Infrastructure for testing with ThreadSanitizer

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a61f66d6c14762869ad95b7646bce975df9f80f8">a61f66d6</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T20:59:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/CNF: Initialize all bdescrs in group

It seems wise and cheap to ensure that the whole bdescr of all blocks of

a compact group is valid, even if most cases only look at the flags

field.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/65136c134d1b6e2f2c5d7193fade3c99a8cb81c4">65136c13</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T20:59:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Capability: Intialize interrupt field

Previously this was left uninitialized.

Also clarify some comments.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b3ce6acaae1b386aeca6649738cf286ad71ed5cd">b3ce6aca</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T20:59:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Task: Make comments proper Notes

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d3890ac737e282a582f0cc9819dedd2a8c363501">d3890ac7</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T20:59:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/SpinLock: Move to proper atomics

This is fairly straightforward; we just needed to use relaxed operations

for the PROF_SPIN counters and a release store instead of a write

barrier.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ef88712f5dcc9e245b4e3819be1889e659731b59">ef88712f</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T20:59:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/OSThreads: Fix data race

Previously we would race on the cached processor count. Avoiding this is

straightforward; just use relaxed operations.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/33a719c392be4d8a389a1331c6c88093148f7396">33a719c3</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T20:59:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/ClosureMaros: Use relaxed atomics

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f08951fd0279248bd4e9536e4cf44ba658aaf710">f08951fd</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T20:59:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Bump minimum-supported gcc version to 4.7

Since the __atomic_* builtins are not supported until gcc 4.7. Given

that this version was released in 2012 I think this is acceptable.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d584923a1e1fe92a4bb38b2cd1f0bf5a3b7802f0">d584923a</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T20:59:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Fix thread leak in hs_try_putmvar00[13]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bf1b0bc78da7dbe5f6fbda54b37a9cb165ff857f">bf1b0bc7</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T20:59:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Introduce SET_HDR_RELEASE

Also ensure that we also store the info table pointer last to ensure

that the synchronization covers all stores.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1a2e9f5e8f125ea47b1d6d2a1740614109488c24">1a2e9f5e</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Add nightly-x86_64-linux-deb9-tsan job

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/58a5b0e55dfb7bbb95f51ade650b1d45dc2d929c">58a5b0e5</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-10-24T21:00:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark setnumcapabilities001 as broken with TSAN

Due to #18808.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d9bc7dea72e0135cd0e969e8b4e977a33cbec906">d9bc7dea</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-10-24T21:00:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Skip divbyzero and derefnull under TSAN

ThreadSanitizer changes the output of these tests.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fcc42a10ada33f2ad6c344fdd8f8468742bf35cd">fcc42a10</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Skip high memory usage tests with TSAN

ThreadSanitizer significantly increases the memory footprint of tests,

so much so that it can send machines into OOM.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cae4bb3e0f65016be057db2f1b02f449ba646e74">cae4bb3e</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark hie002 as high_memory_usage

This test has a peak residency of 1GByte; this is large enough to

classify as "high" in my book.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/dae1b86abc7c22ae92eba264709546783ac4673f">dae1b86a</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T9872[abc] as high_memory_usage

These all have a maximum residency of over 2 GB.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c5a0bb22238a437ae050e8cc6120d5a41533866d">c5a0bb22</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Disable documentation in TSAN build

Haddock chews through enough memory to cause the CI builders to OOM and

there's frankly no reason to build documentation in this job anyways.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4cb1232ec5ad92f40ed494fde4a9f172cc4980fb">4cb1232e</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">TSANUtils: Ensure that C11 atomics are supported

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7ed15f7f84f43729fd8373b8c6fdd07ede07d05e">7ed15f7f</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T3807 as broken with TSAN

Due to #18883.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f7e6f012bcedbf60fac2631e223b8766c9afa959">f7e6f012</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T13702 as broken with TSAN due to #18884

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/16b136b0c3c79833a1e35305f9c5d1b0511eda9c">16b136b0</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Factor out logic to identify a good capability for running a task

Not only does this make the control flow a bit clearer but it also

allows us to add a TSAN suppression on this logic, which requires

(harmless) data races.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2781d68c5d94fd87435d6316c2d4118171e97b14">2781d68c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Annotate benign race in waitForCapability

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f6b4b492d9c112c30ddc0bda2338b143b56faf4c">f6b4b492</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Clarify locking behavior of releaseCapability_

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/65219810a41f1c903838185a766baeba8954cc88">65219810</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Add assertions for task ownership of capabilities

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/31fa87ecb4ff1abc761d776d48e87cd0fd37bedd">31fa87ec</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Use relaxed atomics on n_returning_tasks

This mitigates the warning of a benign race on n_returning_tasks in

shouldYieldCapability.

See #17261.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6517a2ea285688907e8d71e8313f04e919a24445">6517a2ea</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Mitigate races in capability interruption logic

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2e9ba3f2881a59fde9932929dce7c42cdcfd4432">2e9ba3f2</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Capability: Use relaxed operations for last_free_capability

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e10dde371229d45bcc864207cfb6e022dde51bf9">e10dde37</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Use relaxed operations for cap->running_task (TODO)

This shouldn't be necessary since only the owning thread of the capability

should be touching this.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/855325cdcad4c10e0f37c10934a62a07c6ec48b2">855325cd</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Schedule: Use relaxed operations for sched_state

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/811f915db3b682f33aad2c3e6ca039a6e8451c69">811f915d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Accept data race in work-stealing implementation

This race is okay since the task is owned by the capability pushing it.

By Note [Ownership of Task] this means that the capability is free to

write to `task->cap` without taking `task->lock`.

Fixes #17276.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8d2b3c3d1fcb9009b6dfcce85777e04bcec9d219">8d2b3c3d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Eliminate data races on pending_sync

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f88710185acc0e02b334b96004f4b8fae38c5eb9">f8871018</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Schedule: Eliminate data races on recent_activity

We cannot safely use relaxed atomics here.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d079b9435382882b0b069ea40bcd287db18082d3">d079b943</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Avoid data races in message handling

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/06f80497b8bd5eea93b72989e9b58372ef482ef9">06f80497</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Messages: Drop incredibly fishy write barrier

executeMessage previously had a write barrier at the beginning of its

loop apparently in an attempt to synchronize with another thread's

writes to the Message. I would guess that the author had intended to use

a load barrier here given that there are no globally-visible writes done

in executeMessage.

I've removed the redundant barrier since the necessary load barrier is

now provided by the ACQUIRE_LOAD.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d4a87779dc691a4db876817e01ba237655768d77">d4a87779</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/ThreadPaused: Avoid data races

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/56778ab38eeb9fd683250a57c228f3821a444811">56778ab3</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Schedule: Eliminate data races in run queue management

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/086521f744f989a4f11585989f1304ab1333a61b">086521f7</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Eliminate shutdown data race on task counters

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/abad977849a70578bca4e5b17a85aff43e3327be">abad9778</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Threads: Avoid data races (TODO)

Replace barriers with appropriate ordering. Drop redundant barrier in

tryWakeupThread (the RELEASE barrier will be provided by sendMessage's

mutex release).

We use relaxed operations on why_blocked and the stack although it's not

clear to me why this is necessary.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2f56be8a74f1f012f1756380ae111ec1327ddde0">2f56be8a</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Messages: Annotate benign race

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7c0cdab17dcf57702bb57e4b9f4136701a33a2e0">7c0cdab1</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/RaiseAsync: Synchronize what_next read

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6cc2a8a578688e1f0542373d913bc4b171239157">6cc2a8a5</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Task: Move debugTrace to avoid data race

Specifically, we need to hold all_tasks_mutex to read taskCount.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bbaec97d1d3d9984736d5f6424785b1c95bd8312">bbaec97d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Disable flawed assertion

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/dd175a926c0e9654cd6ac8d9d26b183540c87331">dd175a92</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document schedulePushWork race

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3416244b736b386f0bbf8369083f90110cd524a2">3416244b</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Capabiliity: Properly fix data race on n_returning_tasks

There is a real data race but can be made safe by using proper atomic

(but relaxed) accesses.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/dffd943207dd356a113ee8ff3e51227c2655a039">dffd9432</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Make write of to_cap->inbox atomic

This is necessary since emptyInbox may read from to_cap->inbox without

taking cap->lock.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1f4cbc2942ad8b757a225b23c9f097f371ca490c">1f4cbc29</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/BlockAlloc: Use relaxed operations

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d0d07cffeded2b1d1b4ffed1f8b06eddc9f06600">d0d07cff</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Rework handling of mutlist scavenging statistics

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9e5c7f6de8e3d4cda0c07e0f210d9d5004fc6131">9e5c7f6d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Avoid data races in StablePtr implementation

This fixes two potentially problematic data races in the StablePtr

implementation:

 * We would fail to RELEASE the stable pointer table when enlarging it,

   causing other cores to potentially see uninitialized memory.

 * We would fail to ACQUIRE when dereferencing a stable pointer.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/316add6762aca4a01fbe71d264b0c65c11313929">316add67</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Storage: Use atomics

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5c23bc4cd6936840deeb398bbea06165952f17c2">5c23bc4c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Updates: Use proper atomic operations

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3d0f033c5109ae0131b81e6b9aaf2a04ebeba1f4">3d0f033c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:00:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Weak: Eliminate data races

By taking all_tasks_mutex in stat_exit. Also better-document the fact

that the task statistics are protected by all_tasks_mutex.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/edb4b92b218cee5b309866f3d236da30c5621567">edb4b92b</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:01:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/WSDeque: Rewrite with proper atomics

After a few attempts at shoring up the previous implementation, I ended

up turning to the literature and now use the proven implementation,

> N.M. Lê, A. Pop, A.Cohen, and F.Z. Nardelli. "Correct and Efficient

> Work-Stealing for Weak Memory Models". PPoPP'13, February 2013,

> ACM 978-1-4503-1922/13/02.

Note only is this approach formally proven correct under C11 semantics

but it is also proved to be a bit faster in practice.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d39bbd3dbd569d60c7f27f68a1f30885a30c3fa3">d39bbd3d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:01:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Use relaxed atomics for whitehole spin stats

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8f802f386ad5774a863f756f2d8d397903074700">8f802f38</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:01:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Avoid lock order inversion during fork

Fixes #17275.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cef667b081c71008e0633d276349dd863cb46d7f">cef667b0</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-10-24T21:01:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Use proper relaxe operations in getCurrentThreadCPUTime

Here we are doing lazy initialization; it's okay if we do the check more

than once, hence relaxed operation is fine.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8cf50eb1b5f145d7bca9abae6220f4c2622e21b1">8cf50eb1</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:01:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/STM: Use atomics

This fixes a potentially harmful race where we failed to synchronize

before looking at a TVar's current_value.

Also did a bit of refactoring to avoid abstract over management of

max_commits.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/88a7ce3893fe16c7d345e91838722b18ad728740">88a7ce38</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:01:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/stm: Strengthen orderings to SEQ_CST instead of volatile

Previously the `current_value`, `first_watch_queue_entry`, and

`num_updates` fields of `StgTVar` were marked as `volatile` in an

attempt to provide strong ordering. Of course, this isn't sufficient.

We now use proper atomic operations. In most of these cases I strengthen

the ordering all the way to SEQ_CST although it's possible that some

could be weakened with some thought.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f97c59ce014687979fa731db7227773fa83d2156">f97c59ce</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:02:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Mitigate data races in event manager startup/shutdown

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c7c3f8aa978dd6230e3b0f2d21dec84a47bd5e7c">c7c3f8aa</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:02:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Accept benign races in Proftimer

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5a98dfcae41b79bed912521d1eeb2cbc09f0742b">5a98dfca</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:02:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Pause timer while changing capability count

This avoids #17289.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/01d9552509a94d1bd1a717f1730b1c513bf7fea8">01d95525</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:02:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix #17289

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9a528985e8e738b4987b58938fad5711af81b61a">9a528985</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:02:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">suppress #17289 (ticker) race

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1726ec419f3c537b28e1290424203c586408bd41">1726ec41</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:02:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Fix timer initialization

Previously `initScheduler` would attempt to pause the ticker and in so

doing acquire the ticker mutex. However, initTicker, which is

responsible for initializing said mutex, hadn't been called

yet.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bfbe4366e658035a9182500ae286c71fc1ee54fd">bfbe4366</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:02:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Fix races in Pthread timer backend shudown

We can generally be pretty relaxed in the barriers here since the timer

thread is a loop.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/297acc71dbbc0786c55c178d5e5fc453d9f4f2f9">297acc71</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-24T21:02:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Stats: Hide a few unused unnecessarily global functions

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9ad51bc9d2ad9168abad271f715ce73d3562218a">9ad51bc9</a></strong>

<div>

<span>by David Beacham</span>

<i>at 2020-10-27T13:59:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix `instance Bounded a => Bounded (Down a)` (#18716)

* Flip `minBound` and `maxBound` to respect the change in ordering

* Remove awkward `Enum` (and hence `Integral`) instances for

  `Data.Ord.Down`

* Update changelog

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/eedec53df8bf030b36cdd1fcfd1ff06041bc46fd">eedec53d</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-27T14:00:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Version bump: base-4.16 (#18712)

Also bumps upper bounds on base in boot libraries (incl. submodules).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/412018c1214a19649e0ccfff73e80a0622635dd5">412018c1</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-27T14:00:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: simplify logic remove optimization step.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4950dd075ce79e13d24362d669e134ed5a4ddec7">4950dd07</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-27T14:01:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Suppress xelatex output unless it fails

As noted in #18835, xelatex produces an absurd amount of output, nearly

all of which is meaningless. Silence this.

Fixes #18835.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f3d8ab2ef6ffe30ec91c795e0223392dd96ea61a">f3d8ab2e</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-27T14:02:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">build system: Clean mingw tarballs

Tamar noticed in !4293 that the build systems fail to clean up the mingw

tarballs directory (`ghc-tarballs`). Fix this in both the make build

system and Hadrian.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0b3d23afcad8bc14f2ba69b8dbe05c314e6e7b29">0b3d23af</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-10-27T14:02:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix two constraint solving problems

This patch fixes two problems in the constraint solver.

* An actual bug #18555: we were floating out a constraint to eagerly,

  and that was ultimately fatal.  It's explained in

  Note [Do not float blocked constraints] in GHC.Core.Constraint.

  This is all very delicate, but it's all going to become irrelevant

  when we stop floating constraints (#17656).

* A major performance infelicity in the flattener.  When flattening

  (ty |> co) we *never* generated Refl, even when there was nothing

  at all to do.  Result: we would gratuitously rewrite the constraint

  to exactly the same thing, wasting work.  Described in #18413, and

  came up again in #18855.

  Solution: exploit the special case by calling the new function

  castCoercionKind1.  See Note [castCoercionKind1] in

  GHC.Core.Coercion

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f76c5a083edc62bb40efbb0e76e8a3bf50ead765">f76c5a08</a></strong>

<div>

<span>by Sergei Trofimovich</span>

<i>at 2020-10-27T14:03:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc.mk: amend 'make sdist'

Noticed 'make sdist' failure seen as:

```

"rm" -rf sdistprep/ghc/ghc-9.1.0.20201020/hadrian/_build/ (SRC_DIST_GHC_DIR)/hadrian/dist-newstyle/

/bin/sh: -c: line 0: syntax error near unexpected token `('

```

commit 9657f6f34

("sdist: Include hadrian sources in source distribution")

added a new cleanup path without a variable expantion.

The change adds variable reference. While at it move directory

cleanup to a separate statement.

Amends #18794

Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/78b52c888a1cc68750261382e3a62fff65242016">78b52c88</a></strong>

<div>

<span>by David Eichmann</span>

<i>at 2020-10-27T14:03:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use config.run_ways for multi_compile_and_run tests

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e3fdd4197cd9def4af40acb3753843e3e9a74d7e">e3fdd419</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-10-27T14:04:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Api Annotations: Introduce AnnPercent for HsExplicitMult

For the case

  foo :: a %p -> b

The location of the '%' is captured, separate from the 'p'

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d2a25f42f884ad4ac841a36474498131596da506">d2a25f42</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-27T14:05:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Bump ci-images

Bumps bootstrap compiler to 8.10.1.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/28f98b01d055c8027f9495b1669bf875b3e42168">28f98b01</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-10-27T14:05:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DmdAnal: Kill `is_thunk` case in `splitFV`

The `splitFV` function implements the highly dubious hack

described in `Note [Lazy und unleashable free variables]` in

GHC.Core.Opt.DmdAnal. It arranges it so that demand signatures only

carry strictness info on free variables. Usage info is released through

other means, see the Note. It's purely for analysis performance reasons.

It turns out that `splitFV` has a quite involved case for thunks that

produces slightly different usage signatures and it's not clear why we

need it: `splitFV` is only relevant in the LetDown case and the only

time we call it on thunks is for top-level or local recursive thunks.

Since usage signatures of top-level thunks can only reference other

top-level bindings and we completely discard demand info we have on

top-level things (see the lack of `setIdDemandInfo` in

`dmdAnalTopBind`), the `is_thunk` case is completely irrelevant here.

For local, recursive thunks, the added benefit of the `is_thunk` test

is marginal: We get used-multiple-times in some cases where previously

we had used-once if a recursive thunk has multiple call sites. It's

very unlikely and not a case to optimise for.

So we kill the `is_thunk` case and inline `splitFV` at its call site,

exposing `isWeakDmd` from `GHC.Types.Demand` instead.

The NoFib summary supports this decision:

```

            Min           0.0%     -0.0%

            Max           0.0%     +0.0%

 Geometric Mean          -0.0%     -0.0%

```

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/60322f930c544fabd7e68231db26e3a1fb8ed037">60322f93</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-28T21:11:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Don't quote metric baseline argument

Previously this was quoted inappropriately.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c85eb3722bc68999dee023c98a8da0ffbbd89760">c85eb372</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-10-28T21:12:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">API Annotations: put constructors in alphabetical order

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/795908dc4eab8e8b40cb318a2adbe4a4d4126c74">795908dc</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-10-29T03:53:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Widen acceptance threshold for T10421a

Progress towards #18842. As @sgraf812 points out, widening the window is

dangerous until the exponential described in #17658 is fixed. But this

test has caused enough misery and is low stakes enough that we and

@bgamari think it's worth it in this one case for the time being.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0e9f6defbdc1f691ff7197b21e68ac16ffa4ab59">0e9f6def</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-29T03:53:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Split GHC.Driver.Types

I was working on making DynFlags stateless (#17957), especially by

storing loaded plugins into HscEnv instead of DynFlags. It turned out to

be complicated because HscEnv is in GHC.Driver.Types but LoadedPlugin

isn't: it is in GHC.Driver.Plugins which depends on GHC.Driver.Types. I

didn't feel like introducing yet another hs-boot file to break the loop.

Additionally I remember that while we introduced the module hierarchy

(#13009) we talked about splitting GHC.Driver.Types because it contained

various unrelated types and functions, but we never executed. I didn't

feel like making GHC.Driver.Types bigger with more unrelated Plugins

related types, so finally I bit the bullet and split GHC.Driver.Types.

As a consequence this patch moves a lot of things. I've tried to put

them into appropriate modules but nothing is set in stone.

Several other things moved to avoid loops.

* Removed Binary instances from GHC.Utils.Binary for random compiler

  things

* Moved Typeable Binary instances into GHC.Utils.Binary.Typeable: they

  import a lot of things that users of GHC.Utils.Binary don't want to

  depend on.

* put everything related to Units/Modules under GHC.Unit:

  GHC.Unit.Finder, GHC.Unit.Module.{ModGuts,ModIface,Deps,etc.}

* Created several modules under GHC.Types: GHC.Types.Fixity, SourceText,

  etc.

* Split GHC.Utils.Error (into GHC.Types.Error)

* Finally removed GHC.Driver.Types

Note that this patch doesn't put loaded plugins into HscEnv. It's left

for another patch.

Bump haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/22f5d9a951dbc9cfdf55984c5e2a6fad28a6f650">22f5d9a9</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-29T03:53:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">GC: Avoid data race (#18717, #17964)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2ef2fac4c412a25fa64f79b759d69d22a4ebc784">2ef2fac4</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-10-29T04:18:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Check for large tuples more thoroughly

This fixes #18723 by:

* Moving the existing `GHC.Tc.Gen.HsType.bigConstraintTuple` validity

  check to `GHC.Rename.Utils.checkCTupSize` for consistency with

  `GHC.Rename.Utils.checkTupSize`, and

* Using `check(C)TupSize` when checking tuple _types_, in addition

  to checking names, expressions, and patterns.

Note that I put as many of these checks as possible in the typechecker so

that GHC can properly distinguish between boxed and constraint tuples. The

exception to this rule is checking names, which I perform in the renamer

(in `GHC.Rename.Env`) so that we can rule out `(,, ... ,,)` and

`''(,, ... ,,)` alike in one fell swoop.

While I was in town, I also removed the `HsConstraintTuple` and

`HsBoxedTuple` constructors of `HsTupleSort`, which are functionally

unused. This requires a `haddock` submodule bump.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7f8be3eb3440a152246a1aef7b4020be4c03cf2e">7f8be3eb</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-10-29T22:08:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove unnecessary gender from comments/docs

While, say, alternating "he" and "she" in sequential writing

may be nicer than always using "they", reading code/documentation

is almost never sequential. If this small change makes individuals

feel more welcome in GHC's codebase, that's a good thing.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/aad1f803471fff1f187b0a0784dc38a867379847">aad1f803</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-30T00:41:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/GC: Use atomics

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d0bc05178ba8a36a8c18158a488471d15fbf97d1">d0bc0517</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-30T00:41:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Use RELEASE ordering in unlockClosure

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d44f523208d32b599fa7e1260de32515d2ef9944">d44f5232</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-30T00:41:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Storage: Accept races on heap size counters

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4e4a73868488f83aa9d355d147e116408634c140">4e4a7386</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-30T00:41:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Join to concurrent mark thread during shutdown

Previously we would take all capabilities but fail to join on the thread

itself, potentially resulting in a leaked thread.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a80cc8577774a744d684cd1f513e373405cd2f2b">a80cc857</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-10-30T00:41:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Fix race in GC CPU time accounting

Ensure that the GC leader synchronizes with workers before calling

stat_endGC.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9902d9ec95dfc3ddb3e8a703de6b000c3ac3871a">9902d9ec</a></strong>

<div>

<span>by Viktor Dukhovni</span>

<i>at 2020-10-30T05:28:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[skip ci] Fix typo in `callocBytes` haddock.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/105d43db7bb7f399be3e5474d207e330d1b2da5a">105d43db</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-30T14:02:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/SpinLock: Separate out slow path

Not only is this in general a good idea, but it turns out that GCC

unrolls the retry loop, resulting is massive code bloat in critical

parts of the RTS (e.g. `evacuate`).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f7b45cde43f47f94b77411477aabdb56f8f63d66">f7b45cde</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-30T14:02:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Use relaxed ordering on spinlock counters

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/31fcb55f4ff8c06c5ab100a6817cae8b571295a9">31fcb55f</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-10-30T18:52:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Split HsConDecl{H98,GADT}Details

Haskell98 and GADT constructors both use `HsConDeclDetails`, which includes

`InfixCon`. But `InfixCon` is never used for GADT constructors, which results

in an awkward unrepresentable state. This removes the unrepresentable state by:

* Renaming the existing `HsConDeclDetails` synonym to `HsConDeclH98Details`,

  which emphasizes the fact that it is now only used for Haskell98-style data

  constructors, and

* Creating a new `HsConDeclGADTDetails` data type with `PrefixConGADT` and

  `RecConGADT` constructors that closely resemble `PrefixCon` and `InfixCon`

  in `HsConDeclH98Details`. The key difference is that `HsConDeclGADTDetails`

  lacks any way to represent infix constructors.

The rest of the patch is refactoring to accommodate the new structure of

`HsConDecl{H98,GADT}Details`. Some highlights:

* The `getConArgs` and `hsConDeclArgTys` functions have been removed, as

  there is no way to implement these functions uniformly for all

  `ConDecl`s. For the most part, their previous call sites now

  pattern match on the `ConDecl`s directly and do different things for

  `ConDeclH98`s and `ConDeclGADT`s.

  I did introduce one new function to make the transition easier:

  `getRecConArgs_maybe`, which extracts the arguments from a `RecCon(GADT)`.

  This is still possible since `RecCon(GADT)`s still use the same representation

  in both `HsConDeclH98Details` and `HsConDeclGADTDetails`, and since the

  pattern that `getRecConArgs_maybe` implements is used in several places,

  I thought it worthwhile to factor it out into its own function.

* Previously, the `con_args` fields in `ConDeclH98` and `ConDeclGADT` were

  both of type `HsConDeclDetails`. Now, the former is of type

  `HsConDeclH98Details`, and the latter is of type `HsConDeclGADTDetails`,

  which are distinct types. As a result, I had to rename the `con_args` field

  in `ConDeclGADT` to `con_g_args` to make it typecheck.

  A consequence of all this is that the `con_args` field is now partial, so

  using `con_args` as a top-level field selector is dangerous. (Indeed, Haddock

  was using `con_args` at the top-level, which caused it to crash at runtime

  before I noticed what was wrong!) I decided to add a disclaimer in the 9.2.1

  release notes to advertise this pitfall.

Fixes #18844. Bumps the `haddock` submodule.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/57c3db9612463426e1724816fd3f98142fec0e31">57c3db96</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-10-31T02:53:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make typechecker equality consider visibility in ForAllTys

Previously, `can_eq_nc'` would equate `ForAllTy`s regardless of their

`ArgFlag`, including `forall i -> i -> Type` and `forall i. i -> Type`! To fix

this, `can_eq_nc'` now uses the `sameVis` function to first check if the

`ArgFlag`s are equal modulo specificity. I have also updated `tcEqType`'s

implementation to match this behavior. For more explanation on the "modulo

specificity" part, see the new `Note [ForAllTy and typechecker equality]`

in `GHC.Tc.Solver.Canonical`.

While I was in town, I fixed some related documentation issues:

* I added `Note [Typechecker equality]` to `GHC.Tc.Utils.TcType` to describe

  what exactly distinguishes `can_eq_nc'` and `tcEqType` (which implement

  typechecker equality) from `eqType` (which implements definitional equality,

  which does not care about the `ArgFlags` of `ForAllTy`s at all).

* The User's Guide had some outdated prose on the specified/inferred

  distinction being different for types and kinds, a holdover from #15079. This

  is no longer the case on today's GHC, so I removed this prose, added some new

  prose to take its place, and added a regression test for the programs in

  #15079.

* The User's Guide had some _more_ outdated prose on inferred type variables

  not being allowed in `default` type signatures for class methods, which is no

  longer true as of the resolution of #18432.

* The related `Note [Deferred Unification]` was being referenced as

  `Note [Deferred unification]` elsewhere, which made it harder to `grep`

  for. I decided to change the name of the Note to `Deferred unification`

  for consistency with the capitalization style used for most other Notes.

Fixes #18863.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a98593f0c7623843a787af5fb628336cb897c527">a98593f0</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-31T02:54:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor numeric constant folding rules

Avoid the use of global pattern synonyms.

1) I think it's going to be helpful to implement constant folding for

   other numeric types, especially Natural which doesn't have a wrapping

   behavior. We'll have to refactor these rules even more so we'd better

   make them less cryptic.

2) It should also be slightly faster because global pattern synonyms

   matched operations for every numeric types instead of the current one:

   e.g., ":**:" pattern was matching multiplication for both Int# and

   Word# types. As we will probably want to implement constant folding

   for other numeric types (Int8#, Int16#, etc.), it is more efficient

   to only match primops for a given type as we do now.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/730ef38f467d67f4f664b2b4a5f4b236864e97b2">730ef38f</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-31T02:54:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Simplify constant-folding (#18032)

See #18032 for the details.

* Use `Lit (LitNumber _ i)` instead of `isLitValue_maybe` which does

  more work but that is not needed for constant-folding

* Don't export `GHC.Types.Literal.isLitValue_maybe`

* Kill `GHC.Types.Literal.isLitValue` which isn't used

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d5a53c1aa6a417a466deb5951c0cc4cd94be97c0">d5a53c1a</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-31T02:55:10-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">primops.txt.pp: Move ByteArray# primops to separate file

This file will be generated.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b4278a41a18132a981b25c59b296cdf3ba970024">b4278a41</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-31T02:55:10-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">primops: Generate ByteArray# index/read/write primops

Previously these were mostly undocumented and was ripe for potential

inconsistencies.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/08e6993a1b956e6edccdc1cecc7250b724bf79a0">08e6993a</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-31T02:55:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move loadDecl into IfaceToCore

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cb1f755c6fb77f140aee11fdc7b4da04dd5dcd02">cb1f755c</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-31T09:26:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix unused variables warnings

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/eb368078204bceba51e3c80e387ce1d776762cfd">eb368078</a></strong>

<div>

<span>by Andrzej Rybczak</span>

<i>at 2020-10-31T09:27:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add testcase for #816

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bd4abdc953427e084e7ecba89db64860f6859822">bd4abdc9</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T01:10:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add performance test for #18698

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/dfd27445308d1ed2df8826c2a045130e918e8192">dfd27445</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-11-01T01:11:09-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add the proper HLint rules and remove redundant keywords from compiler

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ce1bb9959e2465db1c3880f3c532ae7e1be39b41">ce1bb995</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-11-01T08:52:08-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix a leak in `transpose`

This patch was authored by David Feuer <david.feuer@gmail.com>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e63db32c7eb089985a1a7279a0a886a32d70ac0e">e63db32c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T08:52:44-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Scav: Use bd->gen_no instead of bd->gen->no

This potentially saves a cache miss per scavenge.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b1dda15324bf08dcd6265e066577c18d4f3f061d">b1dda153</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T12:58:36-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Stats: Protect with mutex

While on face value this seems a bit heavy, I think it's far better than

enforcing ordering on every access.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5c2e6bced838b7d7617af2bfb272889a9af16a76">5c2e6bce</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T12:58:36-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Tear down stats_mutex after exitHeapProfiling

Since the latter wants to call getRTSStats.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ef25aaa107ae099a2a9bd80d3130664334c69482">ef25aaa1</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T13:02:11-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Annotate hopefully "benign" races in freeGroup

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3a18155331e07e53b9f3b1d987ed430066b17aa4">3a181553</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T13:02:18-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Strengthen ordering in releaseGCThreads

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/af474f6246036d4f904949af96c5c74fb8d1dbe0">af474f62</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T13:05:38-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Suppress data race due to close

This suppresses the other side of a race during shutdown.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b4686bff56377a583f0605b81fae290d3fee4c4a">b4686bff</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T13:09:59-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Merge branch 'wip/tsan/ci' into wip/tsan/all

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b8e66e0eecdc58ec5fea0b2c9a9454d38858886c">b8e66e0e</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T13:10:01-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Merge branch 'wip/tsan/storage' into wip/tsan/all

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/375512cfbb968ed0ffbdf33153b71fab4b707dce">375512cf</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T13:10:02-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Merge branch 'wip/tsan/wsdeque' into wip/tsan/all

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/65ebf07e459733b9dfb51b02ac987411bd478841">65ebf07e</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T13:10:03-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Merge branch 'wip/tsan/misc' into wip/tsan/all

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/55c375d0bc1c7b9f5476d2b074f5da3539386c93">55c375d0</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T13:10:04-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Merge branch 'wip/tsan/stm' into wip/tsan/all

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a9f75fe23b47358bda585e9af3e2b44da7817c37">a9f75fe2</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T13:10:06-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Merge branch 'wip/tsan/event-mgr' into wip/tsan/all

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8325d6585bd1eb440456abcb05a638c44f2aee88">8325d658</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T13:10:24-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Merge branch 'wip/tsan/timer' into wip/tsan/all

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/07e82ba52228580cfbd90ff031e657acbecc715b">07e82ba5</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-01T13:10:35-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Merge branch 'wip/tsan/stats' into wip/tsan/all

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4ce2f7d6e6a516173750b1d740f345e90992ffce">4ce2f7d6</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-11-02T23:45:06-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add --top flag to driver

This allows us to make `config.top` a proper Path. Previously it was a

str, which caused the Ghostscript detection logic to break.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0b7722219ffdb109c3a8b034a8e112d18e6e4336">0b772221</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-02T23:45:42-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document that ccall convention doesn't support varargs

We do not support foreign "C" imports of varargs functions. While this

works on amd64, in general the platform's calling convention may need

more type information that our Cmm representation can currently provide.

For instance, this is the case with Darwin's AArch64 calling convention.

Document this fact in the users guide and fix T5423 which makes use of a

disallowed foreign import.

Closes #18854.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/81006a06736c7300626f9d692a118b493b585cd5">81006a06</a></strong>

<div>

<span>by David Eichmann</span>

<i>at 2020-11-02T23:46:19-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">RtsAPI: pause and resume the RTS

The `rts_pause` and `rts_resume` functions have been added to `RtsAPI.h` and

allow an external process to completely pause and resume the RTS.

Co-authored-by: Sven Tennie <sven.tennie@gmail.com>

Co-authored-by: Matthew Pickering <matthewtpickering@gmail.com>

Co-authored-by: Ben Gamari <bgamari.foss@gmail.com>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bfb1e272950169c17963adaf423890e47b908f4d">bfb1e272</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-11-02T23:46:55-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Display results of GHC.Core.Lint.lint* functions consistently

Previously, the functions in `GHC.Core.Lint` used a patchwork of

different ways to display Core Lint errors:

* `lintPassResult` (which is the source of most Core Lint errors) renders

  Core Lint errors with a distinctive banner (e.g.,

  `*** Core Lint errors : in result of ... ***`) that sets them apart

  from ordinary GHC error messages.

* `lintAxioms`, in contrast, uses a completely different code path that

  displays Core Lint errors in a rather confusing manner. For example,

  the program in #18770 would give these results:

  ```

  Bug.hs:1:1: error:

      Bug.hs:12:1: warning:

          Non-*-like kind when *-like expected: RuntimeRep

          when checking the body of forall: 'TupleRep '[r]

          In the coercion axiom Bug.N:T :: []. Bug.T ~_R Any

          Substitution: [TCvSubst

                           In scope: InScope {r}

                           Type env: [axl :-> r]

                           Co env: []]

    |

  1 | {-# LANGUAGE DataKinds #-}

    | ^

  ```

* Further digging reveals that `GHC.IfaceToCore` displays Core Lint

  errors for iface unfoldings as though they were a GHC panic. See, for

  example, this excerpt from #17723:

  ```

  ghc: panic! (the 'impossible' happened)

    (GHC version 8.8.2 for x86_64-unknown-linux):

          Iface Lint failure

    In interface for Lib

    ...

  ```

This patch makes all of these code paths display Core Lint errors and

warnings consistently. I decided to adopt the conventions that

`lintPassResult` currently uses, as they appear to have been around the

longest (and look the best, in my subjective opinion). We now use the

`displayLintResult` function for all three scenarios mentioned above.

For example, here is what the Core Lint error for the program in #18770 looks

like after this patch:

```

[1 of 1] Compiling Bug              ( Bug.hs, Bug.o )

*** Core Lint errors : in result of TcGblEnv axioms ***

Bug.hs:12:1: warning:

    Non-*-like kind when *-like expected: RuntimeRep

    when checking the body of forall: 'TupleRep '[r_axn]

    In the coercion axiom N:T :: []. T ~_R Any

    Substitution: [TCvSubst

                     In scope: InScope {r_axn}

                     Type env: [axn :-> r_axn]

                     Co env: []]

*** Offending Program ***

axiom N:T :: T = Any -- Defined at Bug.hs:12:1

*** End of Offense ***

<no location info>: error:

Compilation had errors

```

Fixes #18770.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a9e5f52c571ae3dfd4826e10a256d1a265f7e058">a9e5f52c</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-11-02T23:47:31-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Expand type synonyms with :kind!

The User's Guide claims that `:kind!` should expand type synonyms,

but GHCi wasn't doing this in practice. Let's just update the implementation

to match the specification in the User's Guide.

Fixes #13795. Fixes #18828.

Co-authored-by: Ryan Scott <ryan.gl.scott@gmail.com>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1370eda7a53f5dfc88afe705b2ffecb1d5544ec7">1370eda7</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-02T23:48:06-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Don't capture RunTest output

There are a few reasons why capturing the output of the RunTest builder

is undesirable:

 * there is a large amount of output which then gets unnecessarily

   duplicated by Hadrian if the builder fails

 * the output may contain codepoints which are unrepresentable in the

   current codepage on Windows, causing Hadrian to crash

 * capturing the output causes the testsuite driver to disable

   its colorisation logic, making the output less legible.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/78f2767d4db5e69a142ac6a408a217b11c35949d">78f2767d</a></strong>

<div>

<span>by Matthew Pickering</span>

<i>at 2020-11-03T17:39:53-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update inlining flags documentation

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/14ce454f7294381225b4211dc191a167a386e380">14ce454f</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-11-03T17:40:34-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Linker: reorganize linker related code

Move linker related code into GHC.Linker. Previously it was scattered

into GHC.Unit.State, GHC.Driver.Pipeline, GHC.Runtime.Linker, etc.

Add documentation in GHC.Linker

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/616bec0dee67ae4841c4e60e9406cc9c63358223">616bec0d</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-11-03T17:41:10-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Restrict Linear arrow %1 to exactly literal 1 only

This disallows `a %001 -> b`, and makes sure the type literal is

printed from its SourceText so it is clear why.

Closes #18888

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3486ebe6f960cc55d52c1e645ee15fdeb277d0ab">3486ebe6</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-11-03T17:41:48-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: don't fail if ghc-tarballs dir doesn't exist

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/37f0434d65fa0891a961504c8882893fad7609c6">37f0434d</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-11-03T17:42:26-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Constant-folding: don't pass through GHC's Int/Word (fix #11704)

Constant-folding rules for integerToWord/integerToInt were performing

the following coercions at compilation time:

    integerToWord: target's Integer -> ghc's Word -> target's Word

    integerToInt : target's Integer -> ghc's Int -> target's Int

1) It was wrong for cross-compilers when GHC's word size is smaller than

   the target one. This patch avoids passing through GHC's word-sized

   types:

    integerToWord: target's Integer -> ghc's Integer -> target's Word

    integerToInt : target's Integer -> ghc's Integer -> target's Int

2) Additionally we didn't wrap the target word/int literal to make it

   fit into the target's range! This broke the invariant of literals

   only containing values in range.

   The existing code is wrong only with a 64-bit cross-compiling GHC,

   targeting a 32-bit platform, and performing constant folding on a

   literal that doesn't fit in a 32-bit word. If GHC was built with

   DEBUG, the assertion in GHC.Types.Literal.mkLitWord would fail.

   Otherwise the bad transformation would go unnoticed.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bff74de713dac3e62c3bb6f1946e0649549f2215">bff74de7</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-11-03T17:43:03-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: make GMP's bignat_add not recursive

bignat_add was a loopbreaker with an INLINE pragma (spotted by

@mpickering). This patch makes it non recursive to avoid the issue.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bb100805337adc666867da300ee5b0b11c18fe00">bb100805</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-11-04T16:47:24-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">NCG: Fix 64bit int comparisons on 32bit x86

We no compare these by doing 64bit subtraction and

checking the resulting flags.

We used to do this differently but the old approach was

broken when the high bits compared equal and the comparison

was one of >= or <=.

The new approach should be both correct and faster.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b790b7f91104197429cd80e2c192a6fcda9dd6b4">b790b7f9</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-11-04T16:47:59-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Testsuite: Support for user supplied package dbs

We can now supply additional package dbs to the testsuite.

For make the package db can be supplied by

passing PACKAGE_DB=/path/to/db.

In the testsuite driver it's passed via the --test-package-db

argument.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/81560981fd9af7ea21b2592c405e9e22af838aab">81560981</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-11-04T16:48:42-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't use LEA with 8-bit registers (#18614)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/17d5c51834d64f1762320b7abaa40c5686564f4d">17d5c518</a></strong>

<div>

<span>by Viktor Dukhovni</span>

<i>at 2020-11-05T00:50:23-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Naming, value types and tests for Addr# atomics

The atomic Exchange and CAS operations on integral types are updated to

take and return more natural `Word#` rather than `Int#` values.  These

are bit-block not arithmetic operations, and the sign bit plays no

special role.

Standardises the names to `atomic<OpType><ValType>Addr#`, where `OpType` is one

of `Cas` or `Exchange` and `ValType` is presently either `Word` or `Addr`.

Eventually, variants for `Word32` and `Word64` can and should be added,

once #11953 and related issues (e.g. #13825) are resolved.

Adds tests for `Addr#` CAS that mirror existing tests for

`MutableByteArray#`.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2125b1d6bea0c620e3a089603dace6bb38020c81">2125b1d6</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-11-05T00:51:01-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add a regression test for #18920

Commit f594a68a5500696d94ae36425bbf4d4073aca3b2

(`Use level numbers for generalisation`) ended up fixing #18920. Let's add a

regression test to ensure that it stays fixed.

Fixes #18920.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e07e383a3250cb27a9128ad8d5c68def5c3df336">e07e383a</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-11-06T03:45:28-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Replace HsImplicitBndrs with HsOuterTyVarBndrs

This refactors the GHC AST to remove `HsImplicitBndrs` and replace it with

`HsOuterTyVarBndrs`, a type which records whether the outermost quantification

in a type is explicit (i.e., with an outermost, invisible `forall`) or

implicit. As a result of this refactoring, it is now evident in the AST where

the `forall`-or-nothing rule applies: it's all the places that use

`HsOuterTyVarBndrs`. See the revamped `Note [forall-or-nothing rule]` in

`GHC.Hs.Type` (previously in `GHC.Rename.HsType`).

Moreover, the places where `ScopedTypeVariables` brings lexically scoped type

variables into scope are a subset of the places that adhere to the

`forall`-or-nothing rule, so this also makes places that interact with

`ScopedTypeVariables` easier to find. See the revamped

`Note [Lexically scoped type variables]` in `GHC.Hs.Type` (previously in

`GHC.Tc.Gen.Sig`).

`HsOuterTyVarBndrs` are used in type signatures (see `HsOuterSigTyVarBndrs`)

and type family equations (see `HsOuterFamEqnTyVarBndrs`). The main difference

between the former and the latter is that the former cares about specificity

but the latter does not.

There are a number of knock-on consequences:

* There is now a dedicated `HsSigType` type, which is the combination of

  `HsOuterSigTyVarBndrs` and `HsType`. `LHsSigType` is now an alias for an

  `XRec` of `HsSigType`.

* Working out the details led us to a substantial refactoring of

  the handling of explicit (user-written) and implicit type-variable

  bindings in `GHC.Tc.Gen.HsType`.

  Instead of a confusing family of higher order functions, we now

  have a local data type, `SkolemInfo`, that controls how these

  binders are kind-checked.

  It remains very fiddly, not fully satisfying. But it's better

  than it was.

Fixes #16762. Bumps the Haddock submodule.

Co-authored-by: Simon Peyton Jones <simonpj@microsoft.com>

Co-authored-by: Richard Eisenberg <rae@richarde.dev>

Co-authored-by: Zubin Duggal <zubin@cmi.ac.in>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c85f4928d4dbb2eb2cf906d08bfe7620d6f04ca5">c85f4928</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-11-06T03:46:08-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor -dynamic-too handling

1) Don't modify DynFlags (too much) for -dynamic-too: now when we

   generate dynamic outputs for "-dynamic-too", we only set "dynamicNow"

   boolean field in DynFlags instead of modifying several other fields.

   These fields now have accessors that take dynamicNow into account.

2) Use DynamicTooState ADT to represent -dynamic-too state. It's much

   clearer than the undocumented "DynamicTooConditional" that was used

   before.

As a result, we can finally remove the hscs_iface_dflags field in

HscRecomp. There was a comment on this field saying:

   "FIXME (osa): I don't understand why this is necessary, but I spent

   almost two days trying to figure this out and I couldn't .. perhaps

   someone who understands this code better will remove this later."

I don't fully understand the details, but it was needed because of the

changes made to the DynFlags for -dynamic-too.

There is still something very dubious in GHC.Iface.Recomp: we have to

disable the "dynamicNow" flag at some point for some Backpack's "heinous

hack" to continue to work. It may be because interfaces for indefinite

units are always non-dynamic, or because we mix and match dynamic and

non-dynamic interfaces (#9176), or something else, who knows?

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2cb879092c0c946f5313216fc9ce4b93954c2f74">2cb87909</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-11-06T03:46:44-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[AArch64] Aarch64 Always PIC

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b1d2c1f3246b3740589a59bdf7648c13de47c32b">b1d2c1f3</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-06T03:47:19-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Sanity: Avoid nasty race in weak pointer sanity-checking

See Note [Racing weak pointer evacuation] for all of the gory details.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/638f38c50e80a19275f3a06535a0dd8130a17a53">638f38c5</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-08T09:29:16-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Merge remote-tracking branch 'origin/wip/tsan/all'

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/22888798d224f96202480595fc49bc5c4b2f8328">22888798</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-08T12:08:40-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix haddock submodule

The previous merge mistakenly reverted it.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d445cf05d47e8c5513c55cb5e7157b33e83c8123">d445cf05</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-10T10:26:20-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/linker: Fix relocation overflow in PE linker

Previously the overflow check for the IMAGE_REL_AMD64_ADDR32NB

relocation failed to account for the signed nature of the value.

Specifically, the overflow check was:

    uint64_t v;

    v = S + A;

    if (v >> 32) { ... }

However, `v` ultimately needs to fit into 32-bits as a signed value.

Consequently, values `v > 2^31` in fact overflow yet this is not caught

by the existing overflow check.

Here we rewrite the overflow check to rather ensure that

`INT32_MIN <= v <= INT32_MAX`. There is now quite a bit of repetition

between the `IMAGE_REL_AMD64_REL32` and `IMAGE_REL_AMD64_ADDR32` cases

but I am leaving fixing this for future work.

This bug was first noticed by @awson.

Fixes #15808.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4c407f6e71f096835f8671e2d3ea6bda38074314">4c407f6e</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-11-10T10:27:00-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Export SPEC from GHC.Exts (#13681)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7814cd5bb0d145c4d83d7566885bdc3992b63d0c">7814cd5b</a></strong>

<div>

<span>by David Eichmann</span>

<i>at 2020-11-10T10:27:35-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-heap: expose decoding from heap representation

Co-authored-by: Sven Tennie <sven.tennie@gmail.com>

Co-authored-by: Matthew Pickering <matthewtpickering@gmail.com>

Co-authored-by: Ben Gamari <bgamari.foss@gmail.com>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fa344d33dba71f31f55269c5fc733daa3830073a">fa344d33</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-11-10T10:28:10-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add test case for #17186.

This got fixed sometime recently; not worth it trying to

figure out which commit.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2e63a0fb1bdaecc7916a3cc35dcfd2b2ef37c328">2e63a0fb</a></strong>

<div>

<span>by David Eichmann</span>

<i>at 2020-11-10T10:28:46-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add code comments for StgInfoTable and StgStack structs

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fcfda909fd7fcf539ff31717ce01a56292abb92f">fcfda909</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-11T03:19:59-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nativeGen: Make makeImportsDoc take an NCGConfig rather than DynFlags

It appears this was an oversight as there is no reason the full DynFlags

is necessary.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6e23695e7d84aa248e7ca20bdb8d133f9b356548">6e23695e</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-11T03:19:59-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move this_module into NCGConfig

In various places in the NCG we need the Module currently being

compiled. Let's move this into the environment instead of chewing threw

another register.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c6264a2d652517954b7cd076c7bc4487ed17c97d">c6264a2d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-11T03:20:00-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">codeGen: Produce local symbols for module-internal functions

It turns out that some important native debugging/profiling tools (e.g.

perf) rely only on symbol tables for function name resolution (as

opposed to using DWARF DIEs). However, previously GHC would emit

temporary symbols (e.g. `.La42b`) to identify module-internal

entities. Such symbols are dropped during linking and therefore not

visible to runtime tools (in addition to having rather un-helpful unique

names). For instance, `perf report` would often end up attributing all

cost to the libc `frame_dummy` symbol since Haskell code was no covered

by any proper symbol (see #17605).

We now rather follow the model of C compilers and emit

descriptively-named local symbols for module internal things. Since this

will increase object file size this behavior can be disabled with the

`-fno-expose-internal-symbols` flag.

With this `perf record` can finally be used against Haskell executables.

Even more, with `-g3` `perf annotate` provides inline source code.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/584058ddff71460023712a8d816b83b581e6e78f">584058dd</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-11T03:20:00-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enable -fexpose-internal-symbols when debug level >=2

This seems like a reasonable default as the object file size increases

by around 5%.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c34a4b98b1f09ea3096d39a839a86f2d7185c796">c34a4b98</a></strong>

<div>

<span>by Ömer Sinan Ağacan</span>

<i>at 2020-11-11T03:20:35-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix and enable object unloading in GHCi

Fixes #16525 by tracking dependencies between object file symbols and

marking symbol liveness during garbage collection

See Note [Object unloading] in CheckUnload.c for details.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2782487f5f6ad9df4dc8725226a47f07fec77f9f">2782487f</a></strong>

<div>

<span>by Ray Shih</span>

<i>at 2020-11-11T03:20:35-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add loadNativeObj and unloadNativeObj

(This change is originally written by niteria)

This adds two functions:

* `loadNativeObj`

* `unloadNativeObj`

and implements them for Linux.

They are useful if you want to load a shared object with Haskell code

using the system linker and have GHC call dlclose() after the

code is no longer referenced from the heap.

Using the system linker allows you to load the shared object

above outside the low-mem region. It also loads the DWARF sections

in a way that `perf` understands.

`dl_iterate_phdr` is what makes this implementation Linux specific.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7a65f9e140906087273ce95f062775f18f6a708d">7a65f9e1</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-11-11T03:20:35-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Introduce highMemDynamic

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e9e1b2e75de17be47ab887a26943f5517a8463ac">e9e1b2e7</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-11-11T03:20:35-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Introduce test for dynamic library unloading

This uses the highMemDynamic flag introduced earlier to verify that

dynamic objects are properly unloaded.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5506f1342e51bad71a7525ddad0650d1ac63afeb">5506f134</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-11-11T03:21:14-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Force argument in setIdMult (#18925)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/787e93ae141ae0f33bc36895494d48a2a5e49e08">787e93ae</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-11T23:14:11-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add testcase for #18733

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5353fd500b1e92636cd9d45274585fd88a915ff6">5353fd50</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-12T10:05:30-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">compiler: Fix recompilation checking

In ticket #18733 we noticed a rather serious deficiency in the current

fingerprinting logic for recursive groups. I have described the old

fingerprinting story and its problems in Note [Fingerprinting recursive

groups] and have reworked the story accordingly to avoid these issues.

Fixes #18733.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/63fa399726ff85a3ff4ca42a88f3d8a00921a718">63fa3997</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-11-13T14:29:39-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Arity: Rework `ArityType` to fix monotonicity (#18870)

As we found out in #18870, `andArityType` is not monotone, with

potentially severe consequences for termination of fixed-point

iteration. That showed in an abundance of "Exciting arity" DEBUG

messages that are emitted whenever we do more than one step in

fixed-point iteration.

The solution necessitates also recording `OneShotInfo` info for

`ABot` arity type. Thus we get the following definition for `ArityType`:

```

data ArityType = AT [OneShotInfo] Divergence

```

The majority of changes in this patch are the result of refactoring use

sites of `ArityType` to match the new definition.

The regression test `T18870` asserts that we indeed don't emit any DEBUG

output anymore for a function where we previously would have.

Similarly, there's a regression test `T18937` for #18937, which we

expect to be broken for now.

Fixes #18870.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/197d59facbe8f9799df47e86c99f401ced487040">197d59fa</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-11-13T14:29:39-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Arity: Emit "Exciting arity" warning only after second iteration (#18937)

See Note [Exciting arity] why we emit the warning at all and why we only

do after the second iteration now.

Fixes #18937.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/de7ec9dd2bd573d5950ae294747d2bdb45051000">de7ec9dd</a></strong>

<div>

<span>by David Eichmann</span>

<i>at 2020-11-13T14:30:16-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add rts_listThreads and rts_listMiscRoots to RtsAPI.h

These are used to find the current roots of the garbage collector.

Co-authored-by: Sven Tennie's avatarSven Tennie <sven.tennie@gmail.com>

Co-authored-by: Matthew Pickering's avatarMatthew Pickering <matthewtpickering@gmail.com>

Co-authored-by: default avatarBen Gamari <bgamari.foss@gmail.com>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/24a86f09da3426cf1006004bc45d312725280dd5">24a86f09</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-13T14:30:51-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Cache cabal store in linting job

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0a7e592cb1883824a14639372ba284766849ff3a">0a7e592c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-15T03:35:45-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nativeGen/dwarf: Fix procedure end addresses

Previously the `.debug_aranges` and `.debug_info` (DIE) DWARF

information would claim that procedures (represented with a

`DW_TAG_subprogram` DIE) would only span the range covered by their entry

block. This omitted all of the continuation blocks (represented by

`DW_TAG_lexical_block` DIEs), confusing `perf`. Fix this by introducing

a end-of-procedure label and using this as the `DW_AT_high_pc` of

procedure `DW_TAG_subprogram` DIEs

Fixes #17605.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1e19183d08a3312ac2331b8284d17bc17170a51e">1e19183d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-15T03:35:45-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nativeGen/dwarf: Only produce DW_AT_source_note DIEs in -g3

Standard debugging tools don't know how to understand these so let's not

produce them unless asked.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ad73370f6770480f1786aab8f2b7f5fe155152c8">ad73370f</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-15T03:35:45-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nativeGen/dwarf: Use DW_AT_linkage instead of DW_AT_MIPS_linkage

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a2539650cc9c6606c6b50dd5dd96caa0209b408c">a2539650</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-15T03:35:45-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Add DWARF release jobs for Debian 10, Fedora27

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d61adb3dace8f52e21f302989182145a0efa103f">d61adb3d</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-11-15T03:36:21-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Name (tc)SplitForAll- functions more consistently

There is a zoo of `splitForAll-` functions in `GHC.Core.Type` (as well as

`tcSplitForAll-` functions in `GHC.Tc.Utils.TcType`) that all do very similar

things, but vary in the particular form of type variable that they return. To

make things worse, the names of these functions are often quite misleading.

Some particularly egregious examples:

* `splitForAllTys` returns `TyCoVar`s, but `splitSomeForAllTys` returns

  `VarBndr`s.

* `splitSomeForAllTys` returns `VarBndr`s, but `tcSplitSomeForAllTys` returns

  `TyVar`s.

* `splitForAllTys` returns `TyCoVar`s, but `splitForAllTysInvis` returns

  `InvisTVBinder`s. (This in particular arose in the context of #18939, and

  this finally motivated me to bite the bullet and improve the status quo

  vis-à-vis how we name these functions.)

In an attempt to bring some sanity to how these functions are named, I have

opted to rename most of these functions en masse to use consistent suffixes

that describe the particular form of type variable that each function returns.

In concrete terms, this amounts to:

* Functions that return a `TyVar` now use the suffix `-TyVar`.

  This caused the following functions to be renamed:

  * `splitTyVarForAllTys` -> `splitForAllTyVars`

  * `splitForAllTy_ty_maybe` -> `splitForAllTyVar_maybe`

  * `tcSplitForAllTys` -> `tcSplitForAllTyVars`

  * `tcSplitSomeForAllTys` -> `tcSplitSomeForAllTyVars`

* Functions that return a `CoVar` now use the suffix `-CoVar`.

  This caused the following functions to be renamed:

  * `splitForAllTy_co_maybe` -> `splitForAllCoVar_maybe`

* Functions that return a `TyCoVar` now use the suffix `-TyCoVar`.

  This caused the following functions to be renamed:

  * `splitForAllTy` -> `splitForAllTyCoVar`

  * `splitForAllTys` -> `splitForAllTyCoVars`

  * `splitForAllTys'` -> `splitForAllTyCoVars'`

  * `splitForAllTy_maybe` -> `splitForAllTyCoVar_maybe`

* Functions that return a `VarBndr` now use the suffix corresponding to the

  most relevant type synonym. This caused the following functions to be renamed:

  * `splitForAllVarBndrs` -> `splitForAllTyCoVarBinders`

  * `splitForAllTysInvis` -> `splitForAllInvisTVBinders`

  * `splitForAllTysReq` -> `splitForAllReqTVBinders`

  * `splitSomeForAllTys` -> `splitSomeForAllTyCoVarBndrs`

  * `tcSplitForAllVarBndrs` -> `tcSplitForAllTyVarBinders`

  * `tcSplitForAllTysInvis` -> `tcSplitForAllInvisTVBinders`

  * `tcSplitForAllTysReq` -> `tcSplitForAllReqTVBinders`

  * `tcSplitForAllTy_maybe` -> `tcSplitForAllTyVarBinder_maybe`

Note that I left the following functions alone:

* Functions that split apart things besides `ForAllTy`s, such as `splitFunTys`

  or `splitPiTys`. Thankfully, there are far fewer of these functions than

  there are functions that split apart `ForAllTy`s, so there isn't much of a

  pressing need to apply the new naming convention elsewhere.

* Functions that split apart `ForAllCo`s in `Coercion`s, such as

  `GHC.Core.Coercion.splitForAllCo_maybe`. We could theoretically apply the new

  naming convention here, but then we'd have to figure out how to disambiguate

  `Type`-splitting functions from `Coercion`-splitting functions. Ultimately,

  the `Coercion`-splitting functions aren't used nearly as much as the

  `Type`-splitting functions, so I decided to leave the former alone.

This is purely refactoring and should cause no change in behavior.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/645444af9eb185684c750c95e4740d301352b2b9">645444af</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-11-15T03:36:21-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use tcSplitForAllInvisTyVars (not tcSplitForAllTyVars) in more places

The use of `tcSplitForAllTyVars` in `tcDataFamInstHeader` was the immediate

cause of #18939, and replacing it with a new `tcSplitForAllInvisTyVars`

function (which behaves like `tcSplitForAllTyVars` but only splits invisible

type variables) fixes the issue. However, this led me to realize that _most_

uses of `tcSplitForAllTyVars` in GHC really ought to be

`tcSplitForAllInvisTyVars` instead. While I was in town, I opted to replace

most uses of `tcSplitForAllTys` with `tcSplitForAllTysInvis` to reduce the

likelihood of such bugs in the future.

I say "most uses" above since there is one notable place where we _do_ want

to use `tcSplitForAllTyVars`: in `GHC.Tc.Validity.forAllTyErr`, which produces

the "`Illegal polymorphic type`" error message if you try to use a higher-rank

`forall` without having `RankNTypes` enabled. Here, we really do want to split

all `forall`s, not just invisible ones, or we run the risk of giving an

inaccurate error message in the newly added `T18939_Fail` test case.

I debated at some length whether I wanted to name the new function

`tcSplitForAllInvisTyVars` or `tcSplitForAllTyVarsInvisible`, but in the end,

I decided that I liked the former better. For consistency's sake, I opted to

rename the existing `splitPiTysInvisible` and `splitPiTysInvisibleN` functions

to `splitInvisPiTys` and `splitPiTysInvisN`, respectively, so that they use the

same naming convention. As a consequence, this ended up requiring a `haddock`

submodule bump.

Fixes #18939.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8887102fc4ed8ed1089c1aafd19bab424ad706f3">8887102f</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-11-15T03:36:56-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">AArch64/arm64 adjustments

This addes the necessary logic to support aarch64 on elf, as well

as aarch64 on mach-o, which Apple calls arm64.

We change architecture name to AArch64, which is the official arm

naming scheme.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fc644b1a643128041cfec25db84e417851e28bab">fc644b1a</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-15T03:37:31-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-bin: Build with eventlogging by default

We now have all sorts of great facilities using the

eventlog which were previously unavailable without

building a custom GHC. Fix this by linking with

`-eventlog` by default.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/52114fa0f97805d4c4924bc3abce1a8b0fc7a5c6">52114fa0</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-11-16T11:48:47+01:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add Addr# atomic primops (#17751)

This reuses the codegen used for ByteArray#'s atomic primops.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8150f6546e6fd0006252e245d5697f13ffd8ce3e">8150f654</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-11-18T23:38:40-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Print types of uncovered patterns (#18932)

In order to avoid confusion as in #18932, we display the type of the

match variables in the non-exhaustiveness warning, e.g.

```

T18932.hs:14:1: warning: [-Wincomplete-patterns]

    Pattern match(es) are non-exhaustive

    In an equation for ‘g’:

        Patterns of type  ‘T a’, ‘T a’, ‘T a’ not matched:

            (MkT2 _) (MkT1 _) (MkT1 _)

            (MkT2 _) (MkT1 _) (MkT2 _)

            (MkT2 _) (MkT2 _) (MkT1 _)

            (MkT2 _) (MkT2 _) (MkT2 _)

            ...

   |

14 | g (MkT1 x) (MkT1 _) (MkT1 _) = x

   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

```

It also allows us to omit the type signature on wildcard matches which

we previously showed in only some situations, particularly

`-XEmptyCase`.

Fixes #18932.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/165352a2d163537afb01a835bccc7cd0a667410a">165352a2</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-11-20T02:08:36-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Export indexError from GHC.Ix (#18579)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b57845c3d80f5bed8f498f27fb7a318f2b2f8b2c">b57845c3</a></strong>

<div>

<span>by Kamil Dworakowski</span>

<i>at 2020-11-20T02:09:16-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clarify interruptible FFI wrt masking state

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/321d1bd8a79ab39c3c9e8697fffb0107c43f83cf">321d1bd8</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-11-20T02:09:51-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix strictness signatures of `prefetchValue*#` primops

Their strictness signatures said the primops are strict in their first

argument, which is wrong: Handing it a thunk will prefetch the pointer

to the thunk, but not evaluate it. Hence not strict.

The regression test `T8256` actually tests for laziness in the first

argument, so GHC apparently never exploited the strictness signature.

See also https://gitlab.haskell.org/ghc/ghc/-/issues/8256#note_310867,

where this came up.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0aec78b6c97cee58ba20bfcb959f1369b80c4e4c">0aec78b6</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-11-20T02:09:51-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Demand: Interleave usage and strictness demands (#18903)

As outlined in #18903, interleaving usage and strictness demands not

only means a more compact demand representation, but also allows us to

express demands that we weren't easily able to express before.

Call demands are *relative* in the sense that a call demand `Cn(cd)`

on `g` says "`g` is called `n` times. *Whenever `g` is called*, the

result is used according to `cd`". Example from #18903:

```hs

h :: Int -> Int

h m =

  let g :: Int -> (Int,Int)

      g 1 = (m, 0)

      g n = (2 * n, 2 `div` n)

      {-# NOINLINE g #-}

  in case m of

    1 -> 0

    2 -> snd (g m)

    _ -> uncurry (+) (g m)

```

Without the interleaved representation, we would just get `L` for the

strictness demand on `g`. Now we are able to express that whenever

`g` is called, its second component is used strictly in denoting `g`

by `1C1(P(1P(U),SP(U)))`. This would allow Nested CPR to unbox the

division, for example.

Fixes #18903.

While fixing regressions, I also discovered and fixed #18957.

Metric Decrease:

    T13253-spj

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3a55b3a2574f913d046f3a6f82db48d7f6df32e3">3a55b3a2</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-11-20T02:09:51-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update user's guide entry on demand analysis and worker/wrapper

The demand signature notation has been undocumented for a long time.

The only source to understand it, apart from reading the `Outputable`

instance, has been an outdated wiki page.

Since the previous commits have reworked the demand lattice, I took

it as an opportunity to also write some documentation about notation.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fc963932018ccf5445613ec0932d726b51887769">fc963932</a></strong>

<div>

<span>by Greg Steuck</span>

<i>at 2020-11-20T02:10:31-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Find hadrian location more reliably in cabal-install output

Fix #18944

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9f40cf6ca9fb24dbc55f7eae43e2b89aa12bf251">9f40cf6c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-20T02:11:07-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/linker: Align bssSize to page size when mapping symbol extras

We place symbol_extras right after bss. We also need

to ensure that symbol_extras can be mprotect'd independently from the

rest of the image. To ensure this we round up the size of bss to a page

boundary, thus ensuring that symbol_extras is also page-aligned.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b739c319dd56fa2aabd8007cc200eafb3c7651a7">b739c319</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-20T02:11:43-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Add usage message to ci.sh

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/802e9180dd9a9a88c4e8869f0de1048e1edd6343">802e9180</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-20T02:11:43-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Add VERBOSE environment variable

And change the make build system's default behavior to V=0, greatly

reducing build log sizes.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2a8a979c24fe34a81a438ae179693ddaca12709f">2a8a979c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-21T01:13:26-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: A bit of clean-up in profiling flag documentation

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/56804e33a05729f5a5340d3680ae2849e30a9e86">56804e33</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-21T01:13:26-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Refactor CountParserDeps

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/53ad67eacacde8fde452f1a323d5886183375182">53ad67ea</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-21T01:13:26-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Introduce -fprof-callers flag

This introducing a new compiler flag to provide a convenient way to

introduce profiler cost-centers on all occurrences of the named

identifier.

Closes #18566.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ecfd0278cb811c93853c176fe5df60222d1a8fb5">ecfd0278</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-11-21T01:14:09-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move Plugins into HscEnv (#17957)

Loaded plugins have nothing to do in DynFlags so this patch moves them

into HscEnv (session state).

"DynFlags plugins" become "Driver plugins" to still be able to register

static plugins.

Bump haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/72f2257c792e6178933f12ee3401939da11584b6">72f2257c</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-11-21T01:14:09-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't initialize plugins in the Core2Core pipeline

Some plugins can be added via TH (cf addCorePlugin). Initialize them in

the driver instead of in the Core2Core pipeline.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ddbeeb3c7dc7a2781801cc0e6539d2b4b0e97a20">ddbeeb3c</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-11-21T01:14:44-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add regression test for #10504

This issue was fixed at some point between GHC 8.0 and 8.2. Let's add a

regression test to ensure that it stays fixed.

Fixes #10504.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a4a6dc2a90e28c34054d0cfd4c6fd962bf4adc2e">a4a6dc2a</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-21T01:15:21-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">dwarf: Apply info table offset consistently

Previously we failed to apply the info table offset to the aranges and

DIEs, meaning that we often failed to unwind in gdb. For some reason

this only seemed to manifest in the RTS's Cmm closures. Nevertheless,

now we can unwind completely up to `main`

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/69bfbc216c2278c9796aa999c7815c19c12b0f2c">69bfbc21</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-21T01:15:56-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Disable stripping when debug information is enabled

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7e93ae8b2257c17d5ae5ef7832db723e897c8e8b">7e93ae8b</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-21T13:13:29-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Post ticky entry counts to the eventlog

We currently only post the entry counters, not the other global

counters as in my experience the former are more useful. We use the heap

profiler's census period to decide when to dump.

Also spruces up the documentation surrounding ticky-ticky a bit.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bc9c3916df96a20c58b91fd383a0da77ec83c4b0">bc9c3916</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-22T06:28:10-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement -ddump-c-backend argument

To dump output of the C backend.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/901bc2208a115e0f8313b3aa9abc76fd05509aaa">901bc220</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-22T12:39:02-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump time submodule to 1.11.1

Also bumps directory, Cabal, hpc, time, and unix submodules.

Closes #18847.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/92c0afbf592e71dae3c80cec09b1596df50ff8a9">92c0afbf</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-22T12:39:38-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Dump STG when ticky is enabled

This changes the "ticky" modifier to enable dumping of final STG as this

is generally needed to make sense of the ticky profiles.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d23fef68415ce6587f77e9530cb0571bb90b31cc">d23fef68</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-22T12:39:38-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Introduce notion of flavour transformers

This extends Hadrian's notion of "flavour", as described in #18942.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/179d0becd2ddfa216f7b221df9fc520a352fdbe7">179d0bec</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-22T12:39:38-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Add a viaLlvmBackend modifier

Note that this also slightly changes the semantics of these flavours as

we only use LLVM for >= stage1 builds.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d4d95e51a463e539fceb1c6f191e84adaa337e3b">d4d95e51</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-22T12:39:38-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Add profiled_ghc and no_dynamic_ghc modifiers

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6815603f271484766425ff2e37043b78da2d073c">6815603f</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-22T12:39:38-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Drop redundant flavour definitions

Drop the profiled, LLVM, and ThreadSanitizer flavour definitions as

these can now be realized with flavour transformers.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f88f43398217a5f4c2d326555e21fb1417a21db2">f88f4339</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-24T02:43:20-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Flush eventlog buffers from flushEventLog

As noted in #18043, flushTrace failed flush anything beyond the writer.

This means that a significant amount of data sitting in capability-local

event buffers may never get flushed, despite the users' pleads for us to

flush.

Fix this by making flushEventLog flush all of the event buffers before

flushing the writer.

Fixes #18043.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7c03cc5010999d0f0f9dfc549984023b3a1f2c8d">7c03cc50</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-24T02:43:55-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Run LLVM job on appropriately-labelled MRs

Namely, those marked with the ~"LLVM backend" label

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9b95d815d718ce671e9e87b8a2eb0534ed5688dd">9b95d815</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-24T02:43:55-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Run LLVM builds on Debian 10

The current Debian 9 image doesn't provide LLVM 7.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2ed3e6c0f179c06828712832d1176519cdfa82a6">2ed3e6c0</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-24T02:43:55-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">CmmToLlvm: Declare signature for memcmp

Otherwise `opt` fails with:

    error: use of undefined value '@memcmp$def'

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/be5d74caab64abf9d986fc7290f62731db7e73e7">be5d74ca</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-11-26T16:00:32-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[Sized Cmm] properly retain sizes.

This replaces all Word<N> = W<N># Word# and Int<N> = I<N># Int#  with

Word<N> = W<N># Word<N># and Int<N> = I<N># Int<N>#, thus providing us

with properly sized primitives in the codegenerator instead of pretending

they are all full machine words.

This came up when implementing darwinpcs for arm64.  The darwinpcs reqires

us to pack function argugments in excess of registers on the stack.  While

most procedure call standards (pcs) assume arguments are just passed in

8 byte slots; and thus the caller does not know the exact signature to make

the call, darwinpcs requires us to adhere to the prototype, and thus have

the correct sizes.  If we specify CInt in the FFI call, it should correspond

to the C int, and not just be Word sized, when it's only half the size.

This does change the expected output of T16402 but the new result is no

less correct as it eliminates the narrowing (instead of the `and` as was

previously done).

Bumps the array, bytestring, text, and binary submodules.

Co-Authored-By: Ben Gamari <ben@well-typed.com>

Metric Increase:

    T13701

    T14697

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a84e53f978341135355c5c82cd7af2ae2efa5e72">a84e53f9</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-11-26T16:00:32-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">RTS: Fix failed inlining of copy_tag.

On windows using gcc-10 gcc failed to inline copy_tag into evacuate.

To fix this we now set the always_inline attribute for the various

copy* functions in Evac.c. The main motivation here is not the

overhead of the function call, but rather that this allows the code

to "specialize" for the size of the closure we copy which is often

known at compile time.

An earlier commit also tried to avoid evacuate_large inlining. But

didn't quite succeed. So I also marked evacuate_large as noinline.

Fixes #12416

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cdbd16f5450998ad27f376e97b11d3e2873b95f9">cdbd16f5</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-11-26T16:00:33-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix toArgRep to support 64-bit reps on all systems

[This is @Ericson2314 writing a commit message for @hsyl20's patch.]

(Progress towards #11953, #17377, #17375)

`Int64Rep` and `Word64Rep` are currently broken on 64-bit systems.  This

is because they should use "native arg rep" but instead use "large arg

rep" as they do on 32-bit systems, which is either a non-concept or a

128-bit rep depending on one's vantage point.

Now, these reps currently aren't used during 64-bit compilation, so the

brokenness isn't observed, but I don't think that constitutes reasons

not to fix it. Firstly, the linked issues there is a clearly expressed

desire to use explicit-bitwidth constructs in more places. Secondly, per

[1], there are other bugs that *do* manifest from not threading

explicit-bitwidth information all the way through the compilation

pipeline. One can therefore view this as one piece of the larger effort

to do that, improve ergnomics, and squash remaining bugs.

Also, this is needed for !3658. I could just merge this as part of that,

but I'm keen on merging fixes "as they are ready" so the fixes that

aren't ready are isolated and easier to debug.

[1]: https://mail.haskell.org/pipermail/ghc-devs/2020-October/019332.html

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a9378e690d79ea5fce18aad96c76c8eb34f2ebba">a9378e69</a></strong>

<div>

<span>by Tim Barnes</span>

<i>at 2020-11-26T16:00:34-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Set dynamic users-guide TOC spacing (fixes #18554)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/86a59d930fa6ab0889792c1d67b1d29ba1edec1f">86a59d93</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-26T16:00:34-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Use RTS_LIKELY in CHECK

Most compilers probably already infer that

`barf` diverges but it nevertheless doesn't

hurt to be explicit.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5757e82b9344a3b012cf6d71c347ad727e57f8a3">5757e82b</a></strong>

<div>

<span>by Matthew Pickering</span>

<i>at 2020-11-26T16:00:35-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove special case for GHC.ByteCode.Instr

This was added in

https://github.com/nomeata/ghc-heap-view/commit/34935206e51b9c86902481d84d2f368a6fd93423

GHC.ByteCode.Instr.BreakInfo no longer exists so the special case is dead code.

Any check like this can be easily dealt with in client code.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d9c8b5b472b6e7c4bd5a2b7eeda2bef711db9239">d9c8b5b4</a></strong>

<div>

<span>by Matthew Pickering</span>

<i>at 2020-11-26T16:00:35-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Split Up getClosureDataFromHeapRep

Motivation

1. Don't enforce the repeated decoding of an info table, when the client

can cache it (ghc-debug)

2. Allow the constructor information decoding to be overridden, this

casues segfaults in ghc-debug

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3e3555cc9c2a9f5246895f151259fd2a81621f38">3e3555cc</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-11-26T16:00:35-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">RegAlloc: Add missing raPlatformfield to RegAllocStatsSpill

Fixes #18994

Co-Author: Benjamin Maurer <maurer.benjamin@gmail.com>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a1a75aa9be2c133dd1372a08eeb6a92c31688df7">a1a75aa9</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-11-27T06:20:41-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Allocate MBlocks with MAP_TOP_DOWN on Windows

As noted in #18991, we would previously allocate heap in low memory.

Due to this the linker, which typically *needs* low memory, would end up

competing with the heap. In longer builds we end up running out of

low memory entirely, leading to linking failures.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b3915e9c503854839651b8b6917c1fef4d10f7b7">b3915e9c</a></strong>

<div>

<span>by Shayne Fletcher</span>

<i>at 2020-11-27T12:43:10-05:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Record dot syntax

</pre>

</li>

</ul>

<h4>19 changed files:</h4>

<ul>

<li class="file-stats">

<a href="#a5cc2925ca8258af241be7e5b0381edf30266302">

.gitignore

</a>

</li>

<li class="file-stats">

<a href="#587d266bb27a4dc3022bbed44dfa19849df3044c">

.gitlab-ci.yml

</a>

</li>

<li class="file-stats">

<a href="#157f7634c25bc6366cb7c9c9edb48e819dce38db">

.gitlab/ci.sh

</a>

</li>

<li class="file-stats">

<a href="#e3912a2eb40cf45e3dc98ea1b0275653264428e6">

<span class="new-file">

+

.gitlab/common.sh

</span>

</a>

</li>

<li class="file-stats">

<a href="#412267f7d5ed866deae5ac2ca598ff8092b826b6">

.gitlab/linters/check-cpp.py

</a>

</li>

<li class="file-stats">

<a href="#8ec9a00bfd09b3190ac6b22251dbb1aa95a0579d">

README.md

</a>

</li>

<li class="file-stats">

<a href="#9ab3868b23ed5d5a6e12ef902049902556fa4009">

aclocal.m4

</a>

</li>

<li class="file-stats">

<a href="#5679d72ae7645e5e1a929ed09c3a58d0a511176d">

<span class="new-file">

+

compiler/.hlint.yaml

</span>

</a>

</li>

<li class="file-stats">

<a href="#d0d96a6d03668aeab20ebe05e2c4ccb798c7e64c">

compiler/GHC.hs

</a>

</li>

<li class="file-stats">

<a href="#0887cf39c5cdf9cf8d6758f410d7dab3023c0d77">

compiler/GHC/Builtin/Names.hs

</a>

</li>

<li class="file-stats">

<a href="#06764eb0158306b83ab1998d18316392a51838c2">

compiler/GHC/Builtin/Names/TH.hs

</a>

</li>

<li class="file-stats">

<a href="#a1519b7fe8a0d4b42e4aaa927fb6ab5b5da0fcdd">

compiler/GHC/Builtin/PrimOps.hs

</a>

</li>

<li class="file-stats">

<a href="#377cfd14c1f92357465df995ec6537b074051322">

compiler/GHC/Builtin/Types.hs

</a>

</li>

<li class="file-stats">

<a href="#be7a5c9dc04ecfe7bedb2a2afcc2a51be6719577">

compiler/GHC/Builtin/Types.hs-boot

</a>

</li>

<li class="file-stats">

<a href="#02362b473a022fb921814e97a6beba08107d38b1">

compiler/GHC/Builtin/Types/Literals.hs

</a>

</li>

<li class="file-stats">

<a href="#8a5cd068459120cddf3814e7b9e02003b87647ba">

compiler/GHC/Builtin/Types/Prim.hs

</a>

</li>

<li class="file-stats">

<a href="#8dc7109003a77f8a82e987dc1de31466aa956174">

compiler/GHC/Builtin/Uniques.hs

</a>

</li>

<li class="file-stats">

<a href="#d95fdf6575459444666f72b2281534e0558a4ba0">

compiler/GHC/Builtin/Utils.hs

</a>

</li>

<li class="file-stats">

<a href="#ee840b93f51ee5ed4233a2f892343421ba49af58">

<span class="new-file">

+

compiler/GHC/Builtin/bytearray-ops.txt.pp

</span>

</a>

</li>

</ul>

<h5>The diff was not included because it is too large.</h5>

</div>

<div class="footer" style="margin-top: 10px;">

<p style="font-size: small; color: #666;">

—

<br>

<a href="https://gitlab.haskell.org/ghc/ghc/-/compare/b55cfb6777e4d32be25d2c4f6ea67a0f03be049b...b3915e9c503854839651b8b6917c1fef4d10f7b7">View it on GitLab</a>.

<br>

You're receiving this email because of your account on gitlab.haskell.org.

If you'd like to receive fewer emails, you can

adjust your notification settings.

</p>

</div>

</body>

</html>