<!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>
Ryan Scott pushed to branch wip/T18389
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/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/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/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/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/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/75fc1ed58bb9adb3f472e1529d368c0fff479353">75fc1ed5</a></strong>
<div>
<span>by Sylvain Henry</span>
<i>at 2020-11-28T15:40:23-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: fix detection of ghc-pkg for cross-compilers
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7cb5df9617544dc3bdf85b719feaaa5d15f01c2c">7cb5df96</a></strong>
<div>
<span>by Sylvain Henry</span>
<i>at 2020-11-28T15:40:23-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: fix ghc-pkg uses (#17601)

Make sure ghc-pkg doesn't read the compiler "settings" file by passing
--no-user-package-db.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e3fd4226a08ac6cd4abe9f25f764e518de66834a">e3fd4226</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-11-28T15:40:23-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Introduce a nightly cross-compilation job

This adds a job to test cross-compilation from x86-64 to AArch64 with
Hadrian.

Fixes #18234
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/698d3d9648e9cb6b3757269e21ce4fa1692a1a3b">698d3d96</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-11-28T15:41:00-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Only deploy GitLab Pages in ghc/ghc>

The deployments are quite large and yet are currently only served for
the ghc/ghc> project.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/625726f988852f5779825a954609d187d9865dc1">625726f9</a></strong>
<div>
<span>by David Eichmann</span>
<i>at 2020-11-28T15:41:37-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-heap: partial TSO/STACK decoding

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/22ea9c296906ad3a8fed384bcf6fb35d4b6ca814">22ea9c29</a></strong>
<div>
<span>by Andreas Klebinger</span>
<i>at 2020-11-28T15:42:13-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Small optimization to CmmSink.

Inside `regsUsedIn` we can avoid some thunks by specializing the
recursion. In particular we avoid the thunk for `(f e z)` in the
MachOp/Load branches, where we know this will evaluate to z.

Reduces allocations for T3294 by ~1%.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bba42c62220a437f52e7d30cbfa67e93b4cab06e">bba42c62</a></strong>
<div>
<span>by John Ericson</span>
<i>at 2020-11-28T15:42:49-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make primop handler indentation more consistent
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c82bc8e9d444d6d61198f3bfbcc7c5bb5f6ce13c">c82bc8e9</a></strong>
<div>
<span>by John Ericson</span>
<i>at 2020-11-28T15:42:49-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Cleanup some primop constructor names

Harmonize the internal (big sum type) names of the native vs fixed-sized
number primops a bit. (Mainly by renaming the former.)

No user-facing names are changed.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ae14f160c64d20880486ba365348ef3900c84a60">ae14f160</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-11-28T15:43:25-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T14702 as fragile on Windows

Due to #18953.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1bc104b029b4f043cac42253ee2387f4d574abca">1bc104b0</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-11-29T15:33:18-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">withTimings: Emit allocations counter

This will allow us to back out the allocations per compiler pass from
the eventlog. Note that we dump the allocation counter rather than the
difference since this will allow us to determine how much work is done
*between* `withTiming` blocks.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e992ea84248e2ac9f9d439cd9b25745e8c41e32d">e992ea84</a></strong>
<div>
<span>by GHC GitLab CI</span>
<i>at 2020-11-29T15:33:54-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ThreadPaused: Don't zero slop until free vars are pushed

When threadPaused blackholes a thunk it calls `OVERWRITING_CLOSURE` to
zero the slop for the benefit of the sanity checker. Previously this was
done *before* pushing the thunk's free variables to the update
remembered set. Consequently we would pull zero'd pointers to the update
remembered set.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e82cd140e510a792031247a8f414ade48382703b">e82cd140</a></strong>
<div>
<span>by GHC GitLab CI</span>
<i>at 2020-11-29T15:33:54-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nonmoving: Fix regression from TSAN work

The TSAN rework (specifically aad1f803) introduced a subtle regression
in GC.c, swapping `g0` in place of `gen`. Whoops!

Fixes #18997.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/35a5207e8277800b77af90d74cdd235d29a901e6">35a5207e</a></strong>
<div>
<span>by GHC GitLab CI</span>
<i>at 2020-11-29T15:33:54-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Messages: Add missing write barrier in THROWTO message update

After a THROWTO message has been handle the message closure is
overwritten by a NULL message. We must ensure that the original
closure's pointers continue to be visible to the nonmoving GC.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0120829f47ed9ebd02ffd552d71e45cca3bdc9f6">0120829f</a></strong>
<div>
<span>by GHC GitLab CI</span>
<i>at 2020-11-29T15:33:54-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nonmoving: Add missing write barrier in shrinkSmallByteArray
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8a4d8fb62abde3b79043e8915ee538aaabe2d97c">8a4d8fb6</a></strong>
<div>
<span>by GHC GitLab CI</span>
<i>at 2020-11-29T15:33:54-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Updates: Don't zero slop until closure has been pushed

Ensure that the the free variables have been pushed to the update
remembered set before we zero the slop.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2793cfdc8f7dca8461149d54882286a76f52ff84">2793cfdc</a></strong>
<div>
<span>by GHC GitLab CI</span>
<i>at 2020-11-29T15:33:54-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">OSThreads: Fix error code checking

pthread_join returns its error code and apparently doesn't set errno.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e391a16f919e5bebf75355e8dd1542cdc5656198">e391a16f</a></strong>
<div>
<span>by GHC GitLab CI</span>
<i>at 2020-11-29T15:33:54-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nonmoving: Don't join to mark_thread on shutdown

The mark thread is not joinable as we detach from it on creation.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/60d088aba238c7265adf76840ec1d883373b0e20">60d088ab</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-11-29T15:33:54-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nonmoving: Add reference to Ueno 2016
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3aa603620ef5a6aae1778278aa9914f344ab526e">3aa60362</a></strong>
<div>
<span>by GHC GitLab CI</span>
<i>at 2020-11-29T15:33:54-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nonmoving: Ensure that evacuated large objects are marked

See Note [Non-moving GC: Marking evacuated objects].
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8d304a99d2d0c17fb49c0589c0525817d515c0d0">8d304a99</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-11-30T10:15:22-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/m32: Refactor handling of allocator seeding

Previously, in an attempt to reduce fragmentation, each new allocator
would map a region of M32_MAX_PAGES fresh pages to seed itself. However,
this ends up being extremely wasteful since it turns out that we often
use fewer than this.  Consequently, these pages end up getting freed
which, ends up fragmenting our address space more than than we would
have if we had naively allocated pages on-demand.

Here we refactor m32 to avoid this waste while achieving the
fragmentation mitigation previously desired. In particular, we move all
page allocation into the global m32_alloc_page, which will pull a page
from the free page pool. If the free page pool is empty we then refill
it by allocating a region of M32_MAP_PAGES and adding them to the pool.

Furthermore, we do away with the initial seeding entirely. That is, the
allocator starts with no active pages: pages are rather allocated on an
as-needed basis.

On the whole this ends up being a pleasingly simple change,
simultaneously making m32 more efficient, more robust, and simpler.

Fixes #18980.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b66292890d5fe0791c291f4fc427f1ab1d0f5c15">b6629289</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-11-30T10:15:58-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Use CHECK instead of assert

Use the GHC wrappers instead of <assert.h>.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9f4efa6a5e5d43c81d7e61b27f7cd6e3f812b1ea">9f4efa6a</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-11-30T10:15:58-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/linker: Replace some ASSERTs with CHECK

In the past some people have confused ASSERT, which is for checking
internal invariants, which CHECK, which should be used when checking
things that might fail due to bad input (and therefore should be enabled
even in the release compiler). Change some of these cases in the linker
to use CHECK.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0f8a4655e39bed1ca39820abdd3df9db5706b036">0f8a4655</a></strong>
<div>
<span>by Ryan Scott</span>
<i>at 2020-11-30T10:16:34-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow deploy:pages job to fail

See #18973.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/49ebe369165c85ae4c2382b40e34bfa4f1e9da25">49ebe369</a></strong>
<div>
<span>by chessai</span>
<i>at 2020-11-30T19:47:40-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Optimisations in Data.Foldable (T17867)

This PR concerns the following functions from `Data.Foldable`:
* minimum
* maximum
* sum
* product
* minimumBy
* maximumBy

- Default implementations of these functions now use `foldl'` or `foldMap'`.
- All have been marked with INLINEABLE to make room for further optimisations.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4d79ef6599f44b5ab33cbd89fec96ebfac0794a1">4d79ef65</a></strong>
<div>
<span>by chessai</span>
<i>at 2020-11-30T19:47:40-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Apply suggestion to libraries/base/Data/Foldable.hs</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6af074cecdee533791943af1191541f82abc34c4">6af074ce</a></strong>
<div>
<span>by chessai</span>
<i>at 2020-11-30T19:47:40-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Apply suggestion to libraries/base/Data/Foldable.hs</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ab334262a605b0ebc228096d8af88a55aa5ea6b8">ab334262</a></strong>
<div>
<span>by Viktor Dukhovni</span>
<i>at 2020-11-30T19:48:17-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">dirty MVAR after mutating TSO queue head

While the original head and tail of the TSO queue may be in the same
generation as the MVAR, interior elements of the queue could be younger
after a GC run and may then be exposed by putMVar operation that updates
the queue head.

Resolves #18919
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5eb163f321fdc9a3dbb5e02a157b7f8194e70fcc">5eb163f3</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-11-30T19:48:53-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/linker: Don't allow shared libraries to be loaded multiple times
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/490aa14dbc98e4713f913c4417d454e53b8b278a">490aa14d</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-11-30T19:48:53-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/linker: Initialise CCSs from native shared objects
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6ac3db5fefbac6bea6c8fd0ac64daf036d9a8e60">6ac3db5f</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-11-30T19:48:53-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/linker: Move shared library loading logic into Elf.c
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b6698d73fa9811795ca37ba0b704aa430c390345">b6698d73</a></strong>
<div>
<span>by GHC GitLab CI</span>
<i>at 2020-11-30T19:48:53-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/linker: Don't declare dynamic objects with image_mapped

This previously resulted in warnings due to spurious unmap failures.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b94a65afe1e270245cd5b9fe03d59b726dfba8c4">b94a65af</a></strong>
<div>
<span>by jneira</span>
<i>at 2020-11-30T19:49:31-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Include tried paths in findToolDir error
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/72a87fbc7a95c012be260d1a14374e2b06ed0a36">72a87fbc</a></strong>
<div>
<span>by Richard Eisenberg</span>
<i>at 2020-12-01T19:57:41-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move core flattening algorithm to Core.Unify

This sets the stage for a later change, where this
algorithm will be needed from GHC.Core.InstEnv.

This commit also splits GHC.Core.Map into
GHC.Core.Map.Type and GHC.Core.Map.Expr,
in order to avoid module import cycles
with GHC.Core.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0dd45d0adbade7eaae973b09b4d0ff1acb1479b8">0dd45d0a</a></strong>
<div>
<span>by Richard Eisenberg</span>
<i>at 2020-12-01T19:57:41-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump the # of commits searched for perf baseline

The previous value of 75 meant that a feature branch with
more than 75 commits would get spurious CI passes.

This affects #18692, but does not fix that ticket, because
if a baseline cannot be found, we should fail, not succeed.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8bb52d9186655134e3e06b4dc003e060379f5417">8bb52d91</a></strong>
<div>
<span>by Richard Eisenberg</span>
<i>at 2020-12-01T19:57:41-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove flattening variables

This patch redesigns the flattener to simplify type family applications
directly instead of using flattening meta-variables and skolems. The key new
innovation is the CanEqLHS type and the new CEqCan constraint (Ct). A CanEqLHS
is either a type variable or exactly-saturated type family application; either
can now be rewritten using a CEqCan constraint in the inert set.

Because the flattener no longer reduces all type family applications to
variables, there was some performance degradation if a lengthy type family
application is now flattened over and over (not making progress). To
compensate, this patch contains some extra optimizations in the flattener,
leading to a number of performance improvements.

Close #18875.
Close #18910.

There are many extra parts of the compiler that had to be affected in writing
this patch:

* The family-application cache (formerly the flat-cache) sometimes stores
  coercions built from Given inerts. When these inerts get kicked out, we must
  kick out from the cache as well. (This was, I believe, true previously, but
  somehow never caused trouble.) Kicking out from the cache requires adding a
  filterTM function to TrieMap.

* This patch obviates the need to distinguish "blocking" coercion holes from
  non-blocking ones (which, previously, arose from CFunEqCans). There is thus
  some simplification around coercion holes.

* Extra commentary throughout parts of the code I read through, to preserve
  the knowledge I gained while working.

* A change in the pure unifier around unifying skolems with other types.
  Unifying a skolem now leads to SurelyApart, not MaybeApart, as documented
  in Note [Binding when looking up instances] in GHC.Core.InstEnv.

* Some more use of MCoercion where appropriate.

* Previously, class-instance lookup automatically noticed that e.g. C Int was
  a "unifier" to a target [W] C (F Bool), because the F Bool was flattened to
  a variable. Now, a little more care must be taken around checking for
  unifying instances.

* Previously, tcSplitTyConApp_maybe would split (Eq a => a). This is silly,
  because (=>) is not a tycon in Haskell. Fixed now, but there are some
  knock-on changes in e.g. TrieMap code and in the canonicaliser.

* New function anyFreeVarsOf{Type,Co} to check whether a free variable
  satisfies a certain predicate.

* Type synonyms now remember whether or not they are "forgetful"; a forgetful
  synonym drops at least one argument. This is useful when flattening; see
  flattenView.

* The pattern-match completeness checker invokes the solver. This invocation
  might need to look through newtypes when checking representational equality.
  Thus, the desugarer needs to keep track of the in-scope variables to know
  what newtype constructors are in scope. I bet this bug was around before but
  never noticed.

* Extra-constraints wildcards are no longer simplified before printing.
  See Note [Do not simplify ConstraintHoles] in GHC.Tc.Solver.

* Whether or not there are Given equalities has become slightly subtler.
  See the new HasGivenEqs datatype.

* Note [Type variable cycles in Givens] in GHC.Tc.Solver.Canonical
  explains a significant new wrinkle in the new approach.

* See Note [What might match later?] in GHC.Tc.Solver.Interact, which
  explains the fix to #18910.

* The inert_count field of InertCans wasn't actually used, so I removed
  it.

Though I (Richard) did the implementation, Simon PJ was very involved
in design and review.

This updates the Haddock submodule to avoid #18932 by adding
a type signature.

-------------------------
Metric Decrease:
    T12227
    T5030
    T9872a
    T9872b
    T9872c
Metric Increase:
    T9872d
-------------------------
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d66660ba4c491f9937a1a959b009d90f08a4fbee">d66660ba</a></strong>
<div>
<span>by Richard Eisenberg</span>
<i>at 2020-12-01T19:57:41-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename the flattener to become the rewriter.

Now that flattening doesn't produce flattening variables,
it's not really flattening anything: it's rewriting. This
change also means that the rewriter can no longer be confused
the core flattener (in GHC.Core.Unify), which is sometimes used
during type-checking.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/add0aeaefd4d823d31315564e924ce8c018fb69e">add0aeae</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-12-01T19:58:17-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Introduce mmapAnonForLinker

Previously most of the uses of mmapForLinker were mapping anonymous
memory, resulting in a great deal of unnecessary repetition. Factor this
out into a new helper.

Also fixes a few places where error checking was missing or suboptimal.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/97d71646ddf3814de62573100ed0b224d1588cbc">97d71646</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-12-01T19:58:17-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/linker: Introduce munmapForLinker

Consolidates munmap calls to ensure consistent error handling.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d8872af08d205c3067371d56200e68cf2f0c1ffc">d8872af0</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-12-01T19:58:18-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Linker: Introduce Windows implementations for mmapForLinker, et al.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c35d0e03514ce111ff8265426a7b911456984f50">c35d0e03</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-12-01T19:58:18-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/m32: Introduce NEEDS_M32 macro

Instead of relying on RTS_LINKER_USE_MMAP
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/41c64eb5db50c80e110e47b7ab1c1ee18dada46b">41c64eb5</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-12-01T19:58:18-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/linker: Use m32 to allocate symbol extras in PEi386
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e0b08c5f445f70381c854f78913489685feb224e">e0b08c5f</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-12-03T13:01:47-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Fix copy-paste error

Also be more consistent in quoting.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/33ec3a0600fe8c009ab8ed6d86941a8fd88fb033">33ec3a06</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-12-03T23:11:31-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Run linters through ci.sh

Ensuring that the right toolchain is used.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4a437bc19d2026845948356a932b2cac2417eb12">4a437bc1</a></strong>
<div>
<span>by Shayne Fletcher</span>
<i>at 2020-12-05T09:06:38-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix bad span calculations of post qualified imports
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8fac4b9333ef3607e75b4520d847054316cb8c2d">8fac4b93</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2020-12-05T09:07:13-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add a test for #18923
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/62ed6957463a9c0f711ea698d7ed4371e00fb122">62ed6957</a></strong>
<div>
<span>by Simon Peyton Jones</span>
<i>at 2020-12-08T15:31:41-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix kind inference for data types. Again.

This patch fixes several aspects of kind inference for data type
declarations, especially data /instance/ declarations

Specifically

1. In kcConDecls/kcConDecl make it clear that the tc_res_kind argument
   is only used in the H98 case; and in that case there is no result
   kind signature; and hence no need for the disgusting splitPiTys in
   kcConDecls (now thankfully gone).

   The GADT case is a bit different to before, and much nicer.
   This is what fixes #18891.

   See Note [kcConDecls: kind-checking data type decls]

2. Do not look at the constructor decls of a data/newtype instance
   in tcDataFamInstanceHeader. See GHC.Tc.TyCl.Instance
   Note [Kind inference for data family instances].  This was a
   new realisation that arose when doing (1)

   This causes a few knock-on effects in the tests suite, because
   we require more information than before in the instance /header/.

   New user-manual material about this in "Kind inference in data type
   declarations" and "Kind inference for data/newtype instance
   declarations".

3. Minor improvement in kcTyClDecl, combining GADT and H98 cases

4. Fix #14111 and #8707 by allowing the header of a data instance
   to affect kind inferece for the the data constructor signatures;
   as described at length in Note [GADT return types] in GHC.Tc.TyCl

   This led to a modest refactoring of the arguments (and argument
   order) of tcConDecl/tcConDecls.

5. Fix #19000 by inverting the sense of the test in new_locs
   in GHC.Tc.Solver.Canonical.canDecomposableTyConAppOK.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0abe3ddf85a915ab99ae4f87a85faf6ee5466ad3">0abe3ddf</a></strong>
<div>
<span>by Adam Sandberg Ericsson</span>
<i>at 2020-12-08T15:32:19-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: build the _l and _thr_l rts flavours in the develN flavours

The ghc binary requires the eventlog rts since
fc644b1a643128041cfec25db84e417851e28bab
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d3e5a77c3dca22191704890384cdad4e60d3a30e">d3e5a77c</a></strong>
<div>
<span>by Simon Peyton Jones</span>
<i>at 2020-12-08T16:52:39-05:00</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Work in progress on #18359

Joint work between Richard, Simon, Ryan
</pre>
</li>
</ul>
<h4>30 changed files:</h4>
<ul>
<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="#9ab3868b23ed5d5a6e12ef902049902556fa4009">
aclocal.m4
</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="#377cfd14c1f92357465df995ec6537b074051322">
compiler/GHC/Builtin/Types.hs
</a>
</li>
<li class="file-stats">
<a href="#451725cc4e5d443a3b7c2adcdf224840f953b7e2">
compiler/GHC/Builtin/primops.txt.pp
</a>
</li>
<li class="file-stats">
<a href="#2f6f8d6d05acc04b08fff94df4b3996c65b87892">
compiler/GHC/ByteCode/Asm.hs
</a>
</li>
<li class="file-stats">
<a href="#5c66928780aaad0eb5888511dc4b0b08492c69fa">
compiler/GHC/ByteCode/Types.hs
</a>
</li>
<li class="file-stats">
<a href="#f73a4fa90a8eb153bccdcfcc9f63c15edcd66785">
compiler/GHC/Cmm.hs
</a>
</li>
<li class="file-stats">
<a href="#db697f6aea9f93f1583f1d5c62d25570a1e07f73">
compiler/GHC/Cmm/CLabel.hs
</a>
</li>
<li class="file-stats">
<a href="#806448db91cc2906ebcc088107220a663d3d43eb">
compiler/GHC/Cmm/CommonBlockElim.hs
</a>
</li>
<li class="file-stats">
<a href="#4fbb1c5f251c38fc01fcde693420ee6d02df7e45">
compiler/GHC/Cmm/Dataflow/Label.hs
</a>
</li>
<li class="file-stats">
<a href="#56e23d78cfece2c83f03ed9b9a8ce9b20be26462">
compiler/GHC/Cmm/Expr.hs
</a>
</li>
<li class="file-stats">
<a href="#2d3721ad8de95e1144493ca545db846672cb109f">
compiler/GHC/Cmm/Info/Build.hs
</a>
</li>
<li class="file-stats">
<a href="#b1390f6749e1a2dddcae35f88d55623ea6269f56">
compiler/GHC/Cmm/Sink.hs
</a>
</li>
<li class="file-stats">
<a href="#10b61652f9817945bb54ccf8fc40f8a664ca3c30">
compiler/GHC/CmmToAsm.hs
</a>
</li>
<li class="file-stats">
<a href="#7223682bb3d11ed5bc80db47627d3d9ef7fa2ac7">
compiler/GHC/CmmToAsm/Config.hs
</a>
</li>
<li class="file-stats">
<a href="#b131e0d591301ee7a1c76bbd812f3d14783e934f">
compiler/GHC/CmmToAsm/Dwarf.hs
</a>
</li>
<li class="file-stats">
<a href="#31959c38fe93e481a7160526f11fa80db82d20b7">
compiler/GHC/CmmToAsm/Dwarf/Constants.hs
</a>
</li>
<li class="file-stats">
<a href="#3008b031dfff6e38be4d7b8861e17927ee8c3fab">
compiler/GHC/CmmToAsm/Dwarf/Types.hs
</a>
</li>
<li class="file-stats">
<a href="#ea29061dab1b843e0ea9294afc614998f3a8d08f">
compiler/GHC/CmmToAsm/Monad.hs
</a>
</li>
<li class="file-stats">
<a href="#ce4acbced40df8012ccc56db501549f835fb180b">
compiler/GHC/CmmToAsm/PIC.hs
</a>
</li>
<li class="file-stats">
<a href="#1684e8db5c0d415248dabe224ffe70205adc6b0f">
compiler/GHC/CmmToAsm/Ppr.hs
</a>
</li>
<li class="file-stats">
<a href="#eb63fd2d9f8f64c1063f9ce3e162f92c2e6e508c">
compiler/GHC/CmmToAsm/Reg/Graph.hs
</a>
</li>
<li class="file-stats">
<a href="#23fa440e58d1f384d18650b52802ad6d03891572">
compiler/GHC/CmmToAsm/Reg/Graph/Stats.hs
</a>
</li>
<li class="file-stats">
<a href="#70e6dda2b94c6f8cdd584c1b68c5af73bb1f64e3">
compiler/GHC/CmmToAsm/Reg/Graph/TrivColorable.hs
</a>
</li>
<li class="file-stats">
<a href="#83a3b2df5c77503c3a8c6df05a7654333d30cac3">
compiler/GHC/CmmToAsm/Reg/Linear.hs
</a>
</li>
<li class="file-stats">
<a href="#3225e35c655b58843bc349bd56680268cdf059ed">
compiler/GHC/CmmToAsm/Reg/Linear/FreeRegs.hs
</a>
</li>
<li class="file-stats">
<a href="#d521a7e9ecba2e084a32cf4aa6c27fa59efbab32">
compiler/GHC/CmmToAsm/Reg/Target.hs
</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/8da38465bfce4dab706429ea3197f7b70d832320...d3e5a77c3dca22191704890384cdad4e60d3a30e">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>