Duncan Coutts pushed to branch wip/dcoutts/issue-26717 at Glasgow Haskell Compiler / GHC

Commits:

• 701088db
  by Ben Gamari at 2026-07-01T10:34:03-04:00

  gitlab-ci: Drop vestigial references to make build system
  

• 62d54a53
  by Ben Gamari at 2026-07-01T10:34:03-04:00

  gitlab-ci: Add support for running specifying a job's testsuite ways
  

• 7f97ac2c
  by Ben Gamari at 2026-07-01T10:34:03-04:00

  gitlab-ci: Run llvm testsuite ways in llvm jobs
  
  Addresses #25762.
  

• 7ea75116
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Add normalise_ddump_deriv setup function
  
  Some tests check the result of -ddump-deriv, which may contain INLINE pragmas depending on optimization flags.
  With normalise_ddump_deriv setup function, INLINE pragmas are stripped off.
  

• c7a8199f
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Use -dsuppress-idinfo to make tests more robust
  
  Previously, T18052a and T21755 were failing on 'optasm' and 'optllvm' ways because of visibility of unfoldings.
  

• a12122e5
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Use a trick to keep large objects alive
  
  Previously, T17574 and T19381 were failing on 'optasm' and 'optllvm' ways because of compiler optimizations.
  Change them to use NOINLINE to prevent unwanted optimizations.
  

• 1a95b327
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Only run T24224 in 'normal' way
  
  This test is a frontend-only one and breaks if optimizations are enabled.
  

• 8abea737
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Ignore T18118's stderr
  
  When optimizations are enabled, the compiler emits a warning (You cannot SPECIALISE ...).
  The message is not important, so ignore it.
  

• 9453a722
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Mark T816 and tc216 broken with optimizations
  
  These tests are about type checking, so we should not care too much if they are broken with optimizations.
  
  See #26952
  

• 0aef9ec0
  by Ben Gamari at 2026-07-01T10:34:03-04:00

  testsuite: ds014 is not longer broken
  
  It now appears to pass in the ways it was marked as broken in.
  
  Closes #14901.
  

• 4692d1e4
  by Ben Gamari at 2026-07-01T10:34:03-04:00

  testsuite: Only run stack cloning tests in the normal way
  
  These are too dependent upon code generation specifics to pass in most
  other ways.
  

• c154df26
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Update options_ghc_fbyte-code
  
  The `-fbyte-code` option used to be overriden by `-fllvm` but it is no longer true since !14872 was merged.
  
  I updated the test to accept the new behavior.
  
  Closes #27049
  

• 5d8bb7b5
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Only run T22744 in 'normal' way
  
  This test takes a long time on optimized ways.
  

• d1e74c8e
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Disable tests that use -finfo-table-map on llvm ways
  
  Currently, -finfo-table-map does not work with -fllvm. See #26435
  

• 3bf38c84
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Don't run T24726 on optimized ways
  
  If optimizations are enabled, the rewrite rule just fires and -drule-check will report nothing.
  

• e4eef116
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Use -fno-unoptimized-core-for-interpreter when running LinkableUsage01/02
  
  Optimizations for the bytecode interpreter are considered experimental, and need a flag to be enabled.
  

• 234a9872
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Suppress unwanted optimizations on T25284
  

• 99a2af2f
  by ARATA Mizuki at 2026-07-01T10:34:03-04:00

  testsuite: Don't run stack_big_ret with optimizations
  
  Stack layout may change with optimizations enabled.
  

• 04c836df
  by ARATA Mizuki at 2026-07-01T10:34:04-04:00

  testsuite: Mark memo001 broken on optimized ways
  
  See #27396
  

• 1a8a24f4
  by ARATA Mizuki at 2026-07-01T10:34:04-04:00

  testsuite: Mark syn-perf broken on optimized ways
  
  See #27398
  

• 40412093
  by Duncan Coutts at 2026-07-01T10:34:50-04:00

  Add a test for thread scheduler fairness
  
  It also tests that the interval timer and context switching works.
  We also test that fairness is lost when the context switching interval
  is too coarse for the duration of the test.
  
  We add this test before doing surgery on the interval timer, so we have
  decent coverage.
  

• 3f34d557
  by Duncan Coutts at 2026-07-01T10:34:50-04:00

  Make exported stop/startTimer no-ops, and rename internal functions
  
  Specifically, internally rename:
  stop/startTimer to pause/unpauseTimer
  stop/startTicker to pause/unpauseTicker
  
  and keep stop/startTimer as exported functions, but now as no-ops.
  
  In the past the stop/startTicker actions were used incorrectly as if
  they were synchronous, which they are not. See issue #27105. We now
  document pause/unpackTicker as being async and not to be used for the
  purpose of concurrency safety.
  
  The existing stop/startTimer (note Timer not Ticker, the Timer calls the
  Ticker!) are also exported from the RTS as a public API. This was
  historically because the ticker used signals and it was important to
  suspend the timer signel over a process fork. So these functions were
  exported to be used by the process and unix libraries.
  
  We cannot just remove the RTS exports, but we now make them no-ops, and
  they can be removed from the process and unix library later. This
  was already documented in a changelog.d entry no-more-timer-signal but
  due to changes during the MR process the change to make stop/startTicker
  into no-ops didn't make it into the earlier MR.
  

• 02e84e5f
  by Duncan Coutts at 2026-07-01T10:34:51-04:00

  Make exitTicker/exitTimer unconditionally synchronous
  
  We never use them asynchronously, and we should never need to do so.
  
  And update some related comments.
  

• 13db6a72
  by Duncan Coutts at 2026-07-01T10:34:51-04:00

  posix ticker: update and improve comments on (un)pause and exit
  
  Clarify what is async vs sync.
  

• 43d9a07d
  by Duncan Coutts at 2026-07-01T10:34:51-04:00

  posix ticker: split out ppoll/select helper functions
  
  Move the #ifdefs out of the main code body by introducing local helper
  functions and types, which themselves have two implementations (with a
  common API) based on ppoll or select.
  
  This helps improve clarity/readability.
  

• a5491baa
  by Duncan Coutts at 2026-07-01T10:34:51-04:00

  posix ticker: improve the implementation
  
  The existing implementation supported pausing and exiting, with the
  implementation of pausing reling on a mutex and condition variable.
  It needed to check the pause and stop shared variables on every
  iteration. It relies on ppoll or select, to wait on the timeout and also
  wait on an interrupt fd. The interrupt fd was only used for prompt
  exit/shutdown, and not for pausing or other notification. The pause only
  needed a lock and a memory operation, but the pause was not prompt. The
  resume used a lock, and signaling a cond var.
  
  The new implementation uses a somewhat more regular design: every
  notification is done by setting a shared variable and
  interrupting/notifying the ticker via the fd. The ticker thread does not
  need to check any shared variables on normal timer expiry, only when it
  recevies notification. This may be a micro-optimisation, but the tick
  occurs 100 times a second by default so any improvements in the hot path
  are amplified. When the ticker thread does receive notification it can
  check the various shared variables and update its local state. The
  blocking relies on using ppoll/select but without a timeout. This avoids
  the condition var and also allows further notifications when paused
  (also used for unpausing).
  
  This design can be extended with further notification types if needed by
  using and checking further shared vars (or making existing shared vars
  an enum or counter). This may be used in future for additional
  notifications to the ticker thread. This will likely be used to proxy
  wakeUpRts from a single handler context for example. And this approach,
  avoiding mutexes, is compatible with use from signal handlers.
  
  So overall, it's:
   * slightly simpler / more regular;
   * easier to extend with additional notifications;
   * probably slightly more efficient (but a micro-optimisation);
   * and supports calling notification from signal handlers
  

• 5b20821e
  by Duncan Coutts at 2026-07-01T10:34:51-04:00

  posix ticker: further minor local renaming for code clarity
  
  Improve the clarity with better choice of names for several local vars
  and function.
  

• 1f3ec5e0
  by Duncan Coutts at 2026-07-01T10:34:51-04:00

  win32 ticker: split out local helper functions
  

• 596e7307
  by Duncan Coutts at 2026-07-01T10:34:51-04:00

  win32 ticker: provide guarantee about concurrency and idempotency
  
  Use a lock to ensure pause/unpause can be used concurrently. Use a
  paused variable, protected by the lock, to ensure that pause and unpause
  are both idempotent. This is what the portable API expects.
  

• 1870edd7
  by Duncan Coutts at 2026-07-01T10:34:51-04:00

  win32 ticker: make the initial tick be after one wait interval
  
  There is no need to tick immediately. This is consistent with the
  posix implementation.
  

• 7c15ab5b
  by Duncan Coutts at 2026-07-01T10:34:51-04:00

  ticker: remove now-unnecessary layer of enable/disable
  
  There was an atomic variable used to block *part* of the actions of the
  tick handler. This still did not make stopTimer synchronous, even for
  the part of the the handle_tick actions it covered. It also added a more
  expensive (sequentuially consistent) atomic operation in the hot path
  for the handle_tick action, whereas our new design requires no atomic
  ops at all.
  
  Now that we have eliminate the need for synchronous stop/startTicker,
  we don't need this not-quite-working-anyway atomic protocol. The new
  pause/unpauseTicker is explicitly asynchronous and idempotent.
  

• 8585f8cb
  by Duncan Coutts at 2026-07-01T10:34:51-04:00

  ticker: add TODOs about issue #27250: too much being done from handle_tick
  
  The handle_tick should not perform I/O, block, perform long-running
  operations or call arbitrary user code. Unfortunately, everything to
  do with the eventlog (at the moment) falls into all those categories.
  

• 6e381626
  by Duncan Coutts at 2026-07-01T22:29:55+01:00

  Adjust releaseCapability_ precondition to allow cap->running_task == NULL
  
  There are two use cases for releaseCapability_:
  
  1. The current Task (cap->running_task) releases the Capability.
     The Capability is marked free, and if there is any work to do,
     an appropriate Task is woken up.
  
  2. There is no current task (cap->task == NULL), and thus the
     Capability is idle, and we want to wake up an idle Task to animate
     the Capability. This case uses always_wakeup.
  
  Currently, the precondition for releaseCapability_ is
    cap->running_task != NULL
  and so the 2nd use cases have to set cap->running_task (which is then
  immediately overwritten) just to satisfy the precondition. See the
  use cases in sendMessage and prodCapability.
  
  So we can relax the precondition to be:
    cap->running_task != NULL || always_wakeup
  so that in the always_wakeup case, we say it is ok for the
  cap->running_task to be NULL.
  
  This lets us simplify sendMessage and prodCapability. In particular it
  will allow prodCapability to not need a Task parameter.
  
  The ulterior motive for all this is that I want to be able to call
  prodCapability from an OS thread that is not itself a Task, in persuit
  of issue #27086: disentangle I/O managers from wakeUpRts. The most
  straightforward way to wake the RTS is using prodCapability, but the
  context in which we will need to do that are threads that are not Tasks.
  

• 89404ebc
  by Duncan Coutts at 2026-07-01T22:29:55+01:00

  prodCapability no longer needs to take a Task param
  
  Now that releaseCapability_ can accept cap->running_task == NULL then it
  is no longer necessary for prodCapability to require a Task.
  

• 4e60c5f6
  by Duncan Coutts at 2026-07-01T22:29:56+01:00

  Define prodOneCapability
  
  There was an existing declaration for this in the header file, but no
  definition.
  
  Similarly, there is a declaration for prodAllCapabilities but no
  definition, and we don't need it, so remove the declaration.
  

• 2527026f
  by Duncan Coutts at 2026-07-01T22:29:56+01:00

  Add a wakeUpRtsViaTicker feature to the posix ticker
  
  It proxies a call to wakeUpRts, but crucially, this can be called from
  a signal handler context. It will be used for ctl-c handling.
  

• aa5a03a5
  by Duncan Coutts at 2026-07-01T22:29:56+01:00

  Change how wakeUpRts works
  
  Previously it would call wakeupIOManager to get a capability to wake up
  and run. This works but it entangles the I/O managers with unrelated
  features: ctl-c handling and idle gc (the two features that use wakeUpRts).
  
  The reason it used wakeupIOManager is that this action is safe to use
  from a posix signal handler, since it just posts bytes to a pipe.
  Otherwise the more direct approach (used e.g. by sendMessage when the
  target capability is idle) is to use releaseCapability. But that uses
  condition variables and mutexes, which are not safe to use from within a
  signal handler.
  
  So instead of entangling the (multiple) I/O managers with this, we make
  wakeUpRts use the direct approach (using prodOneCapability). On win32
  the ctl-c console handler can call wakeUpRts directly, since it is
  called in a proper thread. On posix, to deal with the signal handler
  problem, we make the signal handler ask the ticker thread to proxy the
  call to wakeUpRts, since the ticker thread is also a proper thread.
  
  This will allow the I/O managers to no longer be concerned with this.
  This is good because there are many I/O managers (and they're
  complicated), but there is (on posix) only one ticker implementation. So
  this is an overall reduction in coupling and complexity.
  
  Fixes issue #27086
  

• c6d53c16
  by sheaf at 2026-07-02T21:35:44-04:00

  Test driver: normalise line numbers into libraries
  
  When comparing the stdout of tests that print out callstacks, we can't
  rely on the stability of exact line:column spans pointing into libraries
  (e.g. ghc-internal), as any change (such as adding a comment) can change
  them.
  
  This commit addresses this by normalising away line:column in callstacks,
  but only when those point into internal libraries. We don't do this in
  general, as the exact span might be important to the test (e.g. for a
  span within the test module itself).
  
  Fixes #27387
  

• 81ee62e0
  by Alan Zimmerman at 2026-07-02T21:36:33-04:00

  EPA: Remove LocatedLW from MatchGroup
  
  This is the last usage of LocatedLW / SrcSpanAnnLW
  

• 925959db
  by Recursion Ninja at 2026-07-04T04:14:12-04:00

  Decoupling 'L.H.S' from 'GHC.Hs.Doc'
  
    * Migrated 'GHC.Hs.Doc' and 'GHC.Hs.DocString' AST defintions from 'GHC.*' namespace,
      to new 'Language.Haskell.Syntax.Doc' module in the 'L.H.S' "namespace."
    * Updated 'HsDocString to be TTG-parameterised as 'HsDocString pass'.
    * Added 'GHC.Hs.Extension.Pass': splits 'GhcPass'/'Pass' and all 'HsDocString'
      TTG instances out of 'GHC.Hs.Extension', which re-exports it unchanged
      (this is backwards compatible and prevents the introduction of a boot file).
    * Deleted 'GHC.Hs.Doc.hs-boot'; removed all 'L.H.S.*' imports of 'GHC.Hs.Doc'.
    * Updated 'GHC.Hs.DocString' to be TTG pass-parameterised throughout; moved
      'mkHsDocStringChunk'/'unpackHDSC' here (require 'GHC.Utils.Encoding').
    * Split 'GHC.Rename.Doc.rnHsDoc' from 'rnHsDocIdentifiersOnly'.
    * Updated parser, renamer, typechecker, HIE, and exact-print for new types.
    * Added 'HsDocString' TTG instances for 'DocNameI' to 'Haddock.Types'.
    * Killed the last module loop between GHC.* and LHS.*.
          - Only edges from LHS.* to GHC.Data.FastString now!
  
  Resolves #26971
  

• b7e24044
  by mangoiv at 2026-07-04T04:14:56-04:00

  ci: retry fetching test metrics
  
  Retry fetching test metrics to make the CI not fail if the services is
  temporarily unavailable
  

• 4180af3f
  by Zubin Duggal at 2026-07-04T04:15:38-04:00

  Bump semaphore-compat submodule to 2.0.1
  
  This versions includes some cruicial fixes for darwin
  

• 242d4317
  by sheaf at 2026-07-04T04:16:19-04:00

  Remove outdated comment in GHC.Data.ShortText
  
  There was a long comment in GHC.Data.ShortText about a workaround that
  was necessary when bootstrapping with GHC 9.2 and below. The actual
  logic has since been dropped, but the comment remained. This commit
  removes the vestigial comment.
  

• 9b714c4c
  by Zubin Duggal at 2026-07-05T09:40:36+05:30

  CorePrep: Don't speculatively evaluate bindings that we have already discovered to be absent
  
  In #25924, we segfault because speculation forces a projection out of a RUBBISH dictionary
  (which we generated because it absent).
  
  Solution: Don't speculate on bindings we already know are absent.
  
  Fixes 25924
  

• 4a59b3ee
  by Zubin Duggal at 2026-07-05T09:40:36+05:30

  Don't make absent fillers for terminating types
  
  In #25924 we discovered that we could speculatively evaluate an absent filler
  for a dictionary, and project a field (a superclass selector) out of it,
  resulting in segfaults.
  
  Solution: Never make an absent filler or rubbish literal for a terminating type
  like a dictionary. mkAbsentFiller returns Nothing for isTerminatingType, so
  worker/wrapper and the specialiser keep the real argument instead.
  
  Some small metric decreases because we do a little less work in the
  simplifier now.
  
  Metric Decrease:
      T9872a
      T9872b
      T9872c
      TcPlugin_RewritePerf
  

• 383ddcd4
  by Alan Zimmerman at 2026-07-06T07:08:16-04:00

  EPA: Move the 'where' annotation for PatSynBind
  
  This allows us to move it out of the MatchGroup exact print annotation
  too
  

• 66d1a5d5
  by fendor at 2026-07-07T16:57:56-04:00

  Add 'backendInfoTableMapValidity' backend predicate
  
  Check whether the backend supports the `-finfo-table-map` flag and
  ignore it otherwise.
  
  Improve by-design documentation of `backendCodeOutput`.
  
  `Backend` is **abstract by design**. Make this clearer in
  `backendCodeOutput` which is incorrectly being used as a proxy for
  `Backend`.
  
  Instead, define the desired property predicates in GHC.Driver.Backend
  In the process, make `backendCodeOutput` total.
  

• 74f1071d
  by fendor at 2026-07-07T16:57:56-04:00

  Add failing test for `-finfo-table-map` and bytecode backend
  
  If you compile a module using the bytecode backend, with
  -finfo-table-map, then the info table map doesn't get populated for the
  module.
  
  This is because the -finfo-table-map code path is implemented mostly in
  the StgToCmm phase which isn't run when creating bytecode.
  
  Ticket #27039
  

• 28d63bca
  by mangoiv at 2026-07-07T16:59:16-04:00

  ci: don't fail nightly if there have been no changes that night
  
  Fixes #27127
  

• 4ebfc478
  by Rodrigo Mesquita at 2026-07-08T04:47:53-04:00

  ttg: Using ShortText over FastString in the AST
  
  To make the AST independent of GHC, this commit replaces usages of
  `FastString` with `HText` in the AST, killing the last edge from
  Language.Haskell.* to GHC.* modules.
  
  Even though we /do/ want to use FastStrings in general -- critically in
  Names or Ids -- there is no particular reason for the FastStrings that
  occur in the AST proper to be FastStrings. Strings in the AST are
  typically unique and don't benefit particularly from being interned
  FastStrings with Uniques for fast comparison.
  
  `HText` is a type synonym for `ShortText` which uses GHC's Modified
  UTF-8 encoding exclusively.
  
  Modified UTF-8 must be used to represent the Haskell AST because the
  Haskell Report allows surrogate code points. `Data.Text.Text` functions
  use Standard UTF-8 which replace surrogates with a placeholder value,
  thus `Data.Text.Text` is unsuitable for AST strings. See the
  `Language.Haskell.Syntax.Text` module header for more details.
  
  Final progress towards #21592
  
  Closes #21628
  

• d910b353
  by Simon Peyton Jones at 2026-07-08T04:48:36-04:00

  Update equality-type documenation in GHC.Builtin.Types.Prim
  
  Fix #27466
  

• b2530542
  by Simon Peyton Jones at 2026-07-08T04:48:36-04:00

  Honour -dsuppress-coercions in GHC.Core.TyCo.pprCo
  
  Fixes #27467
  

• 9a73179a
  by Facundo Domínguez at 2026-07-08T04:49:26-04:00

  Add item to MR checklist asking to squash fixup commits after approval
  
  The checklist has an item that reads
  
      All commits are either individually buildable or squashed.
  
  This item could be checked immediately after sending the merge request
  though. If reviewers ask for amends later on, and the author amends
  the merge request, there was no item that would remind the contributors
  to squash the fixup commits before landing.
  
  This commit adds a new item
  
      After all approvals and before landing: all fixup commits are squashed with their originating commits.
  
  which should be harder to mark as done before approvals have been given.
  

• ed09895d
  by Andreas Klebinger at 2026-07-08T16:53:27-04:00

  Fix a profiling race condition resulting in segfaults.
  
  StgToCmm: Don't assume tagged FUN closures in closureCodeBody.
  When entering a closure the self/node pointer might not be tagged in
  some situations when a thunk is evaluated by multiple threads.
  So we most AND away the tag bits rather than subtracting an expected tag.
  
  Apply.cmm: Fix a race condition occuring when a thunk is mutated during GC.
  
  In stg_ap_0_fast when might need to run GC before entering a thunk. If this happens
  another thread or the GC itself might mutate the closure making entering it no longer
  valid. We now check for this.
  
  Add test and changelog for #27123 fixes.
  

• 67c03eb2
  by Cheng Shao at 2026-07-08T16:54:09-04:00

  ghc-heap: fix invalid srtlen returned by peekItbl when no-TNTC
  
  This patch fixes the no-TNTC code path of `peekItbl` so that it looks
  at the right memory address when reading the `srt` field from the
  `StgInfoTable_` struct. Also adds a `T27465` regression test that
  reproduces the bug on no-TNTC builds before the fix. Fixes #27465.
  
  Co-authored-by: Codex <codex@openai.com>
  

• 2ecabb4f
  by Zubin Duggal at 2026-07-09T09:23:25-04:00

  hadrian: binary-dist-dir should not be the default target
  
  Revert behaviour to pre 23c9b6c392f52ec9d7a8618b204ff6b885f5fba2
  
  In 23c9b6c392f52ec9d7a8618b204ff6b885f5fba2, we applied the following behaviour change:
  
  ```
  hadrian: Build stage 2 cross compilers
  ...
  * hadrian: Make binary-dist-dir the default build target. This allows us
    to have the logic in one place about which libraries/stages to build
    with cross compilers. Fixes #24192
  ```
  
  This is a major regression to development experience, a plain hadrian/build
  --freeze1 now takes ages because we rebuild all docs (which need to go in the
  binary dist dir).
  
  `binary-dist-dir` is the wrong default target for regular GHC development work
  
  Fixes #27445
  

• e16388e3
  by Zubin Duggal at 2026-07-09T09:23:25-04:00

  .gitignore: Add the hadrian system.config introduced by commit 23c9b6c392f52ec9d7a8618b204ff6b885f5fba2
  
  Since
  
  commit 23c9b6c392f52ec9d7a8618b204ff6b885f5fba2
  Author: Matthew Pickering <matthewtpickering@gmail.com>
  Date:   Thu Dec 21 16:17:41 2023 +0000
  
      hadrian: Build stage 2 cross compilers
  
  ./configure produces /hadrian/cfg/system.config.{host,target}
  
  Add these to .gitignore
  

• 7e8abf41
  by Alan Zimmerman at 2026-07-09T09:24:12-04:00

  EPA: Replace AnnListItem with simply [TrailingAnn]
  
  Remove the unnecessary wrapper around a single field.
  

• 29032f17
  by Zubin Duggal at 2026-07-09T09:24:58-04:00

  testsuite: Keep real reason for fragile test failures
  

• c34e03a7
  by Zubin Duggal at 2026-07-09T09:24:58-04:00

  testsuite: Fall back to the failure reason for empty JUnit bodies
  

• 409d40f0
  by Zubin Duggal at 2026-07-09T09:24:58-04:00

  testsuite: Show output diffs in JUnit output
  
  Also refactor compare_outputs to return essentially a `Maybe Diff`
  (`CompareOutput`) instead of a bool, but more pythonic. This
  allows us to pass the diff through nice.
  

• 06fee1ab
  by Zubin Duggal at 2026-07-09T09:24:58-04:00

  perf notes: include stat deviation and acceptance window in notes so they show up in gitlab
  

• 57c0f32c
  by mangoiv at 2026-07-10T11:08:38-04:00

  driver: enable -finter-module-far-jumps by default
  
  this fixes a compatibility bug with certain binutils/gcc versions where
  we were seeing jump offset overflow errors.
  This commit can probably reverted if we stop supporting the problematic
  binutils/gcc verions (2.44 and 14.2, respectively)
  
  Reolves #26994
  

• 4396a6f2
  by Andrea Vezzosi at 2026-07-10T11:09:25-04:00

  [Fix #27287] preserve ModBreaks in ModIface
  

• ed261a7e
  by Cheng Shao at 2026-07-14T17:59:38-04:00

  hadrian: fix HLS support
  
  This patch fixes hadrian's HLS support so one can rely on HLS when
  working on the hadrian codebase. Fixes #27480.
  
  Not building/linking shared libraries for hadrian is a severely
  premature optimization; this top-level setting in `cabal.project` only
  affects home packages while the dependencies in the cabal store are
  built with vanilla/dynamic anyway, and even adding dynamic builds to
  home packages would not be costly due to cabal's usage of
  `-dynamic-too`.
  

• eee8ec5b
  by Cheng Shao at 2026-07-14T18:00:20-04:00

  compiler: fix miscompiled %load_relaxed, add missing %store_relaxed
  
  This patch fixes the %load_relaxed cmm primop compilation logic to
  correctly use relaxed memory ordering, and adds the missing
  %store_relaxed primop. Parsing logic of %load/%store with explicit
  ordering is covered in the AtomicFetch test case. Fixes #27483.
  
  Co-authored-by: Codex <codex@openai.com>
  

• 1718230f
  by Alan Zimmerman at 2026-07-14T18:01:06-04:00

  EPA: Keep binds and sigs together in HsValBindsLR
  
  We combine them into a single list for GhcPs, wrapped in the
  ValBind data type, which is the bind equivalent of ValD, having
  constructors for binds and sigs.
  
  This simplifies exact print processing, especially when using it to
  update the contents of local binds, as we no longer need AnnSortKey
  BindTag
  

• 6bd1ad2a
  by Andreas Klebinger at 2026-07-14T18:01:49-04:00

  Bump nofib submodule to account for MonoLocalBinds.
  
  New versions of GHC enable MonoLocalBinds by default.
  This breaks some of the benchmarks. I've fixed this and
  this bump pulls in that fix.
  

• 7eb0f1c9
  by Cheng Shao at 2026-07-14T18:02:31-04:00

  testsuite: fix bytecodeIPE test under +ipe flavours
  
  This patch fixes the bytecodeIPE test under +ipe flavours. It used to
  fail under +ipe because the RTS is built with IPE info, then
  stg_AP_info in RTS carries IPE info, so whereFrom wouldn't return
  Nothing. Now the test checks IPE info of a datacon in the ghci-loaded
  module which is not affected by whether the RTS is built with IPE info
  or not. Fixes #27498.
  
  Co-authored-by: Codex <codex@openai.com>
  

• ef038aae
  by cydparser at 2026-07-15T04:35:41-04:00

  Reduce bytes allocated for `capabilities` in RTS (fixes #27487)
  
  In rts/Capability.c, `capabilities` is an array of pointers, but it was allocated as if it were an
  array of Capability's.
  

• d377e83e
  by Cheng Shao at 2026-07-15T04:36:27-04:00

  rts: fix missing UNTAG in stg_readTVarIOzh
  
  This patch fixes missing UNTAG on the current value closure read from
  StgTVar. UNTAG is a no-op when it's stg_TREC_HEADER_info which is word
  aligned; it may be a tagged closure, and reading info table from the
  tagged address is an unaligned load which may cause issues on
  platforms with strict alignment requirements.
  
  Co-authored-by: Codex <codex@openai.com>
  

• 8ed03842
  by Cheng Shao at 2026-07-15T04:36:27-04:00

  rts: fix missing UNTAG in stg_control0zh_ll
  
  This patch fixes missing UNTAG on the cont closure returned by
  captureContinuationAndAbort. In case it's not NULL,
  captureContinuationAndAbort returns a tagged StgContinuation closure,
  in which case it must be untagged before accessing the
  apply_mask_frame field.
  
  In the past it worked out of luck: when apply_mask_frame was NULL then
  mask_frame_offset is also 0 so the control flow didn't diverge to a
  wrong path. Still, this is horribly wrong and will crash once
  StgContinuation struct is refactored and fields are shuffled around.
  
  Co-authored-by: Codex <codex@openai.com>
  

• 5aa7000a
  by Cheng Shao at 2026-07-15T04:37:08-04:00

  compiler: fix redundant AP thunk codegen when not using -ticky-ap-thunk
  
  This patch fixes a double negation confusion in !7525 that results in
  some redundant AP thunk code generation when not using
  -ticky-ap-thunk. Now, we use `stgToCmmUseStdApThunk` to indicate
  whether precomputed AP thunks in the RTS should be used, which
  defaults to `True`, unless `-ticky-ap-thunk` is passed.
  `-finfo-table-map` now also implies `-ticky-ap-thunk`, since when
  doing IPE profiling we want the generated AP thunks to be unique.
  Fixes #27502.
  
  -------------------------
  Metric Decrease:
      T3064
  -------------------------
  
  Co-authored-by: Codex <codex@openai.com>
  

• d43a7b7a
  by Brian McKenna at 2026-07-15T20:10:04+02:00

  Strip ticks when desugaring bool guards
  
  The special `considerAccessible` pattern was broken when compiling
  with debug info. Compiling with debug info wraps expressions with
  `SourceNote` ticks, which broke the internals of the
  `desugarBoolGuard` function. Ticks are now ignored within this
  function.
  
  Fixes #27360
  

• ede4b17b
  by Ben Gamari at 2026-07-15T22:59:53-04:00

  base: Display ExceptionContext in WhileHandling's textual description
  
  As originally-implemented the implementation for
  `WhileHandling(displayExceptionAnnotation)` would display the
  `ExceptionContext` of the exception which it carries (as this was the
  behavior of `displayException`, in terms of which
  `displayExceptionAnnotation` was implemented).
  
  However, in 284ffab3 the definition of `SomeException(displayException)`
  was changed to exclude the `ExceptionContext`. This means that
  `WhileHandling(displayExceptionAnnotation)` fails to describe the
  provenance of the exception which it captures, greatly limiting its
  utility.
  
  Return the implementation to its originally-specified behavior by
  implementing `WhileHandling(displayExceptionAnnotation)` in terms of
  `displayExceptionWithInfo`.
  
  Fixes #27456.
  

• 0f64f348
  by Cheng Shao at 2026-07-16T15:41:08+00:00

  ci: add missing docker permission workaround in abi-test job
  

• 660cb239
  by Cheng Shao at 2026-07-16T19:37:48+00:00

  bindist: Fix make install -j race condition on macos/freebsd
  
  This patch fixes make install -j race condition on macos/freebsd. BSD
  install fails with EEXIST when multiple install processes concurrently
  create the same prefix directory. So we add an `install_dirs`
  prerequisite job that sequentially creates the directories for
  subsequent jobs to work with. Fixes #27499.
  
  Co-authored-by: Codex <codex@openai.com>
  

• 08130257
  by Cheng Shao at 2026-07-16T19:37:48+00:00

  ci: run bindist make install with -j
  
  This patch makes the ci scripts run `make install` with `-j` to reduce
  wall clock time when installing the bindist, see related issue for
  benchmark numbers. This only affects ghc ci logic, the user-facing
  default is up to distributors and is still `-j1`. Closes #27029.
  

• d5ae6906
  by Adam Gundry at 2026-07-17T04:57:43-04:00

  Mark various language extension flags as deprecated (see #27329)
  
  The following language extensions are now deprecated:
  
   - AlternativeLayoutRule
   - AlternativeLayoutRuleTransitional
   - ParallelArrays
   - PolymorphicComponents
   - Rank2Types
  
  In addition, the warning `-Walternative-layout-rule-transitional`
  has been marked as deprecated, as it is emitted only under the
  deprecated extension `XAlternativeLayoutRuleTransitional`.
  

• fe3b059c
  by Andrew Lelechenko at 2026-07-17T04:58:26-04:00

  base: re-export GHC.Environment.getFullArgs from System.Environment
  
  CLC proposal https://github.com/haskell/core-libraries-committee/issues/431
  

• de766bb8
  by Duncan Coutts at 2026-07-17T11:44:44+01:00

  Fix failing test GcStaticPointers for non-moving GC
  
  Minor mistake in asserting something before checking for that same
  thing.
  
  Specifically, Bdescr asserts HEAP_ALLOCED_GC, but Bdescr was being used
  prior to a guard that checks HEAP_ALLOCED_GC. The solution is just to
  move the use of Bdescr after the guard.
  
  Fixes issue #27284
  
  Thanks to Simon Jakobi for identifying the problem.
  

• b382e938
  by Duncan Coutts at 2026-07-17T11:56:09+01:00

  Eliminate STM_AWOKEN
  
  It was used as nullary closure for the block_info.closure in the case of
  a thread being awoken after an STM transaction.
  
  However, while it was written, it was never read, so contributed nothing
  to the behaviour. Furthermore, in the only place it was set (in
  tryWakeupThread) the why_blocked was immediately overwritten by the
  NotBlocked status, and the block_info was updated accordingly (by
  appendToRunQueue).
  
  So it didn't even serve a purpose of clarifying an intermediate state,
  there really was no such intermediate state.
  
  Cleaning this up will allow the BlockedOnSTM case to follow the same
  pattern as the other why_blocked cases that do not use the block_info,
  and in turn this reduces the number of different categories.
  

• 94fd9797
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Document that eventlog thread stop code ThreadBlocked is no longer used
  
  It has not been used since GHC 7.0.x (2011). In 7.2 all the BlockedOn*
  codes were added, and these were and are used instead of ThreadBlocked.
  

• 5417604b
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Add a proper mapping to eventlog external thread stop status
  
  That is the mapping from rts-internal codes, to the coes used in the
  status field in the eventlog EVENT_STOP_THREAD event.
  
  See issue #9003 for what goes wrong when we mess this up. In that
  ticket, people note that we should really not require the internal
  tso->why_blocked codes to leak into the external eventlog thread stop
  codes. The same principle applies to the StgThreadReturnCode.
  
  This change properly separates them, and explicitly maps between them
  using a pair of (compact, constant) tables. These tables are pretty
  small (with no alignment constraints) and will soon shrink so it seems
  a sensible tradeoff.
  
  We also introduce and use proper EVENT_STOP_THREAD constants in the
  event log format header. Previously there was not specification in the
  code for these (only in the docs): the values were encoded into the
  conversion code.
  
  This will allow us to renumber the internal why_blockd codes without
  breaking the eventlog output.
  

• 9833f370
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Remove unused tso->block_info.wakeup member.
  
  Presumably it was used once, but not now.
  

• eb25b5de
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Document StgTSOBlockInfo to say what cases use what members
  
  In principle, tso->why_blocked is the tag for the StgTSOBlockInfo union,
  so we should be able to say for each union member the why_blocked cases
  that use that member.
  

• 3ed4f009
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Add a tso->block_info.mvar member and use it
  
  in preference to the generic block_info.closure union member, with
  casts.
  
  The plan is that when we know what case we're in (via tso->why_blocked)
  then we can always access the correct union member, and so we will only
  need to access block_info.closure for generic cases where we don't know
  or don't care.
  

• 44dc01bc
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Add a tso->block_info.unused member and use it
  
  in preference to the generic block_info.closure union member, with
  casts.
  
  The plan is that when we know what case we're in (via tso->why_blocked)
  then we can always access the correct union member, and so we will only
  need to access block_info.closure for generic cases where we don't know
  or don't care.
  

• b327f4f8
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Avoid storing to tso->block_info.closure
  
  In one case we can use a specific union member (.prev) instead. In
  several cases the stores were in fact redundant because of subsequent
  overwrites.
  
  In scavengeTSO we replace setting tso->block_info.closure to a valid
  closure, with an assertion that the block_info.unused is already set to
  END_TSO_QUEUE which is a valid (static) closure.
  

• cf67327c
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Renumber the tso->why_blocked constants
  
  We can do this now because we have separated the internal values from
  the external ones used in the eventlog.
  
  This lets us put them back into a deliberate order and consolodate some
  gaps.
  
  More importantly, it is a prepation for a slightly more sophisticated
  encoding.
  

• 3fd014fa
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Define constants for the existing stg_threadStatuszh return codes
  
  The stg_threadStatuszh reuses the internal tso->why_blocked codes but
  also extends them with a couple previously magic values. This is awkward
  since we need to know what those magic values are so we don't
  accidentally use those values to mean something else. By pulling a
  definition up to where the why_blocked codes are defined we will be able
  to avoid mistakenly assining those codes some meaning (or just changing
  the BlockedThreadComplete, BlockedThreadKilled code if necessary).
  

• 6d06acce
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Extend the tso->why_blocked encoding to indicate block_info closures
  
  We use some bit tricks to cheaply and generically test if a
  tso->why_blocked tag implies that the corresponding tso->block_info will
  contain a non-trivial valid closure (i.e. not just block_info.unused set
  to END_TSO_QUEUE).
  
  In particular we arrange for most why_blocked values to naturally have a
  distinguishing bit, but for the BlockedOn{Read,Write,Delay} cases, they
  can come in either non-closure or closure forms. We allow an additional
  bit to distinguish these cases. The non-closure forms are only from
  legacy I/O managers: select and win32-legacy. So this extra bit
  mechanism will be able to be retired once the legacy I/O managers are
  themselves retired.
  
  This means in a few places we need to untag the why_blocked value before
  inspecting it, but in most places we do not.
  

• 98990a16
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Use BlockInfoForceNonClosure in the select I/O manager
  

• ef3b387a
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Use BlockInfoForceNonClosure in the win32-legacy I/O manager
  
  for the BlockedOn{Read,Write} since these use the non-heap allocated
  StgAsyncIOResult.
  

• 4b31d021
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Enforce the why_blocked and block_info rules in checkTSO
  
  We now check the cases wher IsBlockInfoClosure should hold, the cases
  that are supposed to use block_info.unused == END_TSO_QUEUE, and which
  cases are allowed to use BlockInfoForceNonClosure.
  
  This partially enforces the use of why_blocked as a tag for the
  block_info union. We could be stricter and check for the correct
  expected info table for the closure cases.
  

• cbda8529
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Use IsBlockInfoClosure to simplify several tests
  
  In GC and generic traversal we need to know if we should look at the
  block_info.closure or not. Now we can do just that using a cheap bit
  test on the why_blocked tag.
  
  This fixes issue 26717, where the problem was that some GC modes did not
  know when to look at block_info.closure, because the poll I/O manager
  uses a closure for BlockedOn{Read,Write} while the select I/O manager
  uses a non-closure. Now this information is in the why_blocked tag
  itself.
  

• 39b64d45
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Remove the now-unused scavengeTSOIOManager
  
  The GC no longer has to delegate to the I/O manager, since it can use
  IsBlockInfoClosure to decide things itself.
  

• 2935177a
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Remove duplicate assertion
  

• 33f011e2
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Follow atomic access rules more consistently for tso->why_blocked
  
  The rule is this:
  
  store block_info *before* why_blocked
  store why_blocked using store release
  
  load why_blocked using load acquire
  load block_info *after* why_blocked
  
  This is a an atomic store release / load acquire pair and (if the reads
  are in a separate thread to the writes, and the read receives the value
  stored) then this guarantees a full "happens before" relationship of
  these stores and loads.
  
  In some cases, we do not need a full load acquire, because we don't read
  the block_info at all and so do not need any ordering. In this case we
  just need an atomic relaxed load.
  
  This was being followed in most places, but not all. If there's good
  reason in any case that we don't need atomic access, then we should
  document that in a comment. In the absence of that I think it's easier
  to follow the rule everywhere.
  

• 2476509e
  by Duncan Coutts at 2026-07-17T11:56:10+01:00

  Add a changelog entry
  

393 changed files:

• .gitignore
• .gitlab-ci.yml
• .gitlab/ci.sh
• .gitlab/generate-ci/gen_ci.hs
• .gitlab/jobs.yaml
• .gitlab/merge_request_templates/Default.md
• .gitlab/rel_eng/mk-ghcup-metadata/mk_ghcup_metadata.py
• .gitlab/test-metrics.sh
• + changelog.d/T21628
• + changelog.d/T26716
• + changelog.d/T27123.md
• + changelog.d/T27329
• + changelog.d/T27360
• + changelog.d/T27456
• + changelog.d/fix-absent-dict-projection
• + changelog.d/fix-cmm-atomic-load-store
• + changelog.d/fix-make-install-j
• + changelog.d/fix-peekitbl-no-tntc
• + changelog.d/fix-use-std-ap-thunk
• + changelog.d/inter-module-far-jumps-aarch64-default
• changelog.d/semaphore-v2
• compiler/GHC/Builtin/Types/Prim.hs
• compiler/GHC/Builtin/Utils.hs
• compiler/GHC/ByteCode/Breakpoints.hs
• compiler/GHC/ByteCode/Types.hs
• compiler/GHC/Cmm/CLabel.hs
• compiler/GHC/Cmm/Parser.y
• compiler/GHC/Core/Make.hs
• compiler/GHC/Core/Opt/Specialise.hs
• compiler/GHC/Core/Opt/WorkWrap.hs
• compiler/GHC/Core/Opt/WorkWrap/Utils.hs
• compiler/GHC/Core/Ppr.hs
• compiler/GHC/Core/TyCo/Ppr.hs
• compiler/GHC/Core/TyCo/Rep.hs
• compiler/GHC/Core/TyCon.hs
• compiler/GHC/CoreToStg/Prep.hs
• compiler/GHC/Data/FastString.hs
• compiler/GHC/Data/StringBuffer.hs
• compiler/GHC/Driver/Backend.hs
• compiler/GHC/Driver/CodeOutput.hs
• compiler/GHC/Driver/Config/StgToCmm.hs
• compiler/GHC/Driver/DynFlags.hs
• compiler/GHC/Driver/Errors/Ppr.hs
• compiler/GHC/Driver/Flags.hs
• compiler/GHC/Driver/Main/Compile.hs
• compiler/GHC/Driver/Main/Hsc.hs
• compiler/GHC/Driver/Main/Passes.hs
• compiler/GHC/Driver/Pipeline.hs
• compiler/GHC/Driver/Session.hs
• compiler/GHC/Hs.hs
• compiler/GHC/Hs/Binds.hs
• compiler/GHC/Hs/Decls.hs
• compiler/GHC/Hs/Doc.hs
• − compiler/GHC/Hs/Doc.hs-boot
• compiler/GHC/Hs/DocString.hs
• compiler/GHC/Hs/Dump.hs
• compiler/GHC/Hs/Expr.hs
• compiler/GHC/Hs/Extension.hs
• + compiler/GHC/Hs/Extension/Pass.hs
• compiler/GHC/Hs/ImpExp.hs
• compiler/GHC/Hs/Instances.hs
• compiler/GHC/Hs/Lit.hs
• compiler/GHC/Hs/Type.hs
• compiler/GHC/Hs/Utils.hs
• compiler/GHC/HsToCore.hs
• compiler/GHC/HsToCore/Breakpoints.hs
• + compiler/GHC/HsToCore/Breakpoints/Types.hs
• compiler/GHC/HsToCore/Docs.hs
• compiler/GHC/HsToCore/Errors/Types.hs
• compiler/GHC/HsToCore/Expr.hs
• compiler/GHC/HsToCore/Foreign/C.hs
• compiler/GHC/HsToCore/Foreign/JavaScript.hs
• compiler/GHC/HsToCore/Foreign/Wasm.hs
• compiler/GHC/HsToCore/Match.hs
• compiler/GHC/HsToCore/Match/Literal.hs
• compiler/GHC/HsToCore/Pmc/Desugar.hs
• compiler/GHC/HsToCore/Pmc/Solver/Types.hs
• compiler/GHC/HsToCore/Quote.hs
• compiler/GHC/HsToCore/Ticks.hs
• compiler/GHC/Iface/Ext/Ast.hs
• compiler/GHC/Iface/Load.hs
• compiler/GHC/Iface/Make.hs
• compiler/GHC/Iface/Recomp.hs
• compiler/GHC/Iface/Syntax.hs
• compiler/GHC/Parser.y
• compiler/GHC/Parser/Annotation.hs
• compiler/GHC/Parser/Errors/Ppr.hs
• compiler/GHC/Parser/HaddockLex.x
• compiler/GHC/Parser/Lexer.x
• compiler/GHC/Parser/PostProcess.hs
• compiler/GHC/Parser/PostProcess/Haddock.hs
• compiler/GHC/Parser/Types.hs
• compiler/GHC/Platform/Ways.hs
• compiler/GHC/Rename/Bind.hs
• compiler/GHC/Rename/Doc.hs
• compiler/GHC/Rename/Env.hs
• compiler/GHC/Rename/Expr.hs
• compiler/GHC/Rename/HsType.hs
• compiler/GHC/Rename/Module.hs
• compiler/GHC/Rename/Names.hs
• compiler/GHC/Rename/Splice.hs
• compiler/GHC/Rename/Utils.hs
• compiler/GHC/Runtime/Eval.hs
• compiler/GHC/StgToByteCode.hs
• compiler/GHC/StgToCmm/Bind.hs
• compiler/GHC/StgToCmm/Config.hs
• compiler/GHC/StgToCmm/Foreign.hs
• compiler/GHC/StgToCmm/Prim.hs
• compiler/GHC/StgToJS/FFI.hs
• compiler/GHC/Tc/Deriv.hs
• compiler/GHC/Tc/Deriv/Generate.hs
• compiler/GHC/Tc/Deriv/Generics.hs
• compiler/GHC/Tc/Errors.hs
• compiler/GHC/Tc/Errors/Hole.hs
• compiler/GHC/Tc/Errors/Hole/FitTypes.hs
• compiler/GHC/Tc/Errors/Ppr.hs
• compiler/GHC/Tc/Gen/Arrow.hs
• compiler/GHC/Tc/Gen/Bind.hs
• compiler/GHC/Tc/Gen/Do.hs
• compiler/GHC/Tc/Gen/Expr.hs
• compiler/GHC/Tc/Gen/Head.hs
• compiler/GHC/Tc/Gen/HsType.hs
• compiler/GHC/Tc/Gen/Match.hs
• compiler/GHC/Tc/Gen/Pat.hs
• compiler/GHC/Tc/Gen/Sig.hs
• compiler/GHC/Tc/Gen/Splice.hs
• compiler/GHC/Tc/Instance/Class.hs
• compiler/GHC/Tc/Module.hs
• compiler/GHC/Tc/Solver/Dict.hs
• compiler/GHC/Tc/TyCl.hs
• compiler/GHC/Tc/TyCl/PatSyn.hs
• compiler/GHC/Tc/TyCl/Utils.hs
• compiler/GHC/Tc/Types/Origin.hs
• compiler/GHC/Tc/Types/Rank.hs
• compiler/GHC/Tc/Validity.hs
• compiler/GHC/ThToHs.hs
• compiler/GHC/Types/Basic.hs
• compiler/GHC/Types/Error.hs
• compiler/GHC/Types/FieldLabel.hs
• compiler/GHC/Types/ForeignCall.hs
• compiler/GHC/Types/Literal.hs
• compiler/GHC/Unit/Module/ModGuts.hs
• compiler/GHC/Unit/Module/ModIface.hs
• compiler/GHC/Unit/Module/Warnings.hs
• compiler/GHC/Unit/Module/WholeCoreBindings.hs
• compiler/GHC/Utils/Binary.hs
• compiler/GHC/Utils/Outputable.hs
• compiler/Language/Haskell/Syntax.hs
• compiler/Language/Haskell/Syntax/Basic.hs
• compiler/Language/Haskell/Syntax/Binds.hs
• compiler/Language/Haskell/Syntax/Decls.hs
• compiler/Language/Haskell/Syntax/Decls/Foreign.hs
• + compiler/Language/Haskell/Syntax/Doc.hs
• compiler/Language/Haskell/Syntax/Expr.hs
• compiler/Language/Haskell/Syntax/Expr.hs-boot
• compiler/Language/Haskell/Syntax/Extension.hs
• compiler/Language/Haskell/Syntax/ImpExp.hs
• compiler/Language/Haskell/Syntax/Lit.hs
• compiler/Language/Haskell/Syntax/Module/Name.hs
• + compiler/Language/Haskell/Syntax/Text.hs
• compiler/Language/Haskell/Syntax/Type.hs
• − compiler/Language/Haskell/Syntax/Type.hs-boot
• compiler/ghc.cabal.in
• docs/users_guide/eventlog-formats.rst
• docs/users_guide/expected-undocumented-flags.txt
• docs/users_guide/exts/rank_polymorphism.rst
• docs/users_guide/exts/static_pointers.rst
• docs/users_guide/using-optimisation.rst
• ghc/GHCi/UI.hs
• hadrian/bindist/Makefile
• hadrian/cabal.project
• hadrian/src/Rules.hs
• hadrian/src/Rules/BinaryDist.hs
• hadrian/src/Settings/Warnings.hs
• libraries/base/changelog.md
• libraries/base/src/System/Environment.hs
• libraries/base/tests/T15349.stderr
• libraries/base/tests/all.T
• libraries/ghc-boot/GHC/Data/ShortText.hs
• + libraries/ghc-heap/tests/T27465.hs
• + libraries/ghc-heap/tests/T27465.stdout
• libraries/ghc-heap/tests/all.T
• libraries/ghc-internal/ghc-internal.cabal.in
• libraries/ghc-internal/src/GHC/Internal/Conc/Sync.hs
• libraries/ghc-internal/src/GHC/Internal/Exception/Type.hs
• libraries/ghc-internal/src/GHC/Internal/Heap/InfoTable.hsc
• libraries/ghc-internal/src/GHC/Internal/Heap/InfoTableProf.hsc
• libraries/ghc-internal/tests/backtraces/T14532b.stdout
• libraries/semaphore-compat
• nofib
• rts/Apply.cmm
• rts/Capability.c
• rts/Capability.h
• rts/ContinuationOps.cmm
• rts/IOManager.c
• rts/IOManager.h
• rts/Messages.c
• rts/PrimOps.cmm
• rts/RaiseAsync.c
• rts/RaiseAsync.h
• rts/RtsStartup.c
• rts/STM.c
• rts/Schedule.c
• rts/StgMiscClosures.cmm
• rts/Threads.c
• rts/Ticker.h
• rts/Timer.c
• rts/Timer.h
• rts/Trace.c
• rts/Trace.h
• rts/TraverseHeap.c
• rts/include/Cmm.h
• rts/include/rts/Constants.h
• rts/include/rts/EventLogFormat.h
• rts/include/rts/Timer.h
• rts/include/rts/storage/TSO.h
• rts/include/stg/MiscClosures.h
• rts/posix/Poll.c
• rts/posix/Select.c
• rts/posix/Ticker.c
• rts/posix/Timeout.c
• rts/sm/Compact.c
• rts/sm/GC.c
• rts/sm/NonMovingMark.c
• rts/sm/Sanity.c
• rts/sm/Scav.c
• rts/win32/AsyncMIO.c
• rts/win32/Ticker.c
• testsuite/driver/junit.py
• testsuite/driver/perf_notes.py
• testsuite/driver/testglobals.py
• testsuite/driver/testlib.py
• testsuite/driver/testutil.py
• testsuite/tests/arityanal/should_compile/T21755.stderr
• testsuite/tests/arityanal/should_compile/all.T
• testsuite/tests/backpack/should_compile/T13149.bkp
• testsuite/tests/bytecode/TLinkable/all.T
• testsuite/tests/cmm/should_compile/all.T
• testsuite/tests/cmm/should_run/AtomicFetch.hs
• testsuite/tests/cmm/should_run/AtomicFetch_cmm.cmm
• testsuite/tests/codeGen/should_compile/T25177.stderr
• testsuite/tests/codeGen/should_run/cgrun025.stderr
• + testsuite/tests/concurrent/should_run/T27105.hs
• testsuite/tests/concurrent/should_run/all.T
• testsuite/tests/core-to-stg/T25284/Cls.hs
• + testsuite/tests/core-to-stg/T25924/B.hs
• + testsuite/tests/core-to-stg/T25924/Main.hs
• + testsuite/tests/core-to-stg/T25924/all.T
• + testsuite/tests/core-to-stg/T25924a.hs
• + testsuite/tests/core-to-stg/T25924a.stdout
• testsuite/tests/core-to-stg/all.T
• testsuite/tests/count-deps/CountDepsAst.stdout
• testsuite/tests/count-deps/CountDepsParser.stdout
• testsuite/tests/deSugar/should_fail/all.T
• testsuite/tests/deSugar/should_run/all.T
• testsuite/tests/deriving/should_compile/all.T
• testsuite/tests/determinism/determ017/A.hs
• testsuite/tests/dmdanal/should_compile/T18982.stderr
• testsuite/tests/driver/options_ghc/Mod_fbyte_code.hs
• testsuite/tests/driver/options_ghc/all.T
• testsuite/tests/driver/options_ghc/options_ghc_fbyte-code.stderr
• testsuite/tests/exceptions/T26759.stderr
• testsuite/tests/generics/GenDerivOutput.hs
• testsuite/tests/generics/GenDerivOutput1_0.hs
• testsuite/tests/generics/GenDerivOutput1_1.hs
• testsuite/tests/generics/T10604/T10604_deriving.hs
• testsuite/tests/generics/T10604/all.T
• testsuite/tests/generics/all.T
• testsuite/tests/ghc-api/T25121_status.stdout
• testsuite/tests/ghc-api/annotations-literals/parsed.hs
• testsuite/tests/ghc-api/exactprint/T22919.stderr
• testsuite/tests/ghc-api/exactprint/Test20239.stderr
• testsuite/tests/ghc-api/exactprint/ZeroWidthSemi.stderr
• testsuite/tests/ghc-e/should_fail/T18441fail7.stderr
• testsuite/tests/ghci/scripts/T12005.script
• testsuite/tests/ghci/scripts/all.T
• + testsuite/tests/ghci/scripts/bytecodeIPE.hs
• + testsuite/tests/ghci/scripts/bytecodeIPE.script
• + testsuite/tests/ghci/scripts/bytecodeIPE.stdout
• testsuite/tests/ghci/should_run/Makefile
• + testsuite/tests/ghci/should_run/T27287.hs
• + testsuite/tests/ghci/should_run/T27287.stdout
• testsuite/tests/ghci/should_run/all.T
• testsuite/tests/haddock/perf/Fold.hs
• testsuite/tests/haddock/should_compile_flag_haddock/T17544.stderr
• testsuite/tests/haddock/should_compile_flag_haddock/T17544_kw.stderr
• testsuite/tests/haddock/should_compile_flag_haddock/T24221.stderr
• testsuite/tests/indexed-types/should_fail/T7354.hs
• testsuite/tests/interface-stability/base-exports.stdout
• testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs
• testsuite/tests/interface-stability/base-exports.stdout-mingw32
• testsuite/tests/layout/layout001.stdout
• testsuite/tests/layout/layout002.stdout
• testsuite/tests/layout/layout003.stdout
• testsuite/tests/layout/layout004.stdout
• testsuite/tests/layout/layout005.stdout
• testsuite/tests/layout/layout006.stdout
• testsuite/tests/layout/layout007.stdout
• testsuite/tests/layout/layout008.stdout
• testsuite/tests/layout/layout009.stdout
• testsuite/tests/linear/should_compile/T1735Min.hs
• testsuite/tests/mdo/should_fail/mdofail006.stderr
• testsuite/tests/module/mod185.stderr
• testsuite/tests/numeric/should_compile/T15547.stderr
• testsuite/tests/parser/should_compile/DumpParsedAst.stderr
• testsuite/tests/parser/should_compile/DumpParsedAstComments.stderr
• testsuite/tests/parser/should_compile/DumpRenamedAst.stderr
• testsuite/tests/parser/should_compile/DumpSemis.stderr
• testsuite/tests/parser/should_compile/DumpTypecheckedAst.stderr
• testsuite/tests/parser/should_compile/KindSigs.stderr
• + testsuite/tests/parser/should_compile/T13087.stderr
• testsuite/tests/parser/should_compile/T14189.stderr
• testsuite/tests/parser/should_compile/T15279.stderr
• testsuite/tests/parser/should_compile/T15323.stderr
• testsuite/tests/parser/should_compile/T20452.stderr
• testsuite/tests/parser/should_compile/T20718.stderr
• testsuite/tests/parser/should_compile/T20718b.stderr
• testsuite/tests/parser/should_compile/T20846.stderr
• testsuite/tests/parser/should_compile/T23315/T23315.stderr
• testsuite/tests/parser/should_compile/all.T
• testsuite/tests/parser/should_fail/T8431.stderr
• testsuite/tests/parser/should_fail/readFail038.stderr
• + testsuite/tests/parser/should_run/StringStartsWithNull.hs
• + testsuite/tests/parser/should_run/StringStartsWithNull.stdout
• testsuite/tests/parser/should_run/all.T
• testsuite/tests/perf/compiler/T3064.hs
• testsuite/tests/perf/compiler/all.T
• testsuite/tests/perf/compiler/hard_hole_fits.stderr
• + testsuite/tests/pmcheck/should_compile/T27360.hs
• testsuite/tests/pmcheck/should_compile/all.T
• testsuite/tests/polykinds/T7594.hs
• testsuite/tests/printer/AnnotationNoListTuplePuns.stdout
• testsuite/tests/printer/T18052a.stderr
• testsuite/tests/printer/T18791.stderr
• testsuite/tests/printer/Test20297.stdout
• testsuite/tests/printer/Test24533.stdout
• testsuite/tests/printer/all.T
• testsuite/tests/profiling/perf/T23103/all.T
• testsuite/tests/profiling/should_run/all.T
• testsuite/tests/programs/thurston-modular-arith/Main.hs
• testsuite/tests/rts/T17574.hs
• testsuite/tests/rts/T19381.hs
• + testsuite/tests/rts/T27123.hs
• testsuite/tests/rts/all.T
• testsuite/tests/rts/ipe/IpeStats/Fold.hs
• testsuite/tests/rts/ipe/T24005/all.T
• testsuite/tests/runghc/T7859.stderr-mingw32
• testsuite/tests/showIface/DocsInHiFile1.stdout
• testsuite/tests/showIface/HaddockSpanIssueT24378.stdout
• testsuite/tests/showIface/MagicHashInHaddocks.stdout
• testsuite/tests/showIface/NoExportList.stdout
• testsuite/tests/simplCore/should_compile/DataToTagFamilyScrut.stderr
• testsuite/tests/simplCore/should_compile/T11562.hs
• testsuite/tests/simplCore/should_compile/T14978.stdout
• testsuite/tests/simplCore/should_compile/T18013.stderr
• testsuite/tests/simplCore/should_compile/T24229a.stderr
• testsuite/tests/simplCore/should_compile/T24229b.stderr
• testsuite/tests/simplCore/should_compile/T26615.stderr
• testsuite/tests/simplCore/should_compile/all.T
• testsuite/tests/simplCore/should_run/T3591.hs
• testsuite/tests/typecheck/should_compile/DeepSubsumption02.hs
• testsuite/tests/typecheck/should_compile/T12507.hs
• testsuite/tests/typecheck/should_compile/T13951.hs
• testsuite/tests/typecheck/should_compile/T15242.stderr
• testsuite/tests/typecheck/should_compile/T18920.hs
• testsuite/tests/typecheck/should_compile/T2595.hs
• testsuite/tests/typecheck/should_compile/T7541.hs
• testsuite/tests/typecheck/should_compile/all.T
• testsuite/tests/typecheck/should_fail/T6069.stderr
• testsuite/tests/typecheck/should_fail/T7368a.hs
• testsuite/tests/typecheck/should_run/T1735_Help/Basics.hs
• testsuite/tests/typecheck/should_run/T3731-short.hs
• testsuite/tests/typecheck/should_run/T3731.hs
• testsuite/tests/typecheck/should_run/church.hs
• testsuite/tests/typecheck/should_run/tcrun008.hs
• testsuite/tests/typecheck/should_run/tcrun017.hs
• testsuite/tests/typecheck/should_run/tcrun026.hs
• testsuite/tests/typecheck/should_run/tcrun035.hs
• testsuite/tests/typecheck/should_run/tcrun036.hs
• utils/check-exact/ExactPrint.hs
• utils/check-exact/Main.hs
• utils/check-exact/Transform.hs
• utils/check-exact/Utils.hs
• utils/check-exact/check-exact.cabal
• utils/haddock/haddock-api/haddock-api.cabal
• utils/haddock/haddock-api/src/Haddock/Backends/Hyperlinker/Parser.hs
• utils/haddock/haddock-api/src/Haddock/Backends/LaTeX.hs
• utils/haddock/haddock-api/src/Haddock/Backends/Xhtml/Decl.hs
• utils/haddock/haddock-api/src/Haddock/Convert.hs
• utils/haddock/haddock-api/src/Haddock/Interface/Create.hs
• utils/haddock/haddock-api/src/Haddock/Interface/LexParseRn.hs
• utils/haddock/haddock-api/src/Haddock/Interface/Rename.hs
• utils/haddock/haddock-api/src/Haddock/Types.hs

The diff was not included because it is too large.