Simon Peyton Jones pushed to branch wip/T19001 at Glasgow Haskell Compiler / GHC

Commits:

• aeafdba5
  by Sebastian Graf at 2022-09-27T15:14:54+02:00

  Demand: Clear distinction between Call SubDmd and eval Dmd (#21717)
  
  In #21717 we saw a reportedly unsound strictness signature due to an unsound
  definition of plusSubDmd on Calls. This patch contains a description and the fix
  to the unsoundness as outlined in `Note [Call SubDemand vs. evaluation Demand]`.
  
  This fix means we also get rid of the special handling of `-fpedantic-bottoms`
  in eta-reduction. Thanks to less strict and actually sound strictness results,
  we will no longer eta-reduce the problematic cases in the first place, even
  without `-fpedantic-bottoms`.
  
  So fixing the unsoundness also makes our eta-reduction code simpler with less
  hacks to explain. But there is another, more unfortunate side-effect:
  We *unfix* #21085, but fortunately we have a new fix ready:
  See `Note [mkCall and plusSubDmd]`.
  
  There's another change:
  I decided to make `Note [SubDemand denotes at least one evaluation]` a lot
  simpler by using `plusSubDmd` (instead of `lubPlusSubDmd`) even if both argument
  demands are lazy. That leads to less precise results, but in turn rids ourselves
  from the need for 4 different `OpMode`s and the complication of
  `Note [Manual specialisation of lub*Dmd/plus*Dmd]`. The result is simpler code
  that is in line with the paper draft on Demand Analysis.
  
  I left the abandoned idea in `Note [Unrealised opportunity in plusDmd]` for
  posterity. The fallout in terms of regressions is negligible, as the testsuite
  and NoFib shows.
  
  ```
          Program         Allocs    Instrs
  --------------------------------------------------------------------------------
           hidden          +0.2%     -0.2%
           linear          -0.0%     -0.7%
  --------------------------------------------------------------------------------
              Min          -0.0%     -0.7%
              Max          +0.2%     +0.0%
   Geometric Mean          +0.0%     -0.0%
  ```
  
  Fixes #21717.
  

• 9b1595c8
  by Ross Paterson at 2022-09-27T14:12:01-04:00

  implement proposal 106 (Define Kinds Without Promotion) (fixes #6024)
  
  includes corresponding changes to haddock submodule
  

• c2d73cb4
  by Andreas Klebinger at 2022-09-28T15:07:30-04:00

  Apply some tricks to speed up core lint.
  
  Below are the noteworthy changes and if given their impact on compiler
  allocations for a type heavy module:
  
  * Use the oneShot trick on LintM
  * Use a unboxed tuple for the result of LintM: ~6% reduction
  * Avoid a thunk for the result of typeKind in lintType: ~5% reduction
  * lint_app: Don't allocate the error msg in the hot code path: ~4%
    reduction
  * lint_app: Eagerly force the in scope set: ~4%
  * nonDetCmpType: Try to short cut using reallyUnsafePtrEquality#: ~2%
  * lintM: Use a unboxed maybe for the `a` result: ~12%
  * lint_app: make go_app tail recursive to avoid allocating the go function
              as heap closure: ~7%
  * expandSynTyCon_maybe: Use a specialized data type
  
  For a less type heavy module like nofib/spectral/simple compiled with
  -O -dcore-lint allocations went down by ~24% and compile time by ~9%.
  
  -------------------------
  Metric Decrease:
      T1969
  -------------------------
  

• b74b6191
  by sheaf at 2022-09-28T15:08:10-04:00

  matchLocalInst: do domination analysis
  
  When multiple Given quantified constraints match a Wanted, and there is
  a quantified constraint that dominates all others, we now pick it
  to solve the Wanted.
  
  See Note [Use only the best matching quantified constraint].
  
  For example:
  
    [G] d1: forall a b. ( Eq a, Num b, C a b  ) => D a b
    [G] d2: forall a  .                C a Int  => D a Int
    [W] {w}: D a Int
  
  When solving the Wanted, we find that both Givens match, but we pick
  the second, because it has a weaker precondition, C a Int, compared
  to (Eq a, Num Int, C a Int). We thus say that d2 dominates d1;
  see Note [When does a quantified instance dominate another?].
  
  This domination test is done purely in terms of superclass expansion,
  in the function GHC.Tc.Solver.Interact.impliedBySCs. We don't attempt
  to do a full round of constraint solving; this simple check suffices
  for now.
  
  Fixes #22216 and #22223
  

• 2a53ac18
  by Simon Peyton Jones at 2022-09-28T17:49:09-04:00

  Improve aggressive specialisation
  
  This patch fixes #21286, by not unboxing dictionaries in
  worker/wrapper (ever). The main payload is tiny:
  
  * In `GHC.Core.Opt.DmdAnal.finaliseArgBoxities`, do not unbox
    dictionaries in `get_dmd`.  See Note [Do not unbox class dictionaries]
    in that module
  
  * I also found that imported wrappers were being fruitlessly
    specialised, so I fixed that too, in canSpecImport.
    See Note [Specialising imported functions] point (2).
  
  In doing due diligence in the testsuite I fixed a number of
  other things:
  
  * Improve Note [Specialising unfoldings] in GHC.Core.Unfold.Make,
    and Note [Inline specialisations] in GHC.Core.Opt.Specialise,
    and remove duplication between the two. The new Note describes
    how we specialise functions with an INLINABLE pragma.
  
    And simplify the defn of `spec_unf` in `GHC.Core.Opt.Specialise.specCalls`.
  
  * Improve Note [Worker/wrapper for INLINABLE functions] in
    GHC.Core.Opt.WorkWrap.
  
    And (critially) make an actual change which is to propagate the
    user-written pragma from the original function to the wrapper; see
    `mkStrWrapperInlinePrag`.
  
  * Write new Note [Specialising imported functions] in
    GHC.Core.Opt.Specialise
  
  All this has a big effect on some compile times. This is
  compiler/perf, showing only changes over 1%:
  
  Metrics: compile_time/bytes allocated
  -------------------------------------
                  LargeRecord(normal)  -50.2% GOOD
             ManyConstructors(normal)   +1.0%
  MultiLayerModulesTH_OneShot(normal)   +2.6%
                    PmSeriesG(normal)   -1.1%
                       T10547(normal)   -1.2%
                       T11195(normal)   -1.2%
                       T11276(normal)   -1.0%
                      T11303b(normal)   -1.6%
                       T11545(normal)   -1.4%
                       T11822(normal)   -1.3%
                       T12150(optasm)   -1.0%
                       T12234(optasm)   -1.2%
                       T13056(optasm)   -9.3% GOOD
                       T13253(normal)   -3.8% GOOD
                       T15164(normal)   -3.6% GOOD
                       T16190(normal)   -2.1%
                       T16577(normal)   -2.8% GOOD
                       T16875(normal)   -1.6%
                       T17836(normal)   +2.2%
                      T17977b(normal)   -1.0%
                       T18223(normal)  -33.3% GOOD
                       T18282(normal)   -3.4% GOOD
                       T18304(normal)   -1.4%
                      T18698a(normal)   -1.4% GOOD
                      T18698b(normal)   -1.3% GOOD
                       T19695(normal)   -2.5% GOOD
                        T5837(normal)   -2.3%
                        T9630(normal)  -33.0% GOOD
                        WWRec(normal)   -9.7% GOOD
               hard_hole_fits(normal)   -2.1% GOOD
                       hie002(normal)   +1.6%
  
                            geo. mean   -2.2%
                            minimum    -50.2%
                            maximum     +2.6%
  
  I diligently investigated some of the big drops.
  
  * Caused by not doing w/w for dictionaries:
      T13056, T15164, WWRec, T18223
  
  * Caused by not fruitlessly specialising wrappers
      LargeRecord, T9630
  
  For runtimes, here is perf/should+_run:
  
  Metrics: runtime/bytes allocated
  --------------------------------
                 T12990(normal)   -3.8%
                  T5205(normal)   -1.3%
                  T9203(normal)  -10.7% GOOD
          haddock.Cabal(normal)   +0.1%
           haddock.base(normal)   -1.1%
       haddock.compiler(normal)   -0.3%
          lazy-bs-alloc(normal)   -0.2%
  ------------------------------------------
                      geo. mean   -0.3%
                      minimum    -10.7%
                      maximum     +0.1%
  
  I did not investigate exactly what happens in T9203.
  
  Nofib is a wash:
  
  +-------------------------------++--+-----------+-----------+
  |                               ||  | tsv (rel) | std. err. |
  +===============================++==+===========+===========+
  |                     real/anna ||  |    -0.13% |      0.0% |
  |                      real/fem ||  |    +0.13% |      0.0% |
  |                   real/fulsom ||  |    -0.16% |      0.0% |
  |                     real/lift ||  |    -1.55% |      0.0% |
  |                  real/reptile ||  |    -0.11% |      0.0% |
  |                  real/smallpt ||  |    +0.51% |      0.0% |
  |          spectral/constraints ||  |    +0.20% |      0.0% |
  |               spectral/dom-lt ||  |    +1.80% |      0.0% |
  |               spectral/expert ||  |    +0.33% |      0.0% |
  +===============================++==+===========+===========+
  |                     geom mean ||  |           |           |
  +-------------------------------++--+-----------+-----------+
  
  I spent quite some time investigating dom-lt, but it's pretty
  complicated.  See my note on !7847.  Conclusion: it's just a delicate
  inlining interaction, and we have plenty of those.
  
  Metric Decrease:
      LargeRecord
      T13056
      T13253
      T15164
      T16577
      T18223
      T18282
      T18698a
      T18698b
      T19695
      T9630
      WWRec
      hard_hole_fits
      T9203
  

• addeefc0
  by Simon Peyton Jones at 2022-09-28T17:49:09-04:00

  Refactor UnfoldingSource and IfaceUnfolding
  
  I finally got tired of the way that IfaceUnfolding reflected
  a previous structure of unfoldings, not the current one. This
  MR refactors UnfoldingSource and IfaceUnfolding to be simpler
  and more consistent.
  
  It's largely just a refactor, but in UnfoldingSource (which moves
  to GHC.Types.Basic, since it is now used in IfaceSyn too), I
  distinguish between /user-specified/ and /system-generated/ stable
  unfoldings.
  
      data UnfoldingSource
        = VanillaSrc
        | StableUserSrc   -- From a user-specified pragma
        | StableSystemSrc -- From a system-generated unfolding
        | CompulsorySrc
  
  This has a minor effect in CSE (see the use of isisStableUserUnfolding
  in GHC.Core.Opt.CSE), which I tripped over when working on
  specialisation, but it seems like a Good Thing to know anyway.
  

• 7be6f9a4
  by Simon Peyton Jones at 2022-09-28T17:49:09-04:00

  INLINE/INLINEABLE pragmas in Foreign.Marshal.Array
  
  Foreign.Marshal.Array contains many small functions, all of which are
  overloaded, and which are critical for performance. Yet none of them
  had pragmas, so it was a fluke whether or not they got inlined.
  
  This patch makes them all either INLINE (small ones) or
  INLINEABLE and hence specialisable (larger ones).
  
  See Note [Specialising array operations] in that module.
  

• b0c89dfa
  by Jade Lovelace at 2022-09-28T17:49:49-04:00

  Export OnOff from GHC.Driver.Session
  
  I was working on fixing an issue where HLS was trying to pass its
  DynFlags to HLint, but didn't pass any of the disabled language
  extensions, which HLint would then assume are on because of their
  default values.
  
  Currently it's not possible to get any of the "No" flags because the
  `DynFlags.extensions` field can't really be used since it is [OnOff
  Extension] and OnOff is not exported.
  
  So let's export it.
  

• 2f050687
  by Andrew Lelechenko at 2022-09-28T17:50:28-04:00

  Avoid Data.List.group; prefer Data.List.NonEmpty.group
  
  This allows to avoid further partiality, e. g., map head . group is
  replaced by map NE.head . NE.group, and there are less panic calls.
  

• bc0020fa
  by M Farkas-Dyck at 2022-09-28T22:51:59-04:00

  Clean up `findWiredInUnit`. In particular, avoid `head`.
  

• 6a2eec98
  by Andrew Lelechenko at 2022-09-28T22:52:38-04:00

  Eliminate headFS, use unconsFS instead
  
  A small step towards #22185 to avoid partial functions + safe implementation
  of `startsWithUnderscore`.
  

• 5a535172
  by Sebastian Graf at 2022-09-29T17:04:20+02:00

  Demand: Format Call SubDemands `Cn(sd)` as `C(n,sd)` (#22231)
  
  Justification in #22231. Short form: In a demand like `1C1(C1(L))`
  it was too easy to confuse which `1` belongs to which `C`. Now
  that should be more obvious.
  
  Fixes #22231
  

• ea0083bf
  by Bryan Richter at 2022-09-29T15:48:38-04:00

  Revert "ci: enable parallel compression for xz"
  
  Combined wxth XZ_OPT=9, this blew the memory capacity of CI runners.
  
  This reverts commit a5f9c35f5831ef5108e87813a96eac62803852ab.
  

• f5e8f493
  by Sebastian Graf at 2022-09-30T18:42:13+02:00

  Boxity: Don't update Boxity unless worker/wrapper follows (#21754)
  
  A small refactoring in our Core Opt pipeline and some new functions for
  transfering argument boxities from one signature to another to facilitate
  `Note [Don't change boxity without worker/wrapper]`.
  
  Fixes #21754.
  

• 4baf7b1c
  by M Farkas-Dyck at 2022-09-30T17:45:47-04:00

  Scrub various partiality involving empty lists.
  
  Avoids some uses of `head` and `tail`, and some panics when an argument is null.
  

• 95ead839
  by Alexis King at 2022-10-01T00:37:43-04:00

  Fix a bug in continuation capture across multiple stack chunks
  

• 22096652
  by Andrew Lelechenko at 2022-10-01T00:38:22-04:00

  Enforce internal invariant of OrdList and fix bugs in viewCons / viewSnoc
  
  `viewCons` used to ignore `Many` constructor completely, returning `VNothing`.
  `viewSnoc` violated internal invariant of `Many` being a non-empty list.
  

• 48ab9ca5
  by Nicolas Trangez at 2022-10-04T20:34:10-04:00

  chore: extend `.editorconfig` for C files
  

• b8df5c72
  by Brandon Chinn at 2022-10-04T20:34:46-04:00

  Fix docs for pattern synonyms

• 463ffe02
  by Oleg Grenrus at 2022-10-04T20:35:24-04:00

  Use sameByteArray# in sameByteArray
  

• fbe1e86e
  by Pierre Le Marre at 2022-10-05T15:58:43+02:00

  Minor fixes following Unicode 15.0.0 update
  
  - Fix changelog for Unicode 15.0.0
  - Fix the checksums of the downloaded Unicode files, in base's tool: "ucd2haskell".
  

• 8a31d02e
  by Cheng Shao at 2022-10-05T20:40:41-04:00

  rts: don't enforce aligned((8)) on 32-bit targets
  
  We simply need to align to the word size for pointer tagging to work. On
  32-bit targets, aligned((8)) is wasteful.
  

• 532de368
  by Ryan Scott at 2022-10-06T07:45:46-04:00

  Export symbolSing, SSymbol, and friends (CLC#85)
  
  This implements this Core Libraries Proposal:
  https://github.com/haskell/core-libraries-committee/issues/85
  
  In particular, it:
  
  1. Exposes the `symbolSing` method of `KnownSymbol`,
  2. Exports the abstract `SSymbol` type used in `symbolSing`, and
  3. Defines an API for interacting with `SSymbol`.
  
  This also makes corresponding changes for `natSing`/`KnownNat`/`SNat` and
  `charSing`/`KnownChar`/`SChar`. This fixes #15183 and addresses part (2)
  of #21568.
  

• d83a92e6
  by sheaf at 2022-10-07T07:36:30-04:00

  Remove mention of make from README.md
  

• 945e8e49
  by Andrew Lelechenko at 2022-10-10T17:13:31-04:00

  Add a newline before since pragma in Data.Array.Byte
  

• 44fcdb04
  by Vladislav Zavialov at 2022-10-10T17:14:06-04:00

  Parser/PostProcess: rename failOp* functions
  
  There are three functions named failOp* in the parser:
  	failOpNotEnabledImportQualifiedPost
  	failOpImportQualifiedTwice
  	failOpFewArgs
  Only the last one has anything to do with operators. The other two
  were named this way either by mistake or due to a misunderstanding of
  what "op" stands for. This small patch corrects this.
  

• 96d32ff2
  by Simon Peyton Jones at 2022-10-10T22:30:21+01:00

  Make rewrite rules "win" over inlining
  
  If a rewrite rule and a rewrite rule compete in the simplifier, this
  patch makes sure that the rewrite rule "win".  That is, in general
  a bit fragile, but it's a huge help when making specialisation work
  reliably, as #21851 and #22097 showed.
  
  The change is fairly straightforwad, and documented in
     Note [Rewrite rules and inlining]
  in GHC.Core.Opt.Simplify.Iteration.
  
  Compile-times change, up and down a bit -- in some cases because
  we get better specialisation.  But the payoff (more reliable
  specialisation) is large.
  
  Metrics: compile_time/bytes allocated
  -----------------------------------------------
      T10421(normal)   +3.7% BAD
     T10421a(normal)   +5.5%
      T13253(normal)   +1.3%
        T14052(ghci)   +1.8%
      T15304(normal)   -1.4%
      T16577(normal)   +3.1% BAD
      T17516(normal)   +2.3%
      T17836(normal)   -1.9%
      T18223(normal)   -1.8%
       T8095(normal)   -1.3%
       T9961(normal)   +2.5% BAD
  
           geo. mean   +0.0%
           minimum     -1.9%
           maximum     +5.5%
  
  Nofib results are (bytes allocated)
  
  +-------------------------------++----------+
  |                               ||tsv (rel) |
  +===============================++==========+
  |           imaginary/paraffins ||   +0.27% |
  |                imaginary/rfib ||   -0.04% |
  |                     real/anna ||   +0.02% |
  |                      real/fem ||   -0.04% |
  |                    real/fluid ||   +1.68% |
  |                   real/gamteb ||   -0.34% |
  |                       real/gg ||   +1.54% |
  |                   real/hidden ||   -0.01% |
  |                      real/hpg ||   -0.03% |
  |                    real/infer ||   -0.03% |
  |                   real/prolog ||   +0.02% |
  |                  real/veritas ||   -0.47% |
  |       shootout/fannkuch-redux ||   -0.03% |
  |         shootout/k-nucleotide ||   -0.02% |
  |               shootout/n-body ||   -0.06% |
  |        shootout/spectral-norm ||   -0.01% |
  |         spectral/cryptarithm2 ||   +1.25% |
  |             spectral/fibheaps ||  +18.33% |
  |           spectral/last-piece ||   -0.34% |
  +===============================++==========+
  |                     geom mean ||   +0.17% |
  
  There are extensive notes in !8897 about the regressions.
  Briefly
  
  * fibheaps: there was a very delicately balanced inlining that
    tipped over the wrong way after this change.
  
  * cryptarithm2 and paraffins are caused by #22274, which is
    a separate issue really.  (I.e. the right fix is *not* to
    make inlining "win" over rules.)
  
  So I'm accepting these changes
  
  Metric Increase:
      T10421
      T16577
      T9961
  

• ed4b5885
  by Joachim Breitner at 2022-10-10T23:16:11-04:00

  Utils.JSON: do not escapeJsonString in ToJson String instance
  
  as `escapeJsonString` is used in `renderJSON`, so the `JSString`
  constructor is meant to carry the unescaped string.
  

• fbb88740
  by Matthew Pickering at 2022-10-11T12:48:45-04:00

  Tidy implicit binds
  
  We want to put implicit binds into fat interface files, so the easiest
  thing to do seems to be to treat them uniformly with other binders.
  

• e058b138
  by Matthew Pickering at 2022-10-11T12:48:45-04:00

  Interface Files with Core Definitions
  
  This commit adds three new flags
  
  * -fwrite-if-simplified-core: Writes the whole core program into an interface
    file
  * -fbyte-code-and-object-code: Generate both byte code and object code
    when compiling a file
  * -fprefer-byte-code: Prefer to use byte-code if it's available when
    running TH splices.
  
  The goal for including the core bindings in an interface file is to be able to restart the compiler pipeline
  at the point just after simplification and before code generation. Once compilation is
  restarted then code can be created for the byte code backend.
  This can significantly speed up
  start-times for projects in GHCi. HLS already implements its own version of these extended interface
  files for this reason.
  
  Preferring to use byte-code means that we can avoid some potentially
  expensive code generation steps (see #21700)
  
  * Producing object code is much slower than producing bytecode, and normally you
    need to compile with `-dynamic-too` to produce code in the static and dynamic way, the
    dynamic way just for Template Haskell execution when using a dynamically linked compiler.
  
  * Linking many large object files, which happens once per splice, can be quite
    expensive compared to linking bytecode.
  
  And you can get GHC to compile the necessary byte code so
  `-fprefer-byte-code` has access to it by using
  `-fbyte-code-and-object-code`.
  
  Fixes #21067
  

• 9789ea8e
  by Matthew Pickering at 2022-10-11T12:48:45-04:00

  Teach -fno-code about -fprefer-byte-code
  
  This patch teachs the code generation logic of -fno-code about
  -fprefer-byte-code, so that if we need to generate code for a module
  which prefers byte code, then we generate byte code rather than object
  code.
  
  We keep track separately which modules need object code and which byte
  code and then enable the relevant code generation for each. Typically
  the option will be enabled globally so one of these sets should be empty
  and we will just turn on byte code or object code generation.
  
  We also fix the bug where we would generate code for a module which
  enables Template Haskell despite the fact it was unecessary.
  
  Fixes #22016
  

• caced757
  by Simon Peyton Jones at 2022-10-11T12:49:21-04:00

  Don't keep exit join points so much
  
  We were religiously keeping exit join points throughout, which
  had some bad effects (#21148, #22084).
  
  This MR does two things:
  
  * Arranges that exit join points are inhibited from inlining
    only in /one/ Simplifier pass (right after Exitification).
  
    See Note [Be selective about not-inlining exit join points]
    in GHC.Core.Opt.Exitify
  
    It's not a big deal, but it shaves 0.1% off compile times.
  
  * Inline used-once non-recursive join points very aggressively
    Given join j x = rhs in
          joinrec k y = ....j x....
  
    where this is the only occurrence of `j`, we want to inline `j`.
    (Unless sm_keep_exits is on.)
  
    See Note [Inline used-once non-recursive join points] in
    GHC.Core.Opt.Simplify.Utils
  
    This is just a tidy-up really.  It doesn't change allocation, but
    getting rid of a binding is always good.
  
  Very effect on nofib -- some up and down.
  

• 284cf387
  by Simon Peyton Jones at 2022-10-11T12:49:21-04:00

  Make SpecConstr bale out less often
  
  When doing performance debugging on #22084 / !8901, I found that the
  algorithm in SpecConstr.decreaseSpecCount was so aggressive that if
  there were /more/ specialisations available for an outer function,
  that could more or less kill off specialisation for an /inner/
  function.  (An example was in nofib/spectral/fibheaps.)
  
  This patch makes it a bit more aggressive, by dividing by 2, rather
  than by the number of outer specialisations.
  
  This makes the program bigger, temporarily:
  
     T19695(normal) ghc/alloc   +11.3% BAD
  
  because we get more specialisation.  But lots of other programs
  compile a bit faster and the geometric mean in perf/compiler
  is 0.0%.
  
  Metric Increase:
      T19695
  

• 66af1399
  by Cheng Shao at 2022-10-11T12:49:59-04:00

  CmmToC: emit explicit tail calls when the C compiler supports it
  
  Clang 13+ supports annotating a return statement using the musttail
  attribute, which guarantees that it lowers to a tail call if compilation
  succeeds.
  
  This patch takes advantage of that feature for the unregisterised code
  generator. The configure script tests availability of the musttail
  attribute, if it's available, the Cmm tail calls will become C tail
  calls that avoids the mini interpreter trampoline overhead. Nothing is
  affected if the musttail attribute is not supported.
  
  Clang documentation:
  https://clang.llvm.org/docs/AttributeReference.html#musttail
  

• 7f0decd5
  by Matthew Pickering at 2022-10-11T12:50:40-04:00

  Don't include BufPos in interface files
  
  Ticket #22162 pointed out that the build directory was leaking into the
  ABI hash of a module because the BufPos depended on the location of the
  build tree.
  
  BufPos is only used in GHC.Parser.PostProcess.Haddock, and the
  information doesn't need to be propagated outside the context of a
  module.
  
  Fixes #22162
  

• dce9f320
  by Cheng Shao at 2022-10-11T12:51:19-04:00

  CLabel: fix isInfoTableLabel
  
  isInfoTableLabel does not take Cmm info table into account. This patch is required for data section layout of wasm32 NCG to work.
  

• da679f2e
  by Andrew Lelechenko at 2022-10-11T18:02:59-04:00

  Extend documentation for Data.List, mostly wrt infinite lists
  

• 9c099387
  by jwaldmann at 2022-10-11T18:02:59-04:00

  Expand comment for Data.List.permutations

• d3863cb7
  by Andrew Lelechenko at 2022-10-11T18:03:37-04:00

  ByteArray# is unlifted, not unboxed
  

• f6260e8b
  by Ben Gamari at 2022-10-11T23:45:10-04:00

  rts: Add missing declaration of stg_noDuplicate
  

• 69ccec2c
  by Ben Gamari at 2022-10-11T23:45:10-04:00

  base: Move CString, CStringLen to GHC.Foreign
  

• f6e8feb4
  by Ben Gamari at 2022-10-11T23:45:10-04:00

  base: Move IPE helpers to GHC.InfoProv
  

• 866c736e
  by Ben Gamari at 2022-10-11T23:45:10-04:00

  rts: Refactor IPE tracing support
  

• 6b0d2022
  by Ben Gamari at 2022-10-11T23:45:10-04:00

  Refactor IPE initialization
  
  Here we refactor the representation of info table provenance information
  in object code to significantly reduce its size and link-time impact.
  Specifically, we deduplicate strings and represent them as 32-bit
  offsets into a common string table.
  
  In addition, we rework the registration logic to eliminate allocation
  from the registration path, which is run from a static initializer where
  things like allocation are technically undefined behavior (although it
  did previously seem to work). For similar reasons we eliminate lock
  usage from registration path, instead relying on atomic CAS.
  
  Closes #22077.
  

• 9b572d54
  by Ben Gamari at 2022-10-11T23:45:10-04:00

  Separate IPE source file from span
  
  The source file name can very often be shared across many IPE entries
  whereas the source coordinates are generally unique. Separate the two to
  exploit sharing of the former.
  

• 27978ceb
  by Krzysztof Gogolewski at 2022-10-11T23:45:46-04:00

  Make Cmm Lint messages use dump style
  
  Lint errors indicate an internal error in GHC, so it makes sense to use
  it instead of the user style. This is consistent with Core Lint and STG Lint:
  
  https://gitlab.haskell.org/ghc/ghc/-/blob/22096652/compiler/GHC/Core/Lint.hs#L429
  
  https://gitlab.haskell.org/ghc/ghc/-/blob/22096652/compiler/GHC/Stg/Lint.hs#L144
  
  Fixes #22218.
  

• 64a390d9
  by Bryan Richter at 2022-10-12T09:52:51+03:00

  Mark T7919 as fragile
  
  On x86_64-linux, T7919 timed out ~30 times during July 2022.
  
  And again ~30 times in September 2022.
  

• 481467a5
  by Ben Gamari at 2022-10-12T08:08:37-04:00

  rts: Don't hint inlining of appendToRunQueue
  
  These hints have resulted in compile-time warnings due to failed
  inlinings for quite some time. Moreover, it's quite unlikely that
  inlining them is all that beneficial given that they are rather sizeable
  functions.
  
  Resolves #22280.
  

• 81915089
  by Curran McConnell at 2022-10-12T16:32:26-04:00

  remove name shadowing
  

• 626652f7
  by Tamar Christina at 2022-10-12T16:33:13-04:00

  winio: do not re-translate input when handle is uncooked
  

• 5172789a
  by Charles Taylor at 2022-10-12T16:33:57-04:00

  Unrestricted OverloadedLabels (#11671)
  
  Implements GHC proposal:
  https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0170-unrestricted-overloadedlabels.rst
  

• ce293908
  by Andreas Klebinger at 2022-10-13T05:58:19-04:00

  Add a perf test for the generics code pattern from #21839.
  
  This code showed a strong shift between compile time (got worse) and
  run time (got a lot better) recently which is perfectly acceptable.
  
  However it wasn't clear why the compile time regression was happening
  initially so I'm adding this test to make it easier to track such changes
  in the future.
  

• 78ab7afe
  by Ben Gamari at 2022-10-13T05:58:56-04:00

  rts/linker: Consolidate initializer/finalizer handling
  
  Here we extend our treatment of initializer/finalizer priorities to
  include ELF and in so doing refactor things to share the implementation
  with PEi386. As well, I fix a subtle misconception of the ordering
  behavior for `.ctors`.
  
  Fixes #21847.
  

• 44692713
  by Ben Gamari at 2022-10-13T05:58:56-04:00

  rts/linker: Add support for .fini sections
  

• beebf546
  by Simon Hengel at 2022-10-13T05:59:37-04:00

  Update phases.rst
  
  (the name of the original source file is $1, not $2)

• eda6c05e
  by Finley McIlwaine at 2022-10-13T06:00:17-04:00

  Clearer error msg for newtype GADTs with defaulted kind
  
  When a newtype introduces GADT eq_specs due to a defaulted
  RuntimeRep, we detect this and print the error message with
  explicit kinds.
  
  This also refactors newtype type checking to use the new
  diagnostic infra.
  
  Fixes #21447
  

• 43ab435a
  by Pierre Le Marre at 2022-10-14T07:45:43-04:00

  Add standard Unicode case predicates isUpperCase and isLowerCase.
  
  These predicates use the standard Unicode case properties and are more intuitive than isUpper and isLower.
  
  Approved by CLC in https://github.com/haskell/core-libraries-committee/issues/90#issuecomment-1276649403.
  
  Fixes #14589
  

• aec5a443
  by Andrew Lelechenko at 2022-10-14T07:46:21-04:00

  Add type signatures in where-clause of Data.List.permutations
  
  The type of interleave' is very much revealing, otherwise it's extremely tough to decipher.
  

• ee0deb80
  by Ben Gamari at 2022-10-14T18:29:20-04:00

  rts: Use pthread_setname_np correctly on Darwin
  
  As noted in #22206, pthread_setname_np on Darwin only supports
  setting the name of the calling thread. Consequently we must introduce
  a trampoline which first sets the thread name before entering the thread
  entrypoint.

• 8eff62a4
  by Ben Gamari at 2022-10-14T18:29:57-04:00

  testsuite: Add test for #22282
  
  This will complement mpickering's more general port of foundation's
  numerical testsuite, providing a test for the specific case found
  in #22282.
  

• 62a55001
  by Ben Gamari at 2022-10-14T18:29:57-04:00

  ncg/aarch64: Fix sub-word sign extension yet again
  
  In adc7f108141a973b6dcb02a7836eed65d61230e8 we fixed a number of issues
  to do with sign extension in the AArch64 NCG found by ghc/test-primops>.
  However, this patch made a critical error, assuming that getSomeReg
  would allocate a fresh register for the result of its evaluation.
  However, this is not the case as `getSomeReg (CmmReg r) == r`.
  Consequently, any mutation of the register returned by `getSomeReg` may
  have unwanted side-effects on other expressions also mentioning `r`. In
  the fix listed above, this manifested as the registers containing the
  operands of binary arithmetic operations being incorrectly
  sign-extended. This resulted in #22282.
  
  Sadly, the rather simple structure of the tests generated
  by `test-primops` meant that this particular case was not exercised.
  Even more surprisingly, none of our testsuite caught this case.
  
  Here we fix this by ensuring that intermediate sign extension is
  performed in a fresh register.
  
  Fixes #22282.
  

• 54e41b16
  by Teo Camarasu at 2022-10-15T18:09:24+01:00

  rts: ensure we are below maxHeapSize after returning megablocks
  
  When the heap is heavily block fragmented the live byte size might be
  low while the memory usage is high. We want to ensure that heap overflow
  triggers in these cases.
  
  We do so by checking that we can return enough megablocks to
  under maxHeapSize at the end of GC.
  

• 29bb90db
  by Teo Camarasu at 2022-10-15T18:09:24+01:00

  rts: trigger a major collection if megablock usage exceeds maxHeapSize
  
  When the heap is suffering from block fragmentation, live bytes might be
  low while megablock usage is high.
  
  If megablock usage exceeds maxHeapSize, we want to trigger a major GC to
  try to recover some memory otherwise we will die from a heapOverflow at
  the end of the GC.
  
  Fixes #21927
  

• 4a4641ca
  by Teo Camarasu at 2022-10-15T18:11:29+01:00

  Add realease note for #21927
  

• c1e5719a
  by Sebastian Graf at 2022-10-17T11:58:46-04:00

  DmdAnal: Look through unfoldings of DataCon wrappers (#22241)
  
  Previously, the demand signature we computed upfront for a DataCon wrapper
  
  lacked boxity information and was much less precise than the demand transformer
  
  for the DataCon worker.
  
  In this patch we adopt the solution to look through unfoldings of DataCon
  
  wrappers during Demand Analysis, but still attach a demand signature for other
  
  passes such as the Simplifier.
  
  See `Note [DmdAnal for DataCon wrappers]` for more details.
  
  Fixes #22241.
  

• 8c72411d
  by Gergő Érdi at 2022-10-17T19:20:04-04:00

  Add `Enum (Down a)` instance that swaps `succ` and `pred`
  
  See https://github.com/haskell/core-libraries-committee/issues/51 for
  discussion. The key points driving the implementation are the following
  two ideas:
  
  * For the `Int` type, `comparing (complement @Int)` behaves exactly as
    an order-swapping `compare @Int`.
  * `enumFrom @(Down a)` can be implemented in terms of `enumFromThen @a`,
    if only the corner case of starting at the very end is handled specially
  

• d80ad2f4
  by Alan Zimmerman at 2022-10-17T19:20:40-04:00

  Update the check-exact infrastructure to match ghc-exactprint
  
  GHC tests the exact print annotations using the contents of
  utils/check-exact.
  
  The same functionality is provided via
  https://github.com/alanz/ghc-exactprint
  
  The latter was updated to ensure it works with all of the files on
  hackage when 9.2 was released, as well as updated to ensure users of
  the library could work properly (apply-refact, retrie, etc).
  
  This commit brings the changes from ghc-exactprint into
  GHC/utils/check-exact, adapting for the changes to master.
  
  Once it lands, it will form the basis for the 9.4 version of
  ghc-exactprint.
  
  See also discussion around this process at #21355
  

• 08ab5419
  by Andreas Klebinger at 2022-10-17T19:21:15-04:00

  Avoid allocating intermediate lists for non recursive bindings.
  
  We do so by having an explicit folding function that doesn't need to
  allocate intermediate lists first.
  
  Fixes #22196
  

• ff6275ef
  by Andreas Klebinger at 2022-10-17T19:21:52-04:00

  Testsuite: Add a new tables_next_to_code predicate.
  
  And use it to avoid T21710a failing on non-tntc archs.
  
  Fixes #22169
  

• abb82f38
  by Eric Lindblad at 2022-10-17T19:22:33-04:00

  example rewrite

• 39beb801
  by Eric Lindblad at 2022-10-17T19:22:33-04:00

  remove redirect

• 0d9fb651
  by Eric Lindblad at 2022-10-17T19:22:33-04:00

  use heredoc

• 0fa2d185
  by Matthew Pickering at 2022-10-17T19:23:10-04:00

  testsuite: Fix typo when setting llvm_ways
  
  Since 2014 llvm_ways has been set to [] so none of the tests which use
  only_ways(llvm_ways) have worked as expected.
  
  Hopefully the tests still pass with this typo fix!
  

• ced664a2
  by Krzysztof Gogolewski at 2022-10-17T19:23:10-04:00

  Fix T15155l not getting -fllvm
  

• 0ac60423
  by Andreas Klebinger at 2022-10-18T03:34:47-04:00

  Fix GHCis interaction with tag inference.
  
  I had assumed that wrappers were not inlined in interactive mode.
  Meaning we would always execute the compiled wrapper which properly
  takes care of upholding the strict field invariant.
  This turned out to be wrong. So instead we now run tag inference even
  when we generate bytecode. In that case only for correctness not
  performance reasons although it will be still beneficial for runtime
  in some cases.
  
  I further fixed a bug where GHCi didn't tag nullary constructors
  properly when used as arguments. Which caused segfaults when calling
  into compiled functions which expect the strict field invariant to
  be upheld.
  
  Fixes #22042 and #21083
  
  -------------------------
  Metric Increase:
      T4801
  
  Metric Decrease:
      T13035
  -------------------------
  

• 9ecd1ac0
  by M Farkas-Dyck at 2022-10-18T03:35:38-04:00

  Make `Functor` a superclass of `TrieMap`, which lets us derive the `map` functions.
  

• f60244d7
  by Ben Gamari at 2022-10-18T03:36:15-04:00

  configure: Bump minimum bootstrap GHC version
  
  Fixes #22245
  

• ba4bd4a4
  by Matthew Pickering at 2022-10-18T03:36:55-04:00

  Build System: Remove out-of-date comment about make build system
  
  Both make and hadrian interleave compilation of modules of different
  modules and don't respect the package boundaries. Therefore I just
  remove this comment which points out this "difference".
  
  Fixes #22253
  

• e1bbd368
  by Matthew Pickering at 2022-10-18T16:15:49+02:00

  Allow configuration of error message printing
  
  This MR implements the idea of #21731 that the printing of a diagnostic
  method should be configurable at the printing time.
  
  The interface of the `Diagnostic` class is modified from:
  
  ```
  class Diagnostic a where
    diagnosticMessage :: a -> DecoratedSDoc
    diagnosticReason  :: a -> DiagnosticReason
    diagnosticHints   :: a -> [GhcHint]
  ```
  
  to
  
  ```
  class Diagnostic a where
    type DiagnosticOpts a
    defaultDiagnosticOpts :: DiagnosticOpts a
    diagnosticMessage :: DiagnosticOpts a -> a -> DecoratedSDoc
    diagnosticReason  :: a -> DiagnosticReason
    diagnosticHints   :: a -> [GhcHint]
  ```
  
  and so each `Diagnostic` can implement their own configuration record
  which can then be supplied by a client in order to dictate how to print
  out the error message.
  
  At the moment this only allows us to implement #21722 nicely but in
  future it is more natural to separate the configuration of how much
  information we put into an error message and how much we decide to print
  out of it.
  
  Updates Haddock submodule
  

• 99dc3e3d
  by Matthew Pickering at 2022-10-18T16:15:53+02:00

  Add -fsuppress-error-contexts to disable printing error contexts in errors
  
  In many development environments, the source span is the primary means
  of seeing what an error message relates to, and the In the expression:
  and In an equation for: clauses are not particularly relevant. However,
  they can grow to be quite long, which can make the message itself both
  feel overwhelming and interact badly with limited-space areas.
  
  It's simple to implement this flag so we might as well do it and give
  the user control about how they see their messages.
  
  Fixes #21722
  

• 5b3a992f
  by Dai at 2022-10-19T10:45:45-04:00

  Add VecSlot for unboxed sums of SIMD vectors
  
  This patch adds the missing `VecRep` case to `primRepSlot` function and
  all the necessary machinery to carry this new `VecSlot` through code
  generation. This allows programs involving unboxed sums of SIMD vectors
  to be written and compiled.
  
  Fixes #22187
  

• 6d7d9181
  by sheaf at 2022-10-19T10:45:45-04:00

  Remove SIMD conversions
  
  This patch makes it so that packing/unpacking SIMD
  vectors always uses the right sized types, e.g.
  unpacking a Word16X4# will give a tuple of Word16#s.
  
  As a result, we can get rid of the conversion instructions
  that were previously required.
  
  Fixes #22296
  

• 3be48877
  by sheaf at 2022-10-19T10:45:45-04:00

  Cmm Lint: relax SIMD register assignment check
  
  As noted in #22297, SIMD vector registers can be used
  to store different kinds of values, e.g. xmm1 can be used
  both to store integer and floating point values.
  The Cmm type system doesn't properly account for this, so
  we weaken the Cmm register assignment lint check to only
  compare widths when comparing a vector type with its
  allocated vector register.
  

• f7b7a312
  by sheaf at 2022-10-19T10:45:45-04:00

  Disable some SIMD tests on non-X86 architectures
  

• 83638dce
  by M Farkas-Dyck at 2022-10-19T10:46:29-04:00

  Scrub various partiality involving lists (again).
  
  Lets us avoid some use of `head` and `tail`, and some panics.
  

• c3732c62
  by M Farkas-Dyck at 2022-10-19T10:47:13-04:00

  Enforce invariant of `ListBag` constructor.
  

• 488d3631
  by Andrew Lelechenko at 2022-10-19T10:47:52-04:00

  More precise types for fields of OverlappingInstances and UnsafeOverlap in TcSolverReportMsg
  
  It's clear from asserts in `GHC.Tc.Errors` that `overlappingInstances_matches`
  and `unsafeOverlapped` are supposed to be non-empty, and `unsafeOverlap_matches`
  contains a single instance, but these invariants are immediately lost afterwards
  and not encoded in types. This patch enforces the invariants by pattern matching
  and makes types more precise, avoiding asserts and partial functions such as `head`.
  

• 607ce263
  by sheaf at 2022-10-19T10:47:52-04:00

  Rename unsafeOverlap_matches -> unsafeOverlap_match in UnsafeOverlap

• 1fab9598
  by Matthew Pickering at 2022-10-19T10:48:29-04:00

  Add SpliceTypes test for hie files
  
  This test checks that typed splices and quotes get the right type
  information when used in hiefiles.
  
  See #21619
  

• a8b52786
  by Jan Hrček at 2022-10-19T10:49:09-04:00

  Small language fixes in 'Using GHC'
  

• 1dab1167
  by Gergő Érdi at 2022-10-19T10:49:51-04:00

  Fix typo in `Opt_WriteIfSimplifiedCore`'s name
  

• b17cfc9c
  by sheaf at 2022-10-19T10:50:37-04:00

  TyEq:N assertion: only for saturated applications
  
  The assertion that checked TyEq:N in canEqCanLHSFinish incorrectly
  triggered in the case of an unsaturated newtype TyCon heading the RHS,
  even though we can't unwrap such an application. Now, we only trigger
  an assertion failure in case of a saturated application of a newtype
  TyCon.
  
  Fixes #22310
  

• ff6f2228
  by M Farkas-Dyck at 2022-10-20T16:15:51-04:00

  CoreToStg: purge `DynFlags`.
  

• 1ebd521f
  by Matthew Pickering at 2022-10-20T16:16:27-04:00

  ci: Make fat014 test robust
  
  For some reason I implemented this as a makefile test rather than a
  ghci_script test. Hopefully making it a ghci_script test makes it more
  robust.
  
  Fixes #22313
  

• 8cd6f435
  by Curran McConnell at 2022-10-21T02:58:01-04:00

  remove a no-warn directive from GHC.Cmm.ContFlowOpt
  
  This patch is motivated by the desire to remove the {-# OPTIONS_GHC
  -fno-warn-incomplete-patterns #-} directive at the top of
  GHC.Cmm.ContFlowOpt. (Based on the text in this coding standards doc, I
  understand it's a goal of the project to remove such directives.) I
  chose this task because I'm a new contributor to GHC, and it seemed like
  a good way to get acquainted with the patching process.
  
  In order to address the warning that arose when I removed the no-warn
  directive, I added a case to removeUnreachableBlocksProc to handle the
  CmmData constructor. Clearly, since this partial function has not been
  erroring out in the wild, its inputs are always in practice wrapped by
  the CmmProc constructor. Therefore the CmmData case is handled by a
  precise panic (which is an improvement over the partial pattern match
  from before).
  

• a2af7c4c
  by Nicolas Trangez at 2022-10-21T02:58:39-04:00

  build: get rid of `HAVE_TIME_H`
  
  As advertized by `autoreconf`:
  
  > All current systems provide time.h; it need not be checked for.
  
  Hence, remove the check for it in `configure.ac` and remove conditional
  inclusion of the header in `HAVE_TIME_H` blocks where applicable.
  
  The `time.h` header was being included in various source files without a
  `HAVE_TIME_H` guard already anyway.
  

• 25cdc630
  by Nicolas Trangez at 2022-10-21T02:58:39-04:00

  rts: remove use of `TIME_WITH_SYS_TIME`
  
  `autoreconf` will insert an `m4_warning` when the obsolescent
  `AC_HEADER_TIME` macro is used:
  
  > Update your code to rely only on HAVE_SYS_TIME_H,
  > then remove this warning and the obsolete code below it.
  > All current systems provide time.h; it need not be checked for.
  > Not all systems provide sys/time.h, but those that do, all allow
  > you to include it and time.h simultaneously.
  
  Presence of `sys/time.h` was already checked in an earlier
  `AC_CHECK_HEADERS` invocation, so `AC_HEADER_TIME` can be dropped and
  guards relying on `TIME_WITH_SYS_TIME` can be reworked to
  (unconditionally) include `time.h` and include `sys/time.h` based on
  `HAVE_SYS_TIME_H`.
  
  Note the documentation of `AC_HEADER_TIME` in (at least) Autoconf 2.67
  says
  
  > This macro is obsolescent, as current systems can include both files
  > when they exist. New programs need not use this macro.
  

• 1fe7921c
  by Eric Lindblad at 2022-10-21T02:59:21-04:00

  runhaskell

• e3b3986e
  by David Feuer at 2022-10-21T03:00:00-04:00

  Document how to quote certain names with spaces
  
  Quoting a name for Template Haskell is a bit tricky if the second
  character of that name is a single quote. The User's Guide falsely
  claimed that it was impossible. Document how to do it.
  
  Fixes #22236

• 0eba81e8
  by Krzysztof Gogolewski at 2022-10-21T03:00:00-04:00

  Fix syntax

• a4dbd102
  by Ben Gamari at 2022-10-21T09:11:12-04:00

  Fix manifest filename when writing Windows .rc files
  
  As noted in #12971, we previously used `show` which resulted in
  inappropriate escaping of non-ASCII characters.
  

• 30f0d9a9
  by Ben Gamari at 2022-10-21T09:11:12-04:00

  Write response files in UTF-8 on Windows
  
  This reverts the workaround introduced in
  f63c8ef33ec9666688163abe4ccf2d6c0428a7e7, which taught our response file
  logic to write response files with the `latin1` encoding to workaround
  `gcc`'s lacking Unicode support. This is now no longer necessary (and in
  fact actively unhelpful) since we rather use Clang.
  

• b8304648
  by Matthew Farkas-Dyck at 2022-10-21T09:11:56-04:00

  Scrub some partiality in `GHC.Core.Opt.Simplify.Utils`.
  

• 09ec7de2
  by Teo Camarasu at 2022-10-21T13:23:07-04:00

  template-haskell: Improve documentation of strictness annotation types
  
  Before it was undocumentated that DecidedLazy can be returned by
  reifyConStrictness for strict fields. This can happen when a field has
  an unlifted type or its the single field of a newtype constructor.
  
  Fixes #21380
  

• 88172069
  by M Farkas-Dyck at 2022-10-21T13:23:51-04:00

  Delete `eqExpr`, since GHC 9.4 has been released.
  

• 86e6549e
  by Ömer Sinan Ağacan at 2022-10-22T07:41:30-04:00

  Introduce a standard thunk for allocating strings
  
  Currently for a top-level closure in the form
  
      hey = unpackCString# x
  
  we generate code like this:
  
      Main.hey_entry() //  [R1]
               { info_tbls: [(c2T4,
                              label: Main.hey_info
                              rep: HeapRep static { Thunk }
                              srt: Nothing)]
                 stack_info: arg_space: 8 updfr_space: Just 8
               }
           {offset
             c2T4: // global
                 _rqm::P64 = R1;
                 if ((Sp + 8) - 24 < SpLim) (likely: False) goto c2T5; else goto c2T6;
             c2T5: // global
                 R1 = _rqm::P64;
                 call (stg_gc_enter_1)(R1) args: 8, res: 0, upd: 8;
             c2T6: // global
                 (_c2T1::I64) = call "ccall" arg hints:  [PtrHint,
                                                          PtrHint]  result hints:  [PtrHint] newCAF(BaseReg, _rqm::P64);
                 if (_c2T1::I64 == 0) goto c2T3; else goto c2T2;
             c2T3: // global
                 call (I64[_rqm::P64])() args: 8, res: 0, upd: 8;
             c2T2: // global
                 I64[Sp - 16] = stg_bh_upd_frame_info;
                 I64[Sp - 8] = _c2T1::I64;
                 R2 = hey1_r2Gg_bytes;
                 Sp = Sp - 16;
                 call GHC.CString.unpackCString#_info(R2) args: 24, res: 0, upd: 24;
           }
       }
  
  This code is generated for every string literal. Only difference between
  top-level closures like this is the argument for the bytes of the string
  (hey1_r2Gg_bytes in the code above).
  
  With this patch we introduce a standard thunk in the RTS, called
  stg_MK_STRING_info, that does what `unpackCString# x` does, except it
  gets the bytes address from the payload. Using this, for the closure
  above, we generate this:
  
      Main.hey_closure" {
          Main.hey_closure:
              const stg_MK_STRING_info;
              const 0; // padding for indirectee
              const 0; // static link
              const 0; // saved info
              const hey1_r1Gg_bytes; // the payload
      }
  
  This is much smaller in code.
  
  Metric Decrease:
      T10421
      T11195
      T12150
      T12425
      T16577
      T18282
      T18698a
      T18698b
  
  Co-Authored By: Ben Gamari <ben@well-typed.com>
  

• 1937016b
  by Andreas Klebinger at 2022-10-22T07:42:06-04:00

  hadrian: Improve error for wrong key/value errors.
  

• 11fe42d8
  by Vladislav Zavialov at 2022-10-23T00:11:50+03:00

  Class layout info (#19623)
  
  Updates the haddock submodule.
  

• f0a90c11
  by Sven Tennie at 2022-10-24T00:12:51-04:00

  Pin used way for test cloneMyStack (#21977)
  
  cloneMyStack checks the order of closures on the cloned stack. This may
  change for different ways. Thus we limit this test to one way (normal).
  

• 0614e74d
  by Aaron Allen at 2022-10-24T17:11:21+02:00

  Convert Diagnostics in GHC.Tc.Gen.Splice (#20116)
  
  Replaces uses of `TcRnUnknownMessage` in `GHC.Tc.Gen.Splice` with
  structured diagnostics.
  
  closes #20116
  

• 8d2dbe2d
  by Andreas Klebinger at 2022-10-24T15:59:41-04:00

  Improve stg lint for unboxed sums.
  
  It now properly lints cases where sums end up distributed
  over multiple args after unarise.
  
  Fixes #22026.
  

• 41406da5
  by Simon Peyton Jones at 2022-10-25T18:07:03-04:00

  Fix binder-swap bug
  
  This patch fixes #21229 properly, by avoiding doing a
  binder-swap on dictionary Ids.  This is pretty subtle, and explained
  in Note [Care with binder-swap on dictionaries].
  
  Test is already in simplCore/should_run/T21229
  
  This allows us to restore a feature to the specialiser that we had
  to revert: see Note [Specialising polymorphic dictionaries].
  (This is done in a separate patch.)
  
  I also modularised things, using a new function scrutBinderSwap_maybe
  in all the places where we are (effectively) doing a binder-swap,
  notably
  
  * Simplify.Iteration.addAltUnfoldings
  * SpecConstr.extendCaseBndrs
  
  In Simplify.Iteration.addAltUnfoldings I also eliminated a guard
      Many <- idMult case_bndr
  because we concluded, in #22123, that it was doing no good.
  

• 5a997e16
  by Simon Peyton Jones at 2022-10-25T18:07:03-04:00

  Make the specialiser handle polymorphic specialisation
  
  Ticket #13873 unexpectedly showed that a SPECIALISE pragma made a
  program run (a lot) slower, because less specialisation took place
  overall. It turned out that the specialiser was missing opportunities
  because of quantified type variables.
  
  It was quite easy to fix. The story is given in
      Note [Specialising polymorphic dictionaries]
  
  Two other minor fixes in the specialiser
  
  * There is no benefit in specialising data constructor /wrappers/.
    (They can appear overloaded because they are given a dictionary
    to store in the constructor.)  Small guard in canSpecImport.
  
  * There was a buglet in the UnspecArg case of specHeader, in the
    case where there is a dead binder. We need a LitRubbish filler
    for the specUnfolding stuff.  I expanded
    Note [Drop dead args from specialisations] to explain.
  
  There is a 4% increase in compile time for T15164, because we generate
  more specialised code.  This seems OK.
  
  Metric Increase:
      T15164
  

• 7f203d00
  by Sylvain Henry at 2022-10-25T18:07:43-04:00

  Numeric exceptions: replace FFI calls with primops
  
  ghc-bignum needs a way to raise numerical exceptions defined in base
  package. At the time we used FFI calls into primops defined in the RTS.
  These FFI calls had to be wrapped into hacky bottoming functions because
  "foreign import prim" syntax doesn't support giving a bottoming demand
  to the foreign call (cf #16929).
  
  These hacky wrapper functions trip up the JavaScript backend (#21078)
  because they are polymorphic in their return type. This commit
  replaces them with primops very similar to raise# but raising predefined
  exceptions.
  

• 0988a23d
  by Sylvain Henry at 2022-10-25T18:08:24-04:00

  Enable popcount rewrite rule when cross-compiling
  
  The comment applies only when host's word size < target's word size.
  So we can relax the guard.
  

• a2f53ac8
  by Sylvain Henry at 2022-10-25T18:09:05-04:00

  Add GHC.SysTools.Cpp module
  
  Move doCpp out of the driver to be able to use it in the upcoming JS backend.
  

• 1fd7f201
  by Ben Gamari at 2022-10-25T18:09:42-04:00

  llvm-targets: Add datalayouts for big-endian AArch64 targets
  
  Fixes #22311.
  
  Thanks to @zeldin for the patch.
  

• f5a486eb
  by Krzysztof Gogolewski at 2022-10-25T18:10:19-04:00

  Cleanup String/FastString conversions
  
  Remove unused mkPtrString and isUnderscoreFS.
  We no longer use mkPtrString since 1d03d8bef96.
  
  Remove unnecessary conversions between FastString and String and back.
  

• f7bfb40c
  by Ryan Scott at 2022-10-26T00:01:24-04:00

  Broaden the in-scope sets for liftEnvSubst and composeTCvSubst
  
  This patch fixes two distinct (but closely related) buglets that were uncovered
  in #22235:
  
  * `liftEnvSubst` used an empty in-scope set, which was not wide enough to cover
    the variables in the range of the substitution. This patch fixes this by
    populating the in-scope set from the free variables in the range of the
    substitution.
  * `composeTCvSubst` applied the first substitution argument to the range of the
    second substitution argument, but the first substitution's in-scope set was
    not wide enough to cover the range of the second substutition. We similarly
    fix this issue in this patch by widening the first substitution's in-scope set
    before applying it.
  
  Fixes #22235.
  

• 0270cc54
  by Vladislav Zavialov at 2022-10-26T00:02:01-04:00

  Introduce TcRnWithHsDocContext (#22346)
  
  Before this patch, GHC used withHsDocContext to attach an HsDocContext
  to an error message:
  
  	addErr $ mkTcRnUnknownMessage $ mkPlainError noHints (withHsDocContext ctxt msg)
  
  The problem with this approach is that it only works with
  TcRnUnknownMessage. But could we attach an HsDocContext to a
  structured error message in a generic way? This patch solves
  the problem by introducing a new constructor to TcRnMessage:
  
  	data TcRnMessage where
  	  ...
  	  TcRnWithHsDocContext :: !HsDocContext -> !TcRnMessage -> TcRnMessage
  	  ...
  

• 9ab31f42
  by Sylvain Henry at 2022-10-26T09:32:20+02:00

  Testsuite: more precise test options
  
  Necessary for newer cross-compiling backends (JS, Wasm) that don't
  support TH yet.
  

• f60a1a62
  by Vladislav Zavialov at 2022-10-26T12:17:14-04:00

  Use TcRnVDQInTermType in noNestedForallsContextsErr (#20115)
  
  When faced with VDQ in the type of a term, GHC generates the following
  error message:
  
  	Illegal visible, dependent quantification in the type of a term
  	(GHC does not yet support this)
  
  Prior to this patch, there were two ways this message could have been
  generated and represented:
  
  	1. with the dedicated constructor TcRnVDQInTermType
  	    (see check_type in GHC.Tc.Validity)
  	2. with the transitional constructor TcRnUnknownMessage
  	    (see noNestedForallsContextsErr in GHC.Rename.Utils)
  
  Not only this led to duplication of code generating the final SDoc,
  it also made it tricky to track the origin of the error message.
  
  This patch fixes the problem by using TcRnVDQInTermType exclusively.
  

• 223e159d
  by Owen Shepherd at 2022-10-27T13:54:33-04:00

  Remove source location information from interface files
  
  This change aims to minimize source location information leaking
  into interface files, which makes ABI hashes dependent on the
  build location.
  
  The `Binary (Located a)` instance has been removed completely.
  
  It seems that the HIE interface still needs the ability to
  serialize SrcSpans, but by wrapping the instances, it should
  be a lot more difficult to inadvertently add source location
  information.
  

• 22e3deb9
  by Simon Peyton Jones at 2022-10-27T13:55:37-04:00

  Add missing dict binds to specialiser
  
  I had forgotten to add the auxiliary dict bindings to the
  /unfolding/ of a specialised function.  This caused #22358,
  which reports failures when compiling Hackage packages
       fixed-vector
       indexed-traversable
  
  Regression test T22357 is snarfed from indexed-traversable
  

• a8ed36f9
  by Evan Relf at 2022-10-27T13:56:36-04:00

  Fix broken link to `async` package
  

• 750846cd
  by Zubin Duggal at 2022-10-28T00:49:22-04:00

  Pass correct package db when testing stage1.
  
  It used to pick the db for stage-2 which obviously didn't work.
  

• ad612f55
  by Krzysztof Gogolewski at 2022-10-28T00:50:00-04:00

  Minor SDoc-related cleanup
  
  * Rename pprCLabel to pprCLabelStyle, and use the name pprCLabel
    for a function using CStyle (analogous to pprAsmLabel)
  * Move LabelStyle to the CLabel module, it no longer needs to be in Outputable.
  * Move calls to 'text' right next to literals, to make sure the text/str
    rule is triggered.
  * Remove FastString/String roundtrip in Tc.Deriv.Generate
  * Introduce showSDocForUser', which abstracts over a pattern in
    GHCi.UI
  

• c2872f3f
  by Bryan Richter at 2022-10-28T11:36:34+03:00

  CI: Don't run lint-submods on nightly
  
  Fixes #22325
  

• 270037fa
  by Hécate Moonlight at 2022-10-28T19:46:12-04:00

  Start the deprecation process for GHC.Pack
  

• d45d8cb3
  by M Farkas-Dyck at 2022-11-01T12:47:21-04:00

  Drop a kludge for binutils<2.17, which is now over 10 years old.
  

• 8ee8b418
  by Nicolas Trangez at 2022-11-01T12:47:58-04:00

  rts: `name` argument of `createOSThread` can be `const`
  
  Since we don't intend to ever change the incoming string, declare this
  to be true.
  
  Also, in the POSIX implementation, the argument is no longer `STG_UNUSED`
  (since ee0deb8054da2a597fc5624469b4c44fd769ada2) in any code path.
  
  See: https://gitlab.haskell.org/ghc/ghc/-/commit/ee0deb8054da2a597fc5624469b4c44fd769ada2#note_460080
  

• 13b5f102
  by Nicolas Trangez at 2022-11-01T12:47:58-04:00

  rts: fix lifetime of `start_thread`s `name` value
  
  Since, unlike the code in ee0deb8054da2^, usage of the `name` value
  passed to `createOSThread` now outlives said function's lifetime, and
  could hence be released by the caller by the time the new thread runs
  `start_thread`, it needs to be copied.
  
  See: https://gitlab.haskell.org/ghc/ghc/-/commit/ee0deb8054da2a597fc5624469b4c44fd769ada2#note_460080
  See: https://gitlab.haskell.org/ghc/ghc/-/merge_requests/9066
  

• edd175c9
  by Nicolas Trangez at 2022-11-01T12:47:58-04:00

  rts: fix OS thread naming in ticker
  
  Since ee0deb805, the use of `pthread_setname_np` on Darwin was fixed
  when invoking `createOSThread`. However, the 'ticker' has some
  thread-creation code which doesn't rely on `createOSThread`, yet also
  uses `pthread_setname_np`.
  
  This patch enforces all thread creation to go through a single
  function, which uses the (correct) thread-naming code introduced in
  ee0deb805.
  
  See: https://gitlab.haskell.org/ghc/ghc/-/commit/ee0deb8054da2a597fc5624469b4c44fd769ada2
  See: https://gitlab.haskell.org/ghc/ghc/-/issues/22206
  See: https://gitlab.haskell.org/ghc/ghc/-/merge_requests/9066
  

• b7a00113
  by Krzysztof Gogolewski at 2022-11-01T12:48:35-04:00

  Typo: rename -fwrite-if-simplfied-core to -fwrite-if-simplified-core
  

• 30e625e6
  by Vladislav Zavialov at 2022-11-01T12:49:10-04:00

  ThToHs: fix overzealous parenthesization
  
  Before this patch, when converting from TH.Exp to LHsExpr GhcPs,
  the compiler inserted more parentheses than required:
  
  	((f a) (b + c)) d
  
  This was happening because the LHS of the function application was
  parenthesized as if it was the RHS.
  
  Now we use funPrec and appPrec appropriately and produce sensibly
  parenthesized expressions:
  
  	f a (b + c) d
  
  I also took the opportunity to remove the special case for LamE,
  which was not special at all and simply duplicated code.
  

• 0560821f
  by Simon Peyton Jones at 2022-11-01T12:49:47-04:00

  Add accurate skolem info when quantifying
  
  Ticket #22379 revealed that skolemiseQuantifiedTyVar was
  dropping the passed-in skol_info on the floor when it encountered
  a SkolemTv.  Bad!  Several TyCons thereby share a single SkolemInfo
  on their binders, which lead to bogus error reports.
  

• 38d19668
  by Fendor at 2022-11-01T12:50:25-04:00

  Expose UnitEnvGraphKey for user-code
  

• 77e24902
  by Simon Peyton Jones at 2022-11-01T12:51:00-04:00

  Shrink test case for #22357
  
  Ryan Scott offered a cut-down repro case
  (60 lines instead of more than 700 lines)
  

• 4521f649
  by Simon Peyton Jones at 2022-11-01T12:51:00-04:00

  Add two tests for #17366
  

• 6b400d26
  by Nicolas Trangez at 2022-11-02T12:06:48-04:00

  rts: introduce (and use) `STG_NORETURN`
  
  Instead of sprinkling the codebase with
  `GNU(C3)_ATTRIBUTE(__noreturn__)`, add a `STG_NORETURN` macro (for,
  basically, the same thing) similar to `STG_UNUSED` and others, and
  update the code to use this macro where applicable.
  

• f9638654
  by Nicolas Trangez at 2022-11-02T12:06:48-04:00

  rts: consistently use `STG_UNUSED`
  

• 81a58433
  by Nicolas Trangez at 2022-11-02T12:06:48-04:00

  rts: introduce (and use) `STG_USED`
  
  Similar to `STG_UNUSED`, have a specific macro for
  `__attribute__(used)`.
  

• 41e1f748
  by Nicolas Trangez at 2022-11-02T12:06:48-04:00

  rts: introduce (and use) `STG_MALLOC`
  
  Instead of using `GNUC3_ATTRIBUTE(__malloc__)`, provide a `STG_MALLOC`
  macro definition and use it instead.
  

• 3a9a8bde
  by Nicolas Trangez at 2022-11-02T12:06:48-04:00

  rts: use `STG_UNUSED`
  

• 9ab999de
  by Nicolas Trangez at 2022-11-02T12:06:48-04:00

  rts: specify deallocator of allocating functions
  
  This patch adds a new `STG_MALLOC1` macro (and its counterpart
  `STG_MALLOC2` for completeness) which allows to specify the deallocation
  function to be used with allocations of allocating functions, and
  applies it to `stg*allocBytes`.
  
  It also fixes a case where `free` was used to free up an
  `stgMallocBytes` allocation, found by the above change.
  
  See: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-malloc-function-attribute
  See: https://gitlab.haskell.org/ghc/ghc/-/issues/22381
  

• 81c0c7c9
  by Nicolas Trangez at 2022-11-02T12:06:48-04:00

  rts: use `alloc_size` attribute
  
  This patch adds the `STG_ALLOC_SIZE1` and `STG_ALLOC_SIZE2` macros which
  allow to set the `alloc_size` attribute on functions, when available.
  
  See: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-alloc_005fsize-function-attribute
  See: https://gitlab.haskell.org/ghc/ghc/-/issues/22381
  

• 99a1d896
  by Nicolas Trangez at 2022-11-02T12:06:48-04:00

  rts: add and use `STG_RETURNS_NONNULL`
  
  See: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-returns_005fnonnull-function-attribute
  See: https://gitlab.haskell.org/ghc/ghc/-/issues/22381
  

• c235b399
  by Nicolas Trangez at 2022-11-02T12:06:48-04:00

  rts: tag `stgStrndup` as `STG_MALLOC`
  
  See: https://gitlab.haskell.org/ghc/ghc/-/issues/22381
  

• ed81b448
  by Oleg Grenrus at 2022-11-02T12:07:27-04:00

  Move Symbol implementation note out of public haddock
  

• 284fd39c
  by Ben Gamari at 2022-11-03T01:58:54-04:00

  gen-dll: Drop it
  
  Currently it is only used by the make build system, which is soon to be
  retired, and it has not built since 41cf758b. We may need to reintroduce
  it when dynamic-linking support is introduced on Windows, but we will
  cross that bridge once we get there.
  
  Fixes #21753.
  

• 24f4f54f
  by Matthew Pickering at 2022-11-03T01:59:30-04:00

  Port foundation numeric tests to GHC testsuite
  
  This commit ports the numeric tests which found a regression in GHC-9.4.
  
  https://github.com/haskell-foundation/foundation/issues/571
  
  Included in the commit is a simple random number generator and
  simplified QuickCheck implementation. In future these could be factored
  out of this standalone file and reused as a general purpose library
  which could be used for other QuickCheck style tests in the testsuite.
  
  See #22282
  

• d51bf7bd
  by M Farkas-Dyck at 2022-11-03T02:00:13-04:00

  git: ignore HIE files.
  
  Cleans up git status if one sets -fwrite-ide-info in hadrian/ghci.
  

• a9fc15b1
  by Matthew Pickering at 2022-11-03T02:00:49-04:00

  Clarify status of bindings in WholeCoreBindings
  
  Gergo points out that these bindings are tidied, rather than prepd as
  the variable claims. Therefore we update the name of the variable to
  reflect reality and add a comment to the data type to try to erase any
  future confusion.
  
  Fixes #22307
  

• 634da448
  by Andrew Lelechenko at 2022-11-03T21:25:02+00:00

  Fix haddocks for GHC.IORef
  

• 31125154
  by Andreas Klebinger at 2022-11-03T23:08:09-04:00

  Export pprTrace and friends from GHC.Prelude.
  
  Introduces GHC.Prelude.Basic which can be used in modules which are a
  dependency of the ppr code.
  

• bdc8cbb3
  by Bryan Richter at 2022-11-04T10:27:37+02:00

  CI: Allow hadrian-ghc-in-ghci to run in nightlies
  
  Since lint-submods doesn't run in nightlies, hadrian-ghc-in-ghci needs
  to mark it as "optional" so it can run if the job doesn't exist.
  
  Fixes #22396.
  

• 3c0e3793
  by Krzysztof Gogolewski at 2022-11-05T00:29:57-04:00

  Minor refactor around FastStrings
  
  Pass FastStrings to functions directly, to make sure the rule
  for fsLit "literal" fires.
  
  Remove SDoc indirection in GHCi.UI.Tags and GHC.Unit.Module.Graph.
  

• e41b2f55
  by Matthew Pickering at 2022-11-05T14:18:10+00:00

  Bump unix submodule to 2.8.0.0
  
  Also bumps process and ghc-boot bounds on unix.
  
  For hadrian, when cross-compiling, we add -Wwarn=unused-imports
  -Wwarn=unused-top-binds to validation flavour. Further fixes in unix
  and/or hsc2hs is needed to make it completely free of warnings; for
  the time being, this change is needed to unblock other
  cross-compilation related work.
  

• 42938a58
  by Matthew Pickering at 2022-11-05T14:18:10+00:00

  Bump Win32 submodule to 2.13.4.0
  
  Fixes #22098
  

• e7372bc5
  by Cheng Shao at 2022-11-06T13:15:22+00:00

  Bump ci-images revision
  
  ci-images has recently been updated, including changes needed for wasm32-wasi CI.
  

• 88cb9492
  by Cheng Shao at 2022-11-06T13:15:22+00:00

  Bump gmp-tarballs submodule
  
  Includes a fix for wasm support, doesn't impact other targets.
  

• 69427ce9
  by Cheng Shao at 2022-11-06T13:15:22+00:00

  Bump haskeline submodule
  
  Includes a fix for wasm support, doesn't impact other targets.
  

• 5fe11fe6
  by Carter Schonwald at 2022-11-07T13:22:14-05:00

  bump llvm upper bound

• 68f49874
  by M Farkas-Dyck at 2022-11-08T12:53:55-05:00

  Define `Infinite` list and use where appropriate.
  
  Also add perf test for infinite list fusion.
  
  In particular, in `GHC.Core`, often we deal with infinite lists of roles. Also in a few locations we deal with infinite lists of names.
  
  Thanks to simonpj for helping to write the Note [Fusion for `Infinite` lists].
  

• ce726cd2
  by Ross Paterson at 2022-11-08T12:54:34-05:00

  Fix TypeData issues (fixes #22315 and #22332)
  
  There were two bugs here:
  
  1. Treating type-level constructors as PromotedDataCon doesn't always
     work, in particular because constructors promoted via DataKinds are
     called both T and 'T. (Tests T22332a, T22332b, T22315a, T22315b)
     Fix: guard these cases with isDataKindsPromotedDataCon.
  
  2. Type-level constructors were sent to the code generator, producing
     things like constructor wrappers. (Tests T22332a, T22332b)
     Fix: test for them in isDataTyCon.
  
  Other changes:
  
  * changed the marking of "type data" DataCon's as suggested by SPJ.
  
  * added a test TDGADT for a type-level GADT.
  
  * comment tweaks
  
  * change tcIfaceTyCon to ignore IfaceTyConInfo, so that IfaceTyConInfo
    is used only for pretty printing, not for typechecking. (SPJ)
  

• 132f8908
  by Jade Lovelace at 2022-11-08T12:55:18-05:00

  Clarify msum/asum documentation
  

• bb5888c5
  by Jade Lovelace at 2022-11-08T12:55:18-05:00

  Add example for (<$)
  

• 080fffa1
  by Jade Lovelace at 2022-11-08T12:55:18-05:00

  Document what Alternative/MonadPlus instances actually do
  

• 92ccb8de
  by Giles Anderson at 2022-11-09T09:27:52-05:00

  Use TcRnDiagnostic in GHC.Tc.TyCl.Instance (#20117)
  
  The following `TcRnDiagnostic` messages have been introduced:
  
  TcRnWarnUnsatisfiedMinimalDefinition
  TcRnMisplacedInstSig
  TcRnBadBootFamInstDeclErr
  TcRnIllegalFamilyInstance
  TcRnAssocInClassErr
  TcRnBadFamInstDecl
  TcRnNotOpenFamily
  

• 90c5abd4
  by Hécate Moonlight at 2022-11-09T09:28:30-05:00

  GHCi tags generation phase 2
  
  see #19884
  

• d8dec015
  by Simon Peyton Jones at 2022-11-10T15:56:19+00:00

  Kill ad hoc Note [Case MFEs] hack
  
  See discussion in #19001.  I'm keen to kill this hack off.
  This MR is to check CI and perf.
  
  Also enable CaseOfCase in InitialPhase
  

910 changed files:

• .editorconfig
• .gitignore
• .gitlab-ci.yml
• .gitlab/ci.sh
• CODEOWNERS
• README.md
• compiler/GHC.hs
• compiler/GHC/Builtin/Names.hs
• compiler/GHC/Builtin/primops.txt.pp
• compiler/GHC/Cmm.hs
• compiler/GHC/Cmm/BlockId.hs
• compiler/GHC/Cmm/CLabel.hs
• compiler/GHC/Cmm/CLabel.hs-boot
• compiler/GHC/Cmm/ContFlowOpt.hs
• compiler/GHC/Cmm/Dataflow/Label.hs
• compiler/GHC/Cmm/Expr.hs
• compiler/GHC/Cmm/Info/Build.hs
• compiler/GHC/Cmm/Lint.hs
• compiler/GHC/Cmm/MachOp.hs
• compiler/GHC/Cmm/Node.hs
• compiler/GHC/Cmm/Parser.y
• compiler/GHC/Cmm/Pipeline.hs
• compiler/GHC/Cmm/Switch.hs
• compiler/GHC/Cmm/Utils.hs
• compiler/GHC/CmmToAsm.hs
• compiler/GHC/CmmToAsm/AArch64/CodeGen.hs
• compiler/GHC/CmmToAsm/AArch64/Ppr.hs
• compiler/GHC/CmmToAsm/AArch64/Regs.hs
• compiler/GHC/CmmToAsm/BlockLayout.hs
• compiler/GHC/CmmToAsm/Dwarf/Types.hs
• compiler/GHC/CmmToAsm/PPC/CodeGen.hs
• compiler/GHC/CmmToAsm/PPC/Instr.hs
• compiler/GHC/CmmToAsm/PPC/Ppr.hs
• compiler/GHC/CmmToAsm/PPC/Regs.hs
• compiler/GHC/CmmToAsm/Reg/Liveness.hs
• compiler/GHC/CmmToAsm/X86/CodeGen.hs
• compiler/GHC/CmmToAsm/X86/Instr.hs
• compiler/GHC/CmmToAsm/X86/Ppr.hs
• compiler/GHC/CmmToAsm/X86/Regs.hs
• compiler/GHC/CmmToC.hs
• compiler/GHC/CmmToLlvm.hs
• compiler/GHC/CmmToLlvm/Base.hs
• compiler/GHC/Core.hs
• compiler/GHC/Core/Coercion.hs
• compiler/GHC/Core/Coercion/Opt.hs
• compiler/GHC/Core/DataCon.hs
• compiler/GHC/Core/DataCon.hs-boot
• compiler/GHC/Core/FamInstEnv.hs
• compiler/GHC/Core/InstEnv.hs
• compiler/GHC/Core/Lint.hs
• compiler/GHC/Core/Make.hs
• compiler/GHC/Core/Map/Expr.hs
• compiler/GHC/Core/Map/Type.hs
• compiler/GHC/Core/Opt/Arity.hs
• compiler/GHC/Core/Opt/CSE.hs
• compiler/GHC/Core/Opt/ConstantFold.hs
• compiler/GHC/Core/Opt/CprAnal.hs
• compiler/GHC/Core/Opt/DmdAnal.hs
• compiler/GHC/Core/Opt/Exitify.hs
• compiler/GHC/Core/Opt/Monad.hs
• compiler/GHC/Core/Opt/OccurAnal.hs
• compiler/GHC/Core/Opt/Pipeline.hs
• compiler/GHC/Core/Opt/Pipeline/Types.hs
• compiler/GHC/Core/Opt/SetLevels.hs
• compiler/GHC/Core/Opt/Simplify.hs
• compiler/GHC/Core/Opt/Simplify/Env.hs
• compiler/GHC/Core/Opt/Simplify/Iteration.hs
• compiler/GHC/Core/Opt/Simplify/Utils.hs
• compiler/GHC/Core/Opt/SpecConstr.hs
• compiler/GHC/Core/Opt/Specialise.hs
• compiler/GHC/Core/Opt/Stats.hs
• compiler/GHC/Core/Opt/WorkWrap.hs
• compiler/GHC/Core/Opt/WorkWrap/Utils.hs
• compiler/GHC/Core/Ppr.hs
• compiler/GHC/Core/Reduction.hs
• compiler/GHC/Core/Rules.hs
• compiler/GHC/Core/SimpleOpt.hs
• compiler/GHC/Core/Subst.hs
• compiler/GHC/Core/Tidy.hs
• compiler/GHC/Core/TyCo/Subst.hs
• compiler/GHC/Core/TyCo/Tidy.hs
• compiler/GHC/Core/TyCon.hs
• compiler/GHC/Core/Type.hs
• compiler/GHC/Core/Unfold.hs
• compiler/GHC/Core/Unfold/Make.hs
• compiler/GHC/Core/Unify.hs
• compiler/GHC/Core/Utils.hs
• compiler/GHC/CoreToIface.hs
• compiler/GHC/CoreToStg.hs
• compiler/GHC/CoreToStg/Prep.hs
• compiler/GHC/Data/Bag.hs
• compiler/GHC/Data/Bool.hs
• compiler/GHC/Data/BooleanFormula.hs
• compiler/GHC/Data/FastMutInt.hs
• compiler/GHC/Data/FastString.hs
• + compiler/GHC/Data/List/Infinite.hs
• compiler/GHC/Data/List/SetOps.hs
• compiler/GHC/Data/OrdList.hs
• compiler/GHC/Data/TrieMap.hs
• + compiler/GHC/Data/Unboxed.hs
• compiler/GHC/Driver/Backpack.hs
• compiler/GHC/Driver/CodeOutput.hs
• compiler/GHC/Driver/Config/Core/Lint.hs
• compiler/GHC/Driver/Config/Core/Opt/Simplify.hs
• + compiler/GHC/Driver/Config/CoreToStg.hs
• compiler/GHC/Driver/Config/Diagnostic.hs
• compiler/GHC/Driver/Config/StgToCmm.hs
• compiler/GHC/Driver/Env.hs
• compiler/GHC/Driver/Errors.hs
• compiler/GHC/Driver/Errors/Ppr.hs
• compiler/GHC/Driver/Errors/Types.hs
• compiler/GHC/Driver/Flags.hs
• compiler/GHC/Driver/GenerateCgIPEStub.hs
• compiler/GHC/Driver/Main.hs
• compiler/GHC/Driver/Make.hs
• compiler/GHC/Driver/Monad.hs
• compiler/GHC/Driver/Pipeline.hs
• compiler/GHC/Driver/Pipeline/Execute.hs
• compiler/GHC/Driver/Pipeline/Phases.hs
• compiler/GHC/Driver/Session.hs
• compiler/GHC/Hs.hs
• compiler/GHC/Hs/Decls.hs
• compiler/GHC/Hs/Doc.hs
• compiler/GHC/Hs/DocString.hs
• compiler/GHC/Hs/Dump.hs
• compiler/GHC/Hs/Extension.hs
• compiler/GHC/Hs/Utils.hs
• compiler/GHC/HsToCore.hs
• compiler/GHC/HsToCore/Binds.hs
• compiler/GHC/HsToCore/Coverage.hs
• compiler/GHC/HsToCore/Errors/Ppr.hs
• compiler/GHC/HsToCore/Errors/Types.hs
• compiler/GHC/HsToCore/Foreign/C.hs
• compiler/GHC/HsToCore/Foreign/Decl.hs
• compiler/GHC/HsToCore/Match/Constructor.hs
• compiler/GHC/HsToCore/Monad.hs
• compiler/GHC/HsToCore/Pmc/Ppr.hs
• compiler/GHC/HsToCore/Pmc/Solver.hs
• compiler/GHC/HsToCore/Pmc/Solver/Types.hs
• compiler/GHC/HsToCore/Quote.hs
• compiler/GHC/HsToCore/Utils.hs
• compiler/GHC/Iface/Ext/Ast.hs
• compiler/GHC/Iface/Ext/Binary.hs
• compiler/GHC/Iface/Ext/Types.hs
• compiler/GHC/Iface/Load.hs
• compiler/GHC/Iface/Make.hs
• compiler/GHC/Iface/Recomp.hs
• compiler/GHC/Iface/Rename.hs
• compiler/GHC/Iface/Syntax.hs
• compiler/GHC/Iface/Tidy.hs
• compiler/GHC/Iface/Tidy/StaticPtrTable.hs
• compiler/GHC/Iface/Type.hs
• compiler/GHC/IfaceToCore.hs
• compiler/GHC/Linker/ExtraObj.hs
• compiler/GHC/Linker/Loader.hs
• compiler/GHC/Linker/Types.hs
• compiler/GHC/Linker/Windows.hs
• compiler/GHC/Llvm/Types.hs
• compiler/GHC/Parser.y
• compiler/GHC/Parser/Annotation.hs
• compiler/GHC/Parser/Errors/Ppr.hs
• compiler/GHC/Parser/Errors/Types.hs
• compiler/GHC/Parser/HaddockLex.x
• compiler/GHC/Parser/Lexer.x
• compiler/GHC/Parser/PostProcess.hs
• compiler/GHC/Parser/PostProcess/Haddock.hs
• compiler/GHC/Prelude.hs
• + compiler/GHC/Prelude/Basic.hs
• compiler/GHC/Rename/Expr.hs
• compiler/GHC/Rename/HsType.hs
• compiler/GHC/Rename/Module.hs
• compiler/GHC/Rename/Names.hs
• compiler/GHC/Rename/Unbound.hs
• compiler/GHC/Rename/Utils.hs
• compiler/GHC/Runtime/Eval.hs
• compiler/GHC/Runtime/Heap/Inspect.hs
• compiler/GHC/Runtime/Interpreter.hs
• compiler/GHC/Runtime/Loader.hs
• compiler/GHC/Stg/CSE.hs
• compiler/GHC/Stg/InferTags.hs
• compiler/GHC/Stg/InferTags/Rewrite.hs
• compiler/GHC/Stg/InferTags/TagSig.hs
• compiler/GHC/Stg/Lift/Monad.hs
• compiler/GHC/Stg/Lint.hs
• compiler/GHC/Stg/Pipeline.hs
• compiler/GHC/Stg/Subst.hs
• compiler/GHC/Stg/Unarise.hs
• compiler/GHC/StgToByteCode.hs
• compiler/GHC/StgToCmm/Bind.hs
• compiler/GHC/StgToCmm/Heap.hs
• + compiler/GHC/StgToCmm/InfoTableProv.hs
• compiler/GHC/StgToCmm/Prim.hs
• compiler/GHC/StgToCmm/Prof.hs
• compiler/GHC/StgToCmm/Ticky.hs
• compiler/GHC/StgToCmm/Types.hs
• compiler/GHC/StgToCmm/Utils.hs
• + compiler/GHC/SysTools/Cpp.hs
• compiler/GHC/SysTools/Process.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/Ppr.hs
• compiler/GHC/Tc/Errors/Types.hs
• compiler/GHC/Tc/Gen/Default.hs
• compiler/GHC/Tc/Gen/Expr.hs
• compiler/GHC/Tc/Gen/Foreign.hs
• compiler/GHC/Tc/Gen/Head.hs
• compiler/GHC/Tc/Gen/HsType.hs
• compiler/GHC/Tc/Gen/Sig.hs
• compiler/GHC/Tc/Gen/Splice.hs
• compiler/GHC/Tc/Instance/Class.hs
• compiler/GHC/Tc/Instance/Typeable.hs
• compiler/GHC/Tc/Module.hs
• compiler/GHC/Tc/Solver/Canonical.hs
• compiler/GHC/Tc/Solver/InertSet.hs
• compiler/GHC/Tc/Solver/Interact.hs
• compiler/GHC/Tc/Solver/Monad.hs
• compiler/GHC/Tc/Solver/Rewrite.hs
• compiler/GHC/Tc/TyCl.hs
• compiler/GHC/Tc/TyCl/Instance.hs
• compiler/GHC/Tc/TyCl/PatSyn.hs
• compiler/GHC/Tc/Types/Constraint.hs
• compiler/GHC/Tc/Types/Origin.hs
• compiler/GHC/Tc/Utils/Backpack.hs
• compiler/GHC/Tc/Utils/Env.hs
• compiler/GHC/Tc/Utils/Monad.hs
• compiler/GHC/Tc/Utils/TcMType.hs
• compiler/GHC/Tc/Utils/TcType.hs
• compiler/GHC/Tc/Validity.hs
• compiler/GHC/ThToHs.hs
• compiler/GHC/Types/Basic.hs
• compiler/GHC/Types/CostCentre.hs
• compiler/GHC/Types/Demand.hs
• compiler/GHC/Types/Error.hs
• compiler/GHC/Types/Error/Codes.hs
• compiler/GHC/Types/FieldLabel.hs
• compiler/GHC/Types/ForeignCall.hs
• compiler/GHC/Types/ForeignStubs.hs
• compiler/GHC/Types/Id.hs
• compiler/GHC/Types/Id/Make.hs
• compiler/GHC/Types/Literal.hs
• compiler/GHC/Types/Name.hs
• compiler/GHC/Types/Name/Env.hs
• compiler/GHC/Types/Name/Occurrence.hs
• compiler/GHC/Types/Name/Occurrence.hs-boot
• compiler/GHC/Types/Name/Reader.hs
• compiler/GHC/Types/Name/Set.hs
• compiler/GHC/Types/RepType.hs
• compiler/GHC/Types/SourceError.hs
• compiler/GHC/Types/SrcLoc.hs
• compiler/GHC/Types/TyThing.hs
• compiler/GHC/Types/TyThing/Ppr.hs
• compiler/GHC/Types/Var/Env.hs
• compiler/GHC/Unit/Env.hs
• compiler/GHC/Unit/Home/ModInfo.hs
• compiler/GHC/Unit/Module/Env.hs
• compiler/GHC/Unit/Module/Graph.hs
• compiler/GHC/Unit/Module/ModIface.hs
• compiler/GHC/Unit/Module/Status.hs
• compiler/GHC/Unit/Module/Warnings.hs
• + compiler/GHC/Unit/Module/WholeCoreBindings.hs
• compiler/GHC/Unit/State.hs
• compiler/GHC/Unit/Types.hs
• compiler/GHC/Unit/Types.hs-boot
• compiler/GHC/Utils/Binary.hs
• compiler/GHC/Utils/BufHandle.hs
• compiler/GHC/Utils/Constants.hs
• compiler/GHC/Utils/Error.hs
• compiler/GHC/Utils/Exception.hs
• compiler/GHC/Utils/Fingerprint.hs
• compiler/GHC/Utils/GlobalVars.hs
• compiler/GHC/Utils/IO/Unsafe.hs
• compiler/GHC/Utils/Json.hs
• compiler/GHC/Utils/Lexeme.hs
• compiler/GHC/Utils/Misc.hs
• compiler/GHC/Utils/Monad.hs
• compiler/GHC/Utils/Outputable.hs
• compiler/GHC/Utils/Panic.hs
• compiler/GHC/Utils/Panic/Plain.hs
• compiler/GHC/Utils/Ppr.hs
• compiler/GHC/Utils/Ppr/Colour.hs
• compiler/GHC/Utils/Trace.hs
• compiler/Language/Haskell/Syntax.hs
• + compiler/Language/Haskell/Syntax/Concrete.hs
• compiler/Language/Haskell/Syntax/Decls.hs
• compiler/Language/Haskell/Syntax/Expr.hs
• compiler/Language/Haskell/Syntax/Extension.hs
• compiler/Language/Haskell/Syntax/Pat.hs
• compiler/Language/Haskell/Syntax/Type.hs
• compiler/Setup.hs
• compiler/ghc.cabal.in
• configure.ac
• docs/users_guide/9.6.1-notes.rst
• docs/users_guide/exts/data_kinds.rst
• docs/users_guide/exts/pattern_synonyms.rst
• docs/users_guide/exts/template_haskell.rst
• + docs/users_guide/exts/type_data.rst
• docs/users_guide/exts/types.rst
• docs/users_guide/phases.rst
• docs/users_guide/runghc.rst
• docs/users_guide/using-optimisation.rst
• docs/users_guide/using.rst
• ghc/GHCi/Leak.hs
• ghc/GHCi/UI.hs
• ghc/GHCi/UI/Monad.hs
• ghc/GHCi/UI/Tags.hs
• ghc/Main.hs
• ghc/ghc-bin.cabal.in
• hadrian/src/Flavour.hs
• hadrian/src/Rules/Dependencies.hs
• hadrian/src/Rules/Generate.hs
• hadrian/src/Rules/Test.hs
• hadrian/src/Settings.hs
• hadrian/src/Settings/Default.hs
• libraries/Cabal
• libraries/Win32
• libraries/base/Data/Array/Byte.hs
• libraries/base/Data/Char.hs
• libraries/base/Data/Foldable.hs
• libraries/base/Data/List.hs
• libraries/base/Data/OldList.hs
• libraries/base/Data/Ord.hs
• libraries/base/Foreign/C/String.hs
• libraries/base/Foreign/Marshal/Array.hs
• libraries/base/GHC/Base.hs
• libraries/base/GHC/Conc/Sync.hs
• libraries/base/GHC/Foreign.hs
• libraries/base/GHC/IO/Windows/Handle.hsc
• libraries/base/GHC/IORef.hs
• + libraries/base/GHC/InfoProv.hsc
• libraries/base/GHC/List.hs
• libraries/base/GHC/Pack.hs
• libraries/base/GHC/Stack/CCS.hsc
• libraries/base/GHC/Stack/CloneStack.hs
• libraries/base/GHC/TypeLits.hs
• libraries/base/GHC/TypeNats.hs
• libraries/base/GHC/Unicode.hs
• + libraries/base/GHC/Unicode/Internal/Char/DerivedCoreProperties.hs
• libraries/base/System/CPUTime/Posix/ClockGetTime.hsc
• libraries/base/aclocal.m4
• libraries/base/base.cabal
• libraries/base/cbits/sysconf.c
• libraries/base/changelog.md
• libraries/base/include/HsBase.h
• + libraries/base/tests/T15183.hs
• + libraries/base/tests/T15183.stdout
• libraries/base/tests/T7773.hs
• libraries/base/tests/all.T
• libraries/base/tests/unicode001.hs
• libraries/base/tests/unicode001.stdout
• libraries/base/tools/ucd2haskell/exe/Parser/Text.hs
• libraries/base/tools/ucd2haskell/tests/check_all_chars.py
• libraries/base/tools/ucd2haskell/tests/export_all_chars.hs
• libraries/base/tools/ucd2haskell/ucd.sh
• libraries/ghc-bignum/gmp/gmp-tarballs
• libraries/ghc-boot-th/GHC/LanguageExtensions/Type.hs
• libraries/ghc-boot/ghc-boot.cabal.in
• libraries/ghc-prim/GHC/Prim/Exception.hs
• libraries/ghc-prim/GHC/Types.hs
• libraries/haskeline
• libraries/process
• libraries/template-haskell/Language/Haskell/TH/Syntax.hs
• libraries/unix
• llvm-targets
• m4/fp_check_timer_create.m4
• + m4/fp_musttail.m4
• rts/CloneStack.c
• rts/Continuation.c
• rts/Heap.c
• rts/Hpc.c
• rts/IPE.c
• rts/IPE.h
• rts/Linker.c
• rts/Prelude.h
• rts/RtsAPI.c
• rts/RtsFlags.c
• rts/RtsMessages.c
• rts/RtsStartup.c
• rts/RtsSymbols.c
• rts/RtsUtils.c
• rts/RtsUtils.h
• rts/Schedule.c
• rts/Schedule.h
• rts/StgCRun.c
• rts/StgStdThunks.cmm
• rts/Trace.c
• rts/Trace.h
• rts/eventlog/EventLog.c
• rts/eventlog/EventLog.h
• rts/include/Cmm.h
• rts/include/Rts.h
• rts/include/RtsAPI.h
• rts/include/Stg.h
• rts/include/rts/IPE.h
• rts/include/rts/Main.h
• rts/include/rts/Messages.h
• rts/include/rts/OSThreads.h
• rts/include/rts/Threads.h
• rts/include/stg/MiscClosures.h
• rts/include/stg/SMP.h
• rts/linker/Elf.c
• rts/linker/ElfTypes.h
• + rts/linker/InitFini.c
• + rts/linker/InitFini.h
• rts/linker/M32Alloc.h
• rts/linker/PEi386.c
• rts/linker/PEi386Types.h
• rts/linker/elf_reloc_aarch64.c
• rts/linker/elf_tlsgd.c
• rts/posix/Clock.h
• rts/posix/OSThreads.c
• rts/posix/Select.c
• rts/posix/ticker/Pthread.c
• rts/posix/ticker/Setitimer.c
• rts/rts.cabal.in
• rts/sm/GC.c
• rts/sm/NonMoving.h
• rts/win32/GetTime.c
• rts/win32/OSThreads.c
• testsuite/config/ghc
• testsuite/driver/testglobals.py
• testsuite/driver/testlib.py
• testsuite/ghc-config/ghc-config.hs
• testsuite/mk/test.mk
• testsuite/tests/annotations/should_fail/all.T
• testsuite/tests/annotations/should_fail/annfail12.stderr
• testsuite/tests/annotations/should_run/all.T
• testsuite/tests/arityanal/should_compile/Arity01.stderr
• testsuite/tests/arityanal/should_compile/Arity02.stderr
• testsuite/tests/arityanal/should_compile/Arity04.stderr
• testsuite/tests/arityanal/should_compile/Arity05.stderr
• testsuite/tests/arityanal/should_compile/Arity06.stderr
• testsuite/tests/arityanal/should_compile/Arity08.stderr
• testsuite/tests/arityanal/should_compile/Arity11.stderr
• testsuite/tests/arityanal/should_compile/Arity14.stderr
• testsuite/tests/arityanal/should_compile/Arity15.stderr
• testsuite/tests/arityanal/should_compile/Arity16.stderr
• testsuite/tests/backpack/should_compile/bkp47.stderr
• testsuite/tests/backpack/should_fail/bkpfail25.stderr
• testsuite/tests/backpack/should_run/all.T
• testsuite/tests/codeGen/should_compile/Makefile
• testsuite/tests/codeGen/should_compile/T17904.hs
• testsuite/tests/codeGen/should_compile/all.T
• testsuite/tests/codeGen/should_run/T20137/all.T
• testsuite/tests/codeGen/should_run/T20735/all.T
• + testsuite/tests/codeGen/should_run/T22296.hs
• + testsuite/tests/codeGen/should_run/T22296.stdout
• testsuite/tests/codeGen/should_run/all.T
• testsuite/tests/corelint/all.T
• testsuite/tests/count-deps/CountDepsAst.stdout
• testsuite/tests/count-deps/CountDepsParser.stdout
• testsuite/tests/deSugar/should_compile/T14546d.stderr
• testsuite/tests/deSugar/should_compile/T19969.stderr
• testsuite/tests/deSugar/should_compile/T2431.stderr
• testsuite/tests/dependent/should_compile/RaeJobTalk.hs
• testsuite/tests/dependent/should_compile/all.T
• testsuite/tests/dependent/should_fail/T16326_Fail6.stderr
• testsuite/tests/dependent/should_fail/T16326_Fail8.stderr
• testsuite/tests/dependent/should_fail/T18271.stderr
• testsuite/tests/deriving/should_compile/T14094.stderr
• testsuite/tests/deriving/should_compile/T4966.stderr
• testsuite/tests/deriving/should_compile/T9968a.stderr
• testsuite/tests/deriving/should_compile/all.T
• testsuite/tests/deriving/should_compile/deriving-1935.stderr
• testsuite/tests/deriving/should_compile/drv003.stderr
• testsuite/tests/deriving/should_fail/T21871.stderr
• testsuite/tests/determinism/determ004/determ004.hs
• testsuite/tests/driver/T20300/T20300.stderr
• + testsuite/tests/driver/T20348/B.hs
• testsuite/tests/driver/T20348/Makefile
• testsuite/tests/driver/T20348/T20348.stdout
• testsuite/tests/driver/T20348/all.T
• testsuite/tests/driver/T20604/all.T
• testsuite/tests/driver/T20696/T20696.stderr
• + testsuite/tests/driver/T21722.hs
• + testsuite/tests/driver/T21722.stderr
• testsuite/tests/driver/T4437.hs
• testsuite/tests/driver/T7835/all.T
• testsuite/tests/driver/all.T
• + testsuite/tests/driver/fat-iface/Fat.hs
• + testsuite/tests/driver/fat-iface/FatMain.hs
• + testsuite/tests/driver/fat-iface/FatQuote.hs
• + testsuite/tests/driver/fat-iface/FatQuote1.hs
• + testsuite/tests/driver/fat-iface/FatQuote2.hs
• + testsuite/tests/driver/fat-iface/FatTH.hs
• + testsuite/tests/driver/fat-iface/FatTH1.hs
• + testsuite/tests/driver/fat-iface/FatTH2.hs
• + testsuite/tests/driver/fat-iface/FatTHTop.hs
• + testsuite/tests/driver/fat-iface/Makefile
• + testsuite/tests/driver/fat-iface/THA.hs
• + testsuite/tests/driver/fat-iface/THB.hs
• + testsuite/tests/driver/fat-iface/THC.hs
• + testsuite/tests/driver/fat-iface/all.T
• + testsuite/tests/driver/fat-iface/fat001.stdout
• + testsuite/tests/driver/fat-iface/fat005.stdout
• + testsuite/tests/driver/fat-iface/fat006.stdout
• + testsuite/tests/driver/fat-iface/fat008.stdout
• + testsuite/tests/driver/fat-iface/fat010.stdout
• + testsuite/tests/driver/fat-iface/fat011.stderr
• + testsuite/tests/driver/fat-iface/fat012.stderr
• + testsuite/tests/driver/fat-iface/fat013.stderr
• + testsuite/tests/driver/fat-iface/fat014.script
• + testsuite/tests/driver/fat-iface/fat014.stdout
• + testsuite/tests/driver/fat-iface/fat015.stderr
• testsuite/tests/driver/implicit-dyn-too/implicit-dyn-too.stdout
• testsuite/tests/driver/multipleHomeUnits/all.T
• testsuite/tests/driver/multipleHomeUnits/o-dir/all.T
• testsuite/tests/driver/multipleHomeUnits/th-deps/all.T
• testsuite/tests/driver/recompTH/all.T
• testsuite/tests/driver/th-new-test/all.T
• testsuite/tests/ffi/should_compile/all.T
• testsuite/tests/ffi/should_fail/all.T
• testsuite/tests/ffi/should_run/all.T
• testsuite/tests/gadt/T14719.stderr
• + testsuite/tests/gadt/T22235.hs
• testsuite/tests/gadt/all.T
• testsuite/tests/generics/all.T
• testsuite/tests/ghc-api/T18522-dbg-ppr.hs
• testsuite/tests/ghc-api/exactprint/AddDecl2.expected.hs
• testsuite/tests/ghc-api/exactprint/RmDecl7.expected.hs
• testsuite/tests/ghc-api/exactprint/RmDecl7.hs
• testsuite/tests/ghc-api/exactprint/Test20239.stderr
• testsuite/tests/ghci.debugger/scripts/T12458.stdout
• testsuite/tests/ghci.debugger/scripts/print018.stdout
• testsuite/tests/ghci/T16670/Makefile
• testsuite/tests/ghci/T16670/T16670_th.stdout
• testsuite/tests/ghci/scripts/T19667Ghci.hs
• testsuite/tests/ghci/scripts/T4175.stdout
• testsuite/tests/ghci/scripts/T5820.stderr
• testsuite/tests/ghci/scripts/T9181.stdout
• testsuite/tests/ghci/scripts/ghci019.stderr
• testsuite/tests/ghci/scripts/ghci024.stdout
• testsuite/tests/ghci/scripts/ghci024.stdout-mingw32
• testsuite/tests/ghci/scripts/ghci064.stdout
• testsuite/tests/haddock/should_compile_flag_haddock/T17544.stderr
• testsuite/tests/haddock/should_compile_flag_haddock/T17544_kw.stderr
• + testsuite/tests/hiefile/should_run/SpliceTypes.hs
• + testsuite/tests/hiefile/should_run/SpliceTypes.stdout
• testsuite/tests/hiefile/should_run/all.T
• testsuite/tests/indexed-types/should_compile/Class3.stderr
• testsuite/tests/indexed-types/should_compile/Simple2.stderr
• testsuite/tests/indexed-types/should_compile/T7837.stderr
• + testsuite/tests/indexed-types/should_fail/BadFamInstDecl.hs
• + testsuite/tests/indexed-types/should_fail/BadFamInstDecl.stderr
• + testsuite/tests/indexed-types/should_fail/BadFamInstDecl_aux.hs
• + testsuite/tests/indexed-types/should_fail/HsBootFam.hs
• + testsuite/tests/indexed-types/should_fail/HsBootFam.stderr
• + testsuite/tests/indexed-types/should_fail/HsBootFam_aux.hs
• + testsuite/tests/indexed-types/should_fail/HsBootFam_aux.hs-boot
• testsuite/tests/indexed-types/should_fail/Overlap3.stderr
• testsuite/tests/indexed-types/should_fail/Overlap7.stderr
• testsuite/tests/indexed-types/should_fail/SimpleFail7.stderr
• testsuite/tests/indexed-types/should_fail/T14033.stderr
• testsuite/tests/indexed-types/should_fail/T15870.stderr
• testsuite/tests/indexed-types/should_fail/T2334A.stderr
• testsuite/tests/indexed-types/should_fail/T3092.stderr
• testsuite/tests/indexed-types/should_fail/T7862.stderr
• testsuite/tests/indexed-types/should_fail/all.T
• testsuite/tests/lib/integer/Makefile
• testsuite/tests/lib/integer/integerGmpInternals.hs
• testsuite/tests/linear/should_compile/all.T
• testsuite/tests/linear/should_fail/LinearGADTNewtype.stderr
• testsuite/tests/linters/notes.stdout
• testsuite/tests/module/mod45.stderr
• testsuite/tests/numeric/should_compile/T19641.stderr
• testsuite/tests/numeric/should_compile/T7116.stdout
• testsuite/tests/numeric/should_run/CarryOverflow.hs
• + testsuite/tests/numeric/should_run/T22282.hs
• + testsuite/tests/numeric/should_run/T22282.stdout
• + testsuite/tests/numeric/should_run/T22282A.hs
• testsuite/tests/numeric/should_run/all.T
• + testsuite/tests/numeric/should_run/foundation.hs
• + testsuite/tests/numeric/should_run/foundation.stdout
• testsuite/tests/overloadedrecflds/should_compile/all.T
• testsuite/tests/overloadedrecflds/should_fail/all.T
• + testsuite/tests/overloadedrecflds/should_run/T11671_run.hs
• + testsuite/tests/overloadedrecflds/should_run/T11671_run.stdout
• testsuite/tests/overloadedrecflds/should_run/all.T
• testsuite/tests/package/T20010/all.T
• testsuite/tests/parser/should_compile/DumpParsedAst.stderr
• testsuite/tests/parser/should_compile/DumpRenamedAst.stderr
• testsuite/tests/parser/should_compile/DumpSemis.stderr
• testsuite/tests/parser/should_compile/T14189.stderr
• testsuite/tests/parser/should_compile/T15323.stderr
• testsuite/tests/parser/should_compile/T20452.stderr
• testsuite/tests/parser/should_compile/T2245.stderr
• testsuite/tests/parser/should_compile/all.T
• testsuite/tests/parser/should_compile/read014.stderr
• testsuite/tests/parser/should_fail/readFail008.stderr
• testsuite/tests/parser/unicode/all.T
• testsuite/tests/partial-sigs/should_fail/ExtraConstraintsWildcardInPatternSignature.stderr
• testsuite/tests/partial-sigs/should_fail/ExtraConstraintsWildcardInTypeSpliceUsed.stderr
• testsuite/tests/partial-sigs/should_fail/ExtraConstraintsWildcardNotLast.stderr
• testsuite/tests/partial-sigs/should_fail/ExtraConstraintsWildcardTwice.stderr
• testsuite/tests/partial-sigs/should_fail/NestedExtraConstraintsWildcard.stderr
• testsuite/tests/partial-sigs/should_fail/NestedNamedExtraConstraintsWildcard.stderr
• testsuite/tests/partial-sigs/should_fail/PartialClassMethodSignature.stderr
• testsuite/tests/partial-sigs/should_fail/PartialClassMethodSignature2.stderr
• testsuite/tests/partial-sigs/should_fail/T12039.stderr
• testsuite/tests/partial-sigs/should_fail/T13324_fail1.stderr
• testsuite/tests/partial-sigs/should_fail/UnnamedConstraintWildcard1.stderr
• testsuite/tests/partial-sigs/should_fail/UnnamedConstraintWildcard2.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInADT1.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInADT2.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInADT3.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInADTContext1.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInDefault.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInDefaultSignature.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInDeriving.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInForeignExport.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInForeignImport.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInGADT1.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInGADT2.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInInstanceHead.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInInstanceSig.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInNewtype.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInPatSynSig.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInStandaloneDeriving.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInTypeFamilyInstanceRHS.stderr
• testsuite/tests/partial-sigs/should_fail/WildcardInTypeSynonymRHS.stderr
• testsuite/tests/patsyn/should_run/all.T
• + testsuite/tests/perf/compiler/InfiniteListFusion.hs
• + testsuite/tests/perf/compiler/InfiniteListFusion.stdout
• testsuite/tests/perf/compiler/LargeRecord.hs
• testsuite/tests/perf/compiler/MultiLayerModulesTH_Make.stderr
• testsuite/tests/perf/compiler/MultiLayerModulesTH_OneShot.stderr
• testsuite/tests/perf/compiler/T15304.stderr
• testsuite/tests/perf/compiler/T18223.hs
• + testsuite/tests/perf/compiler/T21839c.hs
• + testsuite/tests/perf/compiler/T21839c.stdout
• testsuite/tests/perf/compiler/all.T
• testsuite/tests/perf/compiler/hard_hole_fits.stderr
• + testsuite/tests/perf/should_run/T21839r.hs
• + testsuite/tests/perf/should_run/T21839r.stdout
• testsuite/tests/perf/should_run/all.T
• testsuite/tests/polykinds/T11459.stderr
• + testsuite/tests/polykinds/T22379a.hs
• + testsuite/tests/polykinds/T22379b.hs
• testsuite/tests/polykinds/all.T
• testsuite/tests/printer/Makefile
• testsuite/tests/printer/T18791.stderr
• + testsuite/tests/printer/Test21355.hs
• testsuite/tests/printer/all.T
• testsuite/tests/profiling/should_run/staticcallstack001.hs
• testsuite/tests/profiling/should_run/staticcallstack001.stdout
• testsuite/tests/profiling/should_run/staticcallstack002.hs
• testsuite/tests/profiling/should_run/staticcallstack002.stdout
• testsuite/tests/qualifieddo/should_run/all.T
• + testsuite/tests/quantified-constraints/T22216a.hs
• + testsuite/tests/quantified-constraints/T22216b.hs
• + testsuite/tests/quantified-constraints/T22216c.hs
• + testsuite/tests/quantified-constraints/T22216d.hs
• + testsuite/tests/quantified-constraints/T22216e.hs
• + testsuite/tests/quantified-constraints/T22223.hs
• testsuite/tests/quantified-constraints/all.T
• testsuite/tests/quotes/TH_spliceViewPat/test.T
• testsuite/tests/quotes/all.T
• testsuite/tests/regalloc/regalloc_unit_tests.hs
• testsuite/tests/rename/should_compile/all.T
• testsuite/tests/rename/should_fail/all.T
• testsuite/tests/rep-poly/all.T
• testsuite/tests/rts/all.T
• testsuite/tests/rts/continuations/all.T
• + testsuite/tests/rts/continuations/cont_stack_overflow.hs
• + testsuite/tests/rts/ipe/all.T
• + testsuite/tests/rts/ipe/ipeEventLog.c
• + testsuite/tests/rts/ipe/ipeEventLog.stderr
• testsuite/tests/rts/ipeEventLog_fromMap.c → testsuite/tests/rts/ipe/ipeEventLog_fromMap.c
• + testsuite/tests/rts/ipe/ipeEventLog_fromMap.stderr
• testsuite/tests/rts/ipeMap.c → testsuite/tests/rts/ipe/ipeMap.c
• testsuite/tests/rts/ipeEventLog_lib.c → testsuite/tests/rts/ipe/ipe_lib.c
• + testsuite/tests/rts/ipe/ipe_lib.h
• − testsuite/tests/rts/ipeEventLog.c
• − testsuite/tests/rts/ipeEventLog.stderr
• − testsuite/tests/rts/ipeEventLog_fromMap.stderr
• testsuite/tests/saks/should_compile/all.T
• testsuite/tests/saks/should_fail/saks_fail003.stderr
• testsuite/tests/showIface/should_fail/THPutDocExternal.stderr
• testsuite/tests/showIface/should_fail/THPutDocNonExistent.stderr
• testsuite/tests/showIface/should_fail/all.T
• testsuite/tests/simplCore/should_compile/OpaqueNoRebox.stderr
• testsuite/tests/simplCore/should_compile/OpaqueNoSpecialise.stderr
• testsuite/tests/simplCore/should_compile/T13143.stderr
• testsuite/tests/simplCore/should_compile/T13156.hs
• testsuite/tests/simplCore/should_compile/T14152.stderr
• testsuite/tests/simplCore/should_compile/T14152a.stderr
• + testsuite/tests/simplCore/should_compile/T17366.hs
• + testsuite/tests/simplCore/should_compile/T17366.stderr
• + testsuite/tests/simplCore/should_compile/T17366_AR.hs
• + testsuite/tests/simplCore/should_compile/T17366_AR.stderr
• + testsuite/tests/simplCore/should_compile/T17366_ARa.hs
• + testsuite/tests/simplCore/should_compile/T17366a.hs
• testsuite/tests/simplCore/should_compile/T18013.stderr
• testsuite/tests/simplCore/should_compile/T18355.stderr
• testsuite/tests/simplCore/should_compile/T19890.stderr
• + testsuite/tests/simplCore/should_compile/T21148.hs
• + testsuite/tests/simplCore/should_compile/T21148.stderr
• testsuite/tests/simplCore/should_compile/T21261.hs
• testsuite/tests/simplCore/should_compile/T21261.stderr
• − testsuite/tests/simplCore/should_compile/T21261_pedantic.hs
• − testsuite/tests/simplCore/should_compile/T21261_pedantic.stderr
• + testsuite/tests/simplCore/should_compile/T21286.hs
• + testsuite/tests/simplCore/should_compile/T21286.stderr
• + testsuite/tests/simplCore/should_compile/T21286a.hs
• testsuite/tests/simplCore/should_compile/T21694b.stderr
• + testsuite/tests/simplCore/should_compile/T21851.hs
• + testsuite/tests/simplCore/should_compile/T21851.stderr
• + testsuite/tests/simplCore/should_compile/T21851a.hs
• testsuite/tests/simplCore/should_compile/T21948.stderr
• testsuite/tests/simplCore/should_compile/T21960.stderr
• + testsuite/tests/simplCore/should_compile/T22097.hs
• + testsuite/tests/simplCore/should_compile/T22097.stderr
• + testsuite/tests/simplCore/should_compile/T22097a.hs
• + testsuite/tests/simplCore/should_compile/T22357.hs
• testsuite/tests/simplCore/should_compile/T3717.stderr
• testsuite/tests/simplCore/should_compile/T3772.stdout
• testsuite/tests/simplCore/should_compile/T4201.stdout
• testsuite/tests/simplCore/should_compile/T4908.stderr
• testsuite/tests/simplCore/should_compile/T4930.stderr
• testsuite/tests/simplCore/should_compile/T6056.stderr
• testsuite/tests/simplCore/should_compile/T7360.stderr
• testsuite/tests/simplCore/should_compile/T7785.stderr
• testsuite/tests/simplCore/should_compile/T7865.stdout
• testsuite/tests/simplCore/should_compile/T8331.stderr
• testsuite/tests/simplCore/should_compile/all.T
• testsuite/tests/simplCore/should_compile/simpl020.stderr
• testsuite/tests/simplCore/should_compile/spec-inline.stderr
• testsuite/tests/simplStg/should_run/Makefile
• + testsuite/tests/simplStg/should_run/T22042.hs
• + testsuite/tests/simplStg/should_run/T22042.stdout
• + testsuite/tests/simplStg/should_run/T22042a.hs
• testsuite/tests/simplStg/should_run/all.T
• testsuite/tests/stranal/should_compile/T16029.stdout
• testsuite/tests/stranal/should_compile/T18894.stderr
• testsuite/tests/stranal/should_compile/T18894b.stderr
• testsuite/tests/stranal/should_compile/T18903.stderr
• testsuite/tests/stranal/should_compile/T20817.stderr
• testsuite/tests/stranal/should_compile/T21128.hs
• testsuite/tests/stranal/should_compile/T21128.stderr
• + testsuite/tests/stranal/should_run/T21717b.hs
• + testsuite/tests/stranal/should_run/T21717b.stdout
• testsuite/tests/stranal/should_run/T9254.hs
• testsuite/tests/stranal/should_run/all.T
• testsuite/tests/stranal/sigs/T16859.stderr
• testsuite/tests/stranal/sigs/T18957.stderr
• testsuite/tests/stranal/sigs/T19871.stderr
• testsuite/tests/stranal/sigs/T20746.stderr
• testsuite/tests/stranal/sigs/T21081.hs
• testsuite/tests/stranal/sigs/T21081.stderr
• testsuite/tests/stranal/sigs/T21119.stderr
• + testsuite/tests/stranal/sigs/T21717.hs
• + testsuite/tests/stranal/sigs/T21717.stderr
• + testsuite/tests/stranal/sigs/T21754.hs
• + testsuite/tests/stranal/sigs/T21754.stderr
• testsuite/tests/stranal/sigs/T21888.stderr
• + testsuite/tests/stranal/sigs/T22241.hs
• + testsuite/tests/stranal/sigs/T22241.stderr
• testsuite/tests/stranal/sigs/T5075.stderr
• testsuite/tests/stranal/sigs/UnsatFun.stderr
• testsuite/tests/stranal/sigs/all.T
• testsuite/tests/th/ClosedFam1TH.stderr
• testsuite/tests/th/T10279.stderr
• testsuite/tests/th/T10796b.stderr
• testsuite/tests/th/T10828a.stderr
• testsuite/tests/th/T10828b.stderr
• testsuite/tests/th/T11452.stderr
• testsuite/tests/th/T12478_4.stderr
• testsuite/tests/th/T13776.stderr
• testsuite/tests/th/T14681.stderr
• testsuite/tests/th/T15270A.stderr
• testsuite/tests/th/T15270B.stderr
• testsuite/tests/th/T16895a.stderr
• testsuite/tests/th/T16895b.stderr
• testsuite/tests/th/T16895c.stderr
• testsuite/tests/th/T16895d.stderr
• testsuite/tests/th/T16895e.stderr
• testsuite/tests/th/T16976f.stderr
• testsuite/tests/th/T17379a.stderr
• testsuite/tests/th/T17379b.stderr
• testsuite/tests/th/T17608.stderr
• testsuite/tests/th/T18740d.stderr
• testsuite/tests/th/T19470.stderr
• testsuite/tests/th/T19709d.stderr
• testsuite/tests/th/T2597b.stderr
• testsuite/tests/th/T2674.stderr
• testsuite/tests/th/T3395.stderr
• testsuite/tests/th/T5358.stderr
• testsuite/tests/th/T5976.stderr
• testsuite/tests/th/T7276.stderr
• testsuite/tests/th/T7276a.stdout
• testsuite/tests/th/T7477.stderr
• testsuite/tests/th/T7484.stderr
• testsuite/tests/th/T7667a.stderr
• testsuite/tests/th/T8759.stderr
• testsuite/tests/th/T8987.stderr
• testsuite/tests/th/TH_PromotedList.stderr
• testsuite/tests/th/TH_PromotedTuple.stderr
• testsuite/tests/th/TH_RichKinds.stderr
• testsuite/tests/th/TH_RichKinds2.stderr
• testsuite/tests/th/TH_TyInstWhere2.stderr
• testsuite/tests/th/TH_exn1.stderr
• testsuite/tests/th/TH_exn2.stderr
• testsuite/tests/th/TH_fail.stderr
• testsuite/tests/th/TH_finalizer.stderr
• + testsuite/tests/th/TH_fun_par.hs
• + testsuite/tests/th/TH_fun_par.stderr
• testsuite/tests/th/TH_implicitParamsErr1.stderr
• testsuite/tests/th/TH_implicitParamsErr2.stderr
• testsuite/tests/th/TH_implicitParamsErr3.stderr
• testsuite/tests/th/TH_invalid_add_top_decl.stderr
• testsuite/tests/th/TH_runIO.stderr
• testsuite/tests/th/all.T
• + testsuite/tests/type-data/Makefile
• + testsuite/tests/type-data/should_compile/Makefile
• + testsuite/tests/type-data/should_compile/T22315a/Lib.hs
• + testsuite/tests/type-data/should_compile/T22315a/Main.hs
• + testsuite/tests/type-data/should_compile/TDDataConstructor.hs
• + testsuite/tests/type-data/should_compile/TDExistential.hs
• + testsuite/tests/type-data/should_compile/TDGADT.hs
• + testsuite/tests/type-data/should_compile/TDGoodConsConstraints.hs
• + testsuite/tests/type-data/should_compile/TDVector.hs
• + testsuite/tests/type-data/should_compile/all.T
• + testsuite/tests/type-data/should_fail/Makefile
• + testsuite/tests/type-data/should_fail/T22332b.hs
• + testsuite/tests/type-data/should_fail/T22332b.stderr
• + testsuite/tests/type-data/should_fail/TDBadConsConstraint.hs
• + testsuite/tests/type-data/should_fail/TDBadConsConstraint.stderr
• + testsuite/tests/type-data/should_fail/TDDeriving.hs
• + testsuite/tests/type-data/should_fail/TDDeriving.stderr
• + testsuite/tests/type-data/should_fail/TDExpression.hs
• + testsuite/tests/type-data/should_fail/TDExpression.stderr
• + testsuite/tests/type-data/should_fail/TDMultiple01.hs
• + testsuite/tests/type-data/should_fail/TDMultiple01.stderr
• + testsuite/tests/type-data/should_fail/TDMultiple02.hs
• + testsuite/tests/type-data/should_fail/TDMultiple02.stderr
• + testsuite/tests/type-data/should_fail/TDNoPragma.hs
• + testsuite/tests/type-data/should_fail/TDNoPragma.stderr
• + testsuite/tests/type-data/should_fail/TDPattern.hs
• + testsuite/tests/type-data/should_fail/TDPattern.stderr
• + testsuite/tests/type-data/should_fail/TDPunning.hs
• + testsuite/tests/type-data/should_fail/TDPunning.stderr
• + testsuite/tests/type-data/should_fail/TDRecordsGADT.hs
• + testsuite/tests/type-data/should_fail/TDRecordsGADT.stderr
• + testsuite/tests/type-data/should_fail/TDRecordsH98.hs
• + testsuite/tests/type-data/should_fail/TDRecordsH98.stderr
• + testsuite/tests/type-data/should_fail/TDRecursive.hs
• + testsuite/tests/type-data/should_fail/TDRecursive.stderr
• + testsuite/tests/type-data/should_fail/TDStrictnessGADT.hs
• + testsuite/tests/type-data/should_fail/TDStrictnessGADT.stderr
• + testsuite/tests/type-data/should_fail/TDStrictnessH98.hs
• + testsuite/tests/type-data/should_fail/TDStrictnessH98.stderr
• + testsuite/tests/type-data/should_fail/all.T
• + testsuite/tests/type-data/should_run/Makefile
• + testsuite/tests/type-data/should_run/T22315b.hs
• + testsuite/tests/type-data/should_run/T22315b.script
• + testsuite/tests/type-data/should_run/T22315b.stdout
• + testsuite/tests/type-data/should_run/T22332a.hs
• + testsuite/tests/type-data/should_run/T22332a.stderr
• + testsuite/tests/type-data/should_run/all.T
• testsuite/tests/typecheck/prog001/typecheck.prog001.stderr
• testsuite/tests/typecheck/should_compile/HasKey.stderr
• testsuite/tests/typecheck/should_compile/T14774.stdout
• + testsuite/tests/typecheck/should_compile/T22310.hs
• testsuite/tests/typecheck/should_compile/T7903.stderr
• testsuite/tests/typecheck/should_compile/all.T
• testsuite/tests/typecheck/should_compile/tc078.stderr
• testsuite/tests/typecheck/should_compile/tc115.stderr
• testsuite/tests/typecheck/should_compile/tc116.stderr
• testsuite/tests/typecheck/should_compile/tc125.stderr
• testsuite/tests/typecheck/should_compile/tc126.stderr
• testsuite/tests/typecheck/should_compile/tc161.stderr
• testsuite/tests/typecheck/should_compile/tc175.stderr
• testsuite/tests/typecheck/should_fail/T15523.stderr
• testsuite/tests/typecheck/should_fail/T15796.stderr
• testsuite/tests/typecheck/should_fail/T17955.stderr
• testsuite/tests/typecheck/should_fail/T18891a.stderr
• + testsuite/tests/typecheck/should_fail/T21447.hs
• + testsuite/tests/typecheck/should_fail/T21447.stderr
• testsuite/tests/typecheck/should_fail/T21583.stderr
• testsuite/tests/typecheck/should_fail/T5051.stderr
• testsuite/tests/typecheck/should_fail/all.T
• testsuite/tests/typecheck/should_fail/tcfail156.stderr
• testsuite/tests/typecheck/should_run/T16646.hs
• testsuite/tests/typecheck/should_run/T19667.hs
• + testsuite/tests/unboxedsums/T22187.hs
• + testsuite/tests/unboxedsums/T22187_run.hs
• + testsuite/tests/unboxedsums/T22187_run.stdout
• testsuite/tests/unboxedsums/all.T
• testsuite/tests/warnings/minimal/WarnMinimal.stderr
• utils/check-exact/.ghci
• utils/check-exact/ExactPrint.hs
• utils/check-exact/Lookup.hs
• utils/check-exact/Main.hs
• + utils/check-exact/Orphans.hs
• utils/check-exact/Parsers.hs
• utils/check-exact/Preprocess.hs
• utils/check-exact/Transform.hs
• utils/check-exact/Types.hs
• utils/check-exact/Utils.hs
• utils/check-exact/check-exact.cabal
• utils/check-ppr/Main.hs
• − utils/gen-dll/Main.hs
• − utils/gen-dll/Makefile
• − utils/gen-dll/gen-dll.cabal.in
• utils/haddock
• utils/llvm-targets/gen-data-layout.sh
• utils/runghc/Main.hs
• utils/runghc/runghc.cabal.in

The diff was not included because it is too large.