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

<html lang="en">

<head>

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

<title>

GitLab

</title>

<style>img {

max-width: 100%; height: auto;

}

</style>

</head>

<body>

<div class="content">

<h3>

Simon Jakobi pushed to branch wip/sjakobi/update-containers

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

</h3>

<h4>

Commits:

</h4>

<ul>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-14T15:35:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">codeGen: Don't discard live case binders in unsafeEqualityProof logic

Previously CoreToStg would unconditionally discard cases of the form:

    case unsafeEqualityProof of wild { _ -> rhs }

and rather replace the whole thing with `rhs`. However, in some cases

(see #18227) the case binder is still live, resulting in unbound

occurrences in `rhs`. Fix this by only discarding the case if the case

binder is dead.

Fixes #18227.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-14T15:35:23-04:00</i>

</div>

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

T18227A is the original issue which gave rise to the ticket and depends

upon bytestring. T18227B is a minimized reproducer.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-14T15:35:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Fix rts include and library paths

Fixes two bugs:

 * (?) and (<>) associated in a surprising way

 * We neglected to include libdw paths in the rts configure flags

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-14T15:35:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Drop redundant GHC arguments

Cabal should already be passing this arguments to GHC.

</pre>

</li>

<li>

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

<div>

<span>by Peter Trommler</span>

<i>at 2020-06-14T15:36:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">FFI: Fix pass small ints in foreign call wrappers

The Haskell calling convention requires integer parameters smaller

than wordsize to be promoted to wordsize (where the upper bits are

don't care). To access such small integer parameter read a word from

the parameter array and then cast that word to the small integer

target type.

Fixes #15933

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/502647f7583be626319482adf4ea3d905db0006d">502647f7</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-06-14T15:37:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix "ndecreasingIndentation" in manual (#18116)

</pre>

</li>

<li>

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

<div>

<span>by Simon Jakobi</span>

<i>at 2020-06-15T13:10:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use foldl' in unionManyUniqDSets

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/761dcb84cd4c50c6fbb361eb26fb429af87392a3">761dcb84</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-06-15T13:10:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Load .lo as well.

Some archives contain so called linker objects, with the affectionate

.lo suffic.  For example the musl libc.a will come in that form.  We

still want to load those objects, hence we should not discard them and

look for .lo as well.  Ultimately we might want to fix this proerly by

looking at the file magic.

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-06-15T13:11:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">User's Guide: KnownNat evidence is Natural

This bit of documentation got outdated after commit

1fcede43d2b30f33b7505e25eb6b1f321be0407f

</pre>

</li>

<li>

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

<div>

<span>by Jan Hrček</span>

<i>at 2020-06-16T20:36:38+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix typos and formatting in user guide

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/56a9e95fd6c2f213d676c9a2bd0a6cf93c531dbb">56a9e95f</a></strong>

<div>

<span>by Jan Hrček</span>

<i>at 2020-06-16T20:36:38+02:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Jan Hrček</span>

<i>at 2020-06-16T20:36:38+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename TcHoleErrors to GHC.Tc.Errors.Hole

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-06-17T15:31:09-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Build with threaded runtime if available

See #16873.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0639dc10e214280a90dd6b75ce86cf43d1eb2286">0639dc10</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T15:31:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">T16190: only measure bytes_allocated

Just adding `{-# LANGUAGE BangPatterns #-}` makes the two other metrics

fluctuate by 13%.

</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-06-17T15:32:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs: fix formatting in users guide

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T15:33:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move CLabel assertions into smart constructors (#17957)

It avoids using DynFlags in the Outputable instance of Clabel to check

assertions at pretty-printing time.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-17T15:43:31-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-17T15:43:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Use grep -q instead of --quiet

The latter is apparently not supported by busybox.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-06-17T16:21:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Linear types (#15981)

This is the first step towards implementation of the linear types proposal

(https://github.com/ghc-proposals/ghc-proposals/pull/111).

It features

* A language extension -XLinearTypes

* Syntax for linear functions in the surface language

* Linearity checking in Core Lint, enabled with -dlinear-core-lint

* Core-to-core passes are mostly compatible with linearity

* Fields in a data type can be linear or unrestricted; linear fields

  have multiplicity-polymorphic constructors.

  If -XLinearTypes is disabled, the GADT syntax defaults to linear fields

The following items are not yet supported:

* a # m -> b syntax (only prefix FUN is supported for now)

* Full multiplicity inference (multiplicities are really only checked)

* Decent linearity error messages

* Linear let, where, and case expressions in the surface language

  (each of these currently introduce the unrestricted variant)

* Multiplicity-parametric fields

* Syntax for annotating lambda-bound or let-bound with a multiplicity

* Syntax for non-linear/multiple-field-multiplicity records

* Linear projections for records with a single linear field

* Linear pattern synonyms

* Multiplicity coercions (test LinearPolyType)

A high-level description can be found at

https://ghc.haskell.org/trac/ghc/wiki/LinearTypes/Implementation

Following the link above you will find a description of the changes made to Core.

This commit has been authored by

* Richard Eisenberg

* Krzysztof Gogolewski

* Matthew Pickering

* Arnaud Spiwack

With contributions from:

* Mark Barbone

* Alexander Vershilov

Updates haddock submodule.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

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

This implements several general performance improvements to GHC,

to offset the effect of the linear types change.

General optimisations:

- Add a `coreFullView` function which iterates `coreView` on the

  head. This avoids making function recursive solely because the

  iterate `coreView` themselves. As a consequence, this functions can

  be inlined, and trigger case-of-known constructor (_e.g._

  `kindRep_maybe`, `isLiftedRuntimeRep`, `isMultiplicityTy`,

  `getTyVar_maybe`, `splitAppTy_maybe`, `splitFunType_maybe`,

  `tyConAppTyCon_maybe`). The common pattern about all these functions

  is that they are almost always used as views, and immediately

  consumed by a case expression. This commit also mark them asx `INLINE`.

- In `subst_ty` add a special case for nullary `TyConApp`, which avoid

  allocations altogether.

- Use `mkTyConApp` in `subst_ty` for the general `TyConApp`. This

  required quite a bit of module shuffling.

  case. `myTyConApp` enforces crucial sharing, which was lost during

  substitution. See also !2952 .

- Make `subst_ty` stricter.

- In `eqType` (specifically, in `nonDetCmpType`), add a special case,

  tested first, for the very common case of nullary `TyConApp`.

  `nonDetCmpType` has been made `INLINE` otherwise it is actually a

  regression. This is similar to the optimisations in !2952.

Linear-type specific optimisations:

- Use `tyConAppTyCon_maybe` instead of the more complex `eqType` in

  the definition of the pattern synonyms `One` and `Many`.

- Break the `hs-boot` cycles between `Multiplicity.hs` and `Type.hs`:

  `Multiplicity` now import `Type` normally, rather than from the

  `hs-boot`. This way `tyConAppTyCon_maybe` can inline properly in the

  `One` and `Many` pattern synonyms.

- Make `updateIdTypeAndMult` strict in its type and multiplicity

- The `scaleIdBy` gets a specialised definition rather than being an

  alias to `scaleVarBy`

- `splitFunTy_maybe` is given the type `Type -> Maybe (Mult, Type,

  Type)` instead of `Type -> Maybe (Scaled Type, Type)`

- Remove the `MultMul` pattern synonym in favour of a view `isMultMul`

  because pattern synonyms appear not to inline well.

- in `eqType`, in a `FunTy`, compare multiplicities last: they are

  almost always both `Many`, so it helps failing faster.

- Cache `manyDataConTy` in `mkTyConApp`, to make sure that all the

  instances of `TyConApp ManyDataConTy []` are physically the same.

This commit has been authored by

* Richard Eisenberg

* Krzysztof Gogolewski

* Arnaud Spiwack

Metric Decrease:

    haddock.base

    T12227

    T12545

    T12990

    T1969

    T3064

    T5030

    T9872b

Metric Increase:

    haddock.base

    haddock.Cabal

    haddock.compiler

    T12150

    T12234

    T12425

    T12707

    T13035

    T13056

    T15164

    T16190

    T18304

    T1969

    T3064

    T3294

    T5631

    T5642

    T5837

    T6048

    T9020

    T9233

    T9675

    T9872a

    T9961

    WWRec

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/57db91d8ee501c7cf176c4bb1e2101d3092fd0f6">57db91d8</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

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

integer-simple uses lists of words (`[Word]`) to represent big numbers

instead of ByteArray#:

   * it is less efficient than the newer ghc-bignum native backend

   * it isn't compatible with the big number representation that is now

     shared by all the ghc-bignum backends (based on the one that was

     used only in integer-gmp before).

As a consequence, we simply drop integer-simple

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

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

ghc-bignum is a newer package that aims to replace the legacy

integer-simple and integer-gmp packages.

* it supports several backends. In particular GMP is still supported and

  most of the code from integer-gmp has been merged in the "gmp"

  backend.

* the pure Haskell "native" backend is new and is much faster than the

  previous pure Haskell implementation provided by integer-simple

* new backends are easier to write because they only have to provide a

  few well defined functions. All the other code is common to all

  backends. In particular they all share the efficient small/big number

  distinction previously used only in integer-gmp.

* backends can all be tested against the "native" backend with a simple

  Cabal flag. Backends are only allowed to differ in performance, their

  results should be the same.

* Add `integer-gmp` compat package: provide some pattern synonyms and

  function aliases for those in `ghc-bignum`. It is intended to avoid

  breaking packages that depend on `integer-gmp` internals.

Update submodules: text, bytestring

Metric Decrease:

    Conversions

    ManyAlternatives

    ManyConstructors

    Naperian

    T10359

    T10547

    T10678

    T12150

    T12227

    T12234

    T12425

    T13035

    T13719

    T14936

    T1969

    T4801

    T4830

    T5237

    T5549

    T5837

    T8766

    T9020

    parsing001

    space_leak_001

    T16190

    haddock.base

On ARM and i386, T17499 regresses (+6% > 5%).

On x86_64 unregistered, T13701 sometimes regresses (+2.2% > 2%).

Metric Increase:

    T17499

    T13701

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/96aa57878fd6e6a7b92e841a0df8b5255a559c97">96aa5787</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

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

Thanks to ghc-bignum, the compiler can be simplified:

* Types and constructors of Integer and Natural can be wired-in. It

  means that we don't have to query them from interfaces. It also means

  that numeric literals don't have to carry their type with them.

* The same code is used whatever ghc-bignum backend is enabled. In

  particular, conversion of bignum literals into final Core expressions

  is now much more straightforward. Bignum closure inspection too.

* GHC itself doesn't depend on any integer-* package anymore

* The `integerLibrary` setting is gone.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update `base` package

* GHC.Natural isn't implemented in `base` anymore. It is provided by

  ghc-bignum in GHC.Num.Natural. It means that we can safely use Natural

  primitives in `base` without fearing issues with built-in rewrite

  rules (cf #15286)

* `base` doesn't conditionally depend on an integer-* package anymore,

  it depends on ghc-bignum

* Some duplicated code in integer-* can now be factored in GHC.Float

* ghc-bignum tries to use a uniform naming convention so most of the

  other changes are renaming

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update `make` based build system

* replace integer-* package selection with ghc-bignum backend selection

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:04-04:00</i>

</div>

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

* support detection of slow ghc-bignum backend (to replace the detection

  of integer-simple use). There are still some test cases that the

  native backend doesn't handle efficiently enough.

* remove tests for GMP only functions that have been removed from

  ghc-bignum

* fix test results showing dependent packages (e.g. integer-gmp) or

  showing suggested instances

* fix test using Integer/Natural API or showing internal names

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:04-04:00</i>

</div>

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

* support ghc-bignum backend selection in flavours and command-line

* support ghc-bignum "--check" flag (compare results of selected backend

  against results of the native one) in flavours and command-line (e.g.

  pass --bignum=check-gmp" to check the "gmp" backend)

* remove the hack to workaround #15286

* build GMP only when the gmp backend is used

* remove hacks to workaround `text` package flags about integer-*. We

  fix `text` to use ghc-bignum unconditionally in another patch

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:04-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-06-18T23:03:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs: mention -hiedir in docs for -outputdir

[skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/729bcb02716593ae46d7baecce4776b3f353e3f7">729bcb02</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-18T23:04:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: fix build on Mac OS Catalina (#17798)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/95e18292731cd799e024976f11c18fdf34bcb777">95e18292</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-06-18T23:04:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Relax allocation threshold for T12150.

This test performs little work, so the most minor allocation

changes often cause the test to fail.

Increasing the threshold to 2% should help with this.

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-06-18T23:05:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Bump pinned cabal.project to an existent index-state

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/08c1cb0f30770acbf366423f085f8ef92f7f6a06">08c1cb0f</a></strong>

<div>

<span>by Ömer Sinan Ağacan</span>

<i>at 2020-06-18T23:06:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix uninitialized field read in Linker.c

Valgrind report of the bug when running the test `linker_unload`:

    ==29666== Conditional jump or move depends on uninitialised value(s)

    ==29666==    at 0x369C5B4: setOcInitialStatus (Linker.c:1305)

    ==29666==    by 0x369C6C5: mkOc (Linker.c:1347)

    ==29666==    by 0x36C027A: loadArchive_ (LoadArchive.c:522)

    ==29666==    by 0x36C0600: loadArchive (LoadArchive.c:626)

    ==29666==    by 0x2C144CD: ??? (in /home/omer/haskell/ghc_2/testsuite/tests/rts/linker/linker_unload.run/linker_unload)

    ==29666==

    ==29666== Conditional jump or move depends on uninitialised value(s)

    ==29666==    at 0x369C5B4: setOcInitialStatus (Linker.c:1305)

    ==29666==    by 0x369C6C5: mkOc (Linker.c:1347)

    ==29666==    by 0x369C9F6: preloadObjectFile (Linker.c:1507)

    ==29666==    by 0x369CA8D: loadObj_ (Linker.c:1536)

    ==29666==    by 0x369CB17: loadObj (Linker.c:1557)

    ==29666==    by 0x3866BC: main (linker_unload.c:33)

The problem is `mkOc` allocates a new `ObjectCode` and calls

`setOcInitialStatus` without initializing the `status` field.

`setOcInitialStatus` reads the field as first thing:

    static void setOcInitialStatus(ObjectCode* oc) {

        if (oc->status == OBJECT_DONT_RESOLVE)

          return;

        if (oc->archiveMemberName == NULL) {

            oc->status = OBJECT_NEEDED;

        } else {

            oc->status = OBJECT_LOADED;

        }

    }

`setOcInitialStatus` is unsed in two places for two different purposes:

in `mkOc` where we don't have the `status` field initialized yet (`mkOc`

is supposed to initialize it), and `loadOc` where we do have `status`

field initialized and we want to update it. Instead of splitting the

function into two functions which are both called just once I inline the

functions in the use sites and remove it.

Fixes #18342

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-06-18T23:07:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">fix windows bootstrap due to linker changes

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-18T23:07:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: store default depth in SDocContext (#17957)

It avoids having to use DynFlags to reach for pprUserLength.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-18T23:08:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move tablesNextToCode field into Platform

tablesNextToCode is a platform setting and doesn't belong into DynFlags

(#17957). Doing this is also a prerequisite to fix #14335 where we deal

with two platforms (target and host) that may have different platform

settings.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/809caedffe489931efa8c96a60eaed6d7ff739b9">809caedf</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-06-23T22:47:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Switch from HscSource to IsBootInterface for module lookup in GhcMake

We look up modules by their name, and not their contents. There is no

way to separately reference a signature vs regular module; you get what

you get. Only boot files can be referenced indepenently with `import {-#

SOURCE #-}`.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7750bd456f32c3e91b9165587fe290122b9c2444">7750bd45</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:48:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Cmm: introduce SAVE_REGS/RESTORE_REGS

We don't want to save both Fn and Dn register sets on x86-64 as they are

aliased to the same arch register (XMMn).

Moreover, when SAVE_STGREGS was used in conjunction with `jump foo [*]`

which makes a set of Cmm registers alive so that they cover all arch

registers used to pass parameter, we could have Fn, Dn and XMMn alive at

the same time. It made the LLVM code generator choke (see #17920).

Now `SAVE_REGS/RESTORE_REGS` and `jump foo [*]` use the same set of

registers.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2636794d1a1d0c4c2666d5afb002b0ba73600f8a">2636794d</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:48:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">CmmToC: don't add extern decl to parsed Cmm data

Previously, if a .cmm file *not in the RTS* contained something like:

```cmm

section "rodata" { msg : bits8[] "Test\n"; }

```

It would get compiled by CmmToC into:

```c

ERW_(msg);

const char msg[] = "Test\012";

```

and fail with:

```

/tmp/ghc32129_0/ghc_4.hc:5:12: error:

     error: conflicting types for \u2018msg\u2019

     const char msg[] = "Test\012";

                ^~~

In file included from /tmp/ghc32129_0/ghc_4.hc:3:0: error:

/tmp/ghc32129_0/ghc_4.hc:4:6: error:

     note: previous declaration of \u2018msg\u2019 was here

     ERW_(msg);

          ^

/builds/hsyl20/ghc/_build/install/lib/ghc-8.11.0.20200605/lib/../lib/x86_64-linux-ghc-8.11.0.20200605/rts-1.0/include/Stg.h:253:46: error:

     note: in definition of macro \u2018ERW_\u2019

     #define ERW_(X)   extern       StgWordArray (X)

                                                  ^

```

See the rationale for this on https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/backends/ppr-c#prototypes

Now we don't generate these extern declarations (ERW_, etc.) for

top-level data. It shouldn't change anything for the RTS (the only place

we use .cmm files) as it is already special cased in

`GHC.Cmm.CLabel.needsCDecl`. And hand-written Cmm can use explicit

extern declarations when needed.

Note that it allows `cgrun069` test to pass with CmmToC (cf #15467).

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:48:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">LLVM: refactor and comment register padding code (#17920)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:48:18-04:00</i>

</div>

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

Metric Decrease:

    T12150

    T12234

</pre>

</li>

<li>

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

<div>

<span>by Xavier Denis</span>

<i>at 2020-06-23T22:48:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix issue #18262 by zonking constraints after solving

Zonk residual constraints in checkForExistence to reveal user type

errors.

Previously when `:instances` was used with instances that have TypeError

constraints the result would look something like:

instance [safe] s0 => Err 'A -- Defined at ../Bug2.hs:8:10

whereas after zonking, `:instances` now sees the `TypeError` and

properly eliminates the constraint from the results.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/181516bcd6f18f22e1df3915bfca0c36524a725b">181516bc</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-23T22:49:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix a buglet in Simplify.simplCast

This bug, revealed by #18347, is just a missing update to

sc_hole_ty in simplCast.  I'd missed a code path when I

made the recentchanges in

    commit 6d49d5be904c0c01788fa7aae1b112d5b4dfaf1c

    Author: Simon Peyton Jones <simonpj@microsoft.com>

    Date:   Thu May 21 12:53:35 2020 +0100

    Implement cast worker/wrapper properly

The fix is very easy.

Two other minor changes

* Tidy up in SimpleOpt.simple_opt_expr. In fact I think this is an

  outright bug, introduced in the fix to #18112: we were simplifying

  the same coercion twice *with the same substitution*, which is just

  wrong.  It'd be a hard bug to trigger, so I just fixed it; less code

  too.

* Better debug printing of ApplyToVal

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/625a7f5465d51d054c6930772412bad7d87189c5">625a7f54</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-23T22:50:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Two small tweaks to Coercion.simplifyArgsWorker

These tweaks affect the inner loop of simplifyArgsWorker, which

in turn is called from the flattener in Flatten.hs.  This is

a key perf bottleneck to T9872{a,b,c,d}.

These two small changes have a modest but useful benefit.

No change in functionality whatsoever.

Relates to #18354

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:50:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't use timesInt2# with GHC < 8.11 (fix #18358)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix invalid printf format

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-06-23T22:52:09-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add missing entry to freeNamesItem (#18369)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/03a708ba8e8c323b07d8d2e0115d6eb59987cc02">03a708ba</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-06-25T03:54:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enable large address space optimization on windows.

Starting with Win 8.1/Server 2012 windows no longer preallocates

page tables for reserverd memory eagerly, which prevented us from

using this approach in the past.

We also try to allocate the heap high in the memory space.

Hopefully this makes it easier to allocate things in the low

4GB of memory that need to be there. Like jump islands for the

linker.

</pre>

</li>

<li>

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

<div>

<span>by Roland Senn</span>

<i>at 2020-06-25T03:54:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">In `:break ident` allow out of scope and nested identifiers (Fix #3000)

This patch fixes the bug and implements the feature request of #3000.

1. If `Module` is a real module name and `identifier` a name of a

top-level function in `Module` then `:break Module.identifer` works

also for an `identifier` that is out of scope.

2. Extend the syntax for `:break identifier` to:

    :break [ModQual.]topLevelIdent[.nestedIdent]...[.nestedIdent]

`ModQual` is optional and is either the effective name of a module or

the local alias of a qualified import statement.

`topLevelIdent` is the name of a top level function in the module

referenced by `ModQual`.

`nestedIdent` is optional and the name of a function nested in a let or

where clause inside the previously mentioned function `nestedIdent` or

`topLevelIdent`.

If `ModQual` is a module name, then `topLevelIdent` can be any top level

identifier in this module. If `ModQual` is missing or a local alias of a

qualified import, then `topLevelIdent` must be in scope.

Breakpoints can be set on arbitrarily deeply nested functions, but the

whole chain of nested function names must be specified.

3. To support the new functionality rewrite the code to tab complete `:break`.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/30e42652ed895c3ed086e7834be46f93ba1cc61b">30e42652</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-25T03:54:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">make: Respect XELATEX variable

Previously we simply ignored the XELATEX variable when building

PDF documentation.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-25T03:54:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian/make: Detect makeindex

Previously we would simply assume that makeindex was available.

Now we correctly detect it in `configure` and respect this conclusion in

hadrian and make.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-25T03:54:40-04:00</i>

</div>

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

GHC.Hs.Extension had

  type GhcPs   = GhcPass 'Parsed

  type GhcRn   = GhcPass 'Renamed

  type GhcTc   = GhcPass 'Typechecked

  type GhcTcId = GhcTc

The last of these, GhcTcId, is a vestige of the past.

This patch expunges it from GHC.

</pre>

</li>

<li>

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

<div>

<span>by Adam Wespiser</span>

<i>at 2020-06-25T03:54:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">add examples to Data.Traversable

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/284001d00995c82a1f2b38f696138ad683b5364b">284001d0</a></strong>

<div>

<span>by Oleg Grenrus</span>

<i>at 2020-06-25T03:54:42-04:00</i>

</div>

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

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/90f438724dbc1ef9e4b371034d44170738fe3224">90f43872</a></strong>

<div>

<span>by Zubin Duggal</span>

<i>at 2020-06-25T03:54:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Export everything from HsToCore.

This lets us reuse these functions in haddock, avoiding synchronization bugs.

Also fixed some divergences with haddock in that file

Updates haddock submodule

</pre>

</li>

<li>

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

<div>

<span>by Takenobu Tani</span>

<i>at 2020-06-25T03:54:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clean up haddock hyperlinks of GHC.* (part1)

This updates haddock comments only.

This patch focuses to update for hyperlinks in GHC API's haddock comments,

because broken links especially discourage newcomers.

This includes the following hierarchies:

  - GHC.Hs.*

  - GHC.Core.*

  - GHC.Stg.*

  - GHC.Cmm.*

  - GHC.Types.*

  - GHC.Data.*

  - GHC.Builtin.*

  - GHC.Parser.*

  - GHC.Driver.*

  - GHC top

</pre>

</li>

<li>

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

<div>

<span>by Takenobu Tani</span>

<i>at 2020-06-25T03:54:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clean up haddock hyperlinks of GHC.* (part2)

This updates haddock comments only.

This patch focuses to update for hyperlinks in GHC API's haddock comments,

because broken links especially discourage newcomers.

This includes the following hierarchies:

  - GHC.Iface.*

  - GHC.Llvm.*

  - GHC.Rename.*

  - GHC.Tc.*

  - GHC.HsToCore.*

  - GHC.StgToCmm.*

  - GHC.CmmToAsm.*

  - GHC.Runtime.*

  - GHC.Unit.*

  - GHC.Utils.*

  - GHC.SysTools.*

</pre>

</li>

<li>

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

<div>

<span>by Oleg Grenrus</span>

<i>at 2020-06-25T03:54:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add MonadZip and MonadFix instances for Complex

These instances are taken from

https://hackage.haskell.org/package/linear-1.21/docs/Linear-Instances.html

They are the unique possible, so let they be in `base`.

</pre>

</li>

<li>

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

<div>

<span>by Artem Pelenitsyn</span>

<i>at 2020-06-25T03:54:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">test suite: add reproducer for #17516

</pre>

</li>

<li>

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

<div>

<span>by Roland Senn</span>

<i>at 2020-06-25T03:54:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enable maxBound checks for OverloadedLists (Fixes #18172)

Consider the Literal `[256] :: [Data.Word.Word8]`

When the `OverloadedLists` extension is not active, then the `ol_ext` field

in the `OverLitTc` record that is passed to the function `getIntegralLit`

contains the type `Word8`. This is a simple type, and we can use its

type constructor immediately for the `warnAboutOverflowedLiterals` function.

When the `OverloadedLists` extension is active, then the `ol_ext` field

contains the type family `Item [Word8]`. The function `nomaliseType` is used

to convert it to the needed type `Word8`.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-25T03:54:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Hash: Simplify freeing of HashListChunks

While looking at #18348 I noticed that the treatment of HashLists are a

bit more complex than necessary (which lead to some initial confusion on

my part). Specifically, we allocate HashLists in chunks. Each chunk

allocation makes two allocations: one for the chunk itself and one for a

HashListChunk to link together the chunks for the purposes of freeing.

Simplify this (and hopefully make the relationship between these

clearer) but allocating the HashLists and HashListChunk in a single

malloc. This will both make the implementation easier to follow and

reduce C heap fragmentation.

Note that even after this patch we fail to bound the size of the free

HashList pool. However, this is a separate bug.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-25T03:54:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">RTS: avoid overflow on 32-bit arch (#18375)

We're now correctly computing allocated bytes on 32-bit arch, so we get

huge increases.

Metric Increase:

    haddock.Cabal

    haddock.base

    haddock.compiler

    space_leak_001

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-06-25T23:06:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">GHC.Core.Unify: Make UM actions one-shot by default

This MR makes the UM monad in GHC.Core.Unify into a one-shot

monad.  See the long Note [The one-shot state monad trick].

See also #18202 and !3309, which applies this to all Reader/State-like

monads in GHC for compile-time perf improvements. The pattern used

here enables something similar to the state-hack, but is applicable to

user-defined monads, not just `IO`.

Metric Decrease 'runtime/bytes allocated' (test_env='i386-linux-deb9'):

    haddock.Cabal

</pre>

</li>

<li>

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

<div>

<span>by Matthias Pall Gissurarson</span>

<i>at 2020-06-26T17:12:45+00:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement the proposed -XQualifiedDo extension

Co-authored-by: Facundo Domínguez <facundo.dominguez@tweag.io>

QualifiedDo is implemented using the same placeholders for operation names in

the AST that were devised for RebindableSyntax. Whenever the renamer checks

which names to use for do syntax, it first checks if the do block is qualified

(e.g. M.do { stmts }), in which case it searches for qualified names in

the module M.

This allows users to write

    {-# LANGUAGE QualifiedDo #-}

    import qualified SomeModule as M

    f x = M.do           -- desugars to:

      y <- M.return x    -- M.return x M.>>= \y ->

      M.return y         -- M.return y M.>>

      M.return y         -- M.return y

See Note [QualifiedDo] and the users' guide for more details.

Issue #18214

Proposal:

https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0216-qualified-do.rst

Since we change the constructors `ITdo` and `ITmdo` to carry the new module

name, we need to bump the haddock submodule to account or the new shape of

these constructors.

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-27T11:55:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Revamp the treatment of auxiliary bindings for derived instances

This started as a simple fix for #18321 that organically grew into a

much more sweeping refactor of how auxiliary bindings for derived

instances are handled. I have rewritten `Note [Auxiliary binders]`

in `GHC.Tc.Deriv.Generate` to explain all of the moving parts, but

the highlights are:

* Previously, the OccName of each auxiliary binding would be given

  a suffix containing a hash of its package name, module name, and

  parent data type to avoid name clashes. This was needlessly

  complicated, so we take the more direct approach of generating

  `Exact` `RdrName`s for each auxiliary binding with the same

  `OccName`, but using an underlying `System` `Name` with a fresh

  `Unique` for each binding. Unlike hashes, allocating new `Unique`s

  does not require any cleverness and avoid name clashes all the

  same...

* ...speaking of which, in order to convince the renamer that multiple

  auxiliary bindings with the same `OccName` (but different

  `Unique`s) are kosher, we now use `rnLocalValBindsLHS` instead of

  `rnTopBindsLHS` to rename auxiliary bindings. Again, see

  `Note [Auxiliary binders]` for the full story.

* I have removed the `DerivHsBind` constructor for

  `DerivStuff`—which was only used for `Data.Data`-related

  auxiliary bindings—and refactored `gen_Data_binds` to use

  `DerivAuxBind` instead. This brings the treatment of

  `Data.Data`-related auxiliary bindings in line with every other

  form of auxiliary binding.

Fixes #18321.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-27T11:55:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-bignum: fix division by zero (#18359)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-27T11:55:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix ghc-bignum exceptions

We must ensure that exceptions are not simplified. Previously we used:

   case raiseDivZero of

      _ -> 0## -- dummyValue

But it was wrong because the evaluation of `raiseDivZero` was removed and

the dummy value was directly returned. See new Note [ghc-bignum exceptions].

I've also removed the exception triggering primops which were fragile.

We don't need them to be primops, we can have them exported by ghc-prim.

I've also added a test for #18359 which triggered this patch.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-27T11:56:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Better loop detection in findTypeShape

Andreas pointed out, in !3466, that my fix for #18304 was not

quite right.  This patch fixes it properly, by having just one

RecTcChecker rather than (implicitly) two nested ones, in

findTypeShape.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-27T11:57:11-04:00</i>

</div>

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

`DynFlags.buildTag` was a field created from the set of Ways in

`DynFlags.ways`. It had to be kept in sync with `DynFlags.ways` which

was fragile. We want to avoid global state like this (#17957).

Moreover in #14335 we also want to support loading units with different

ways: target units would still use `DynFlags.ways` but plugins would use

`GHC.Driver.Ways.hostFullWays`. To avoid having to deal both with build

tag and with ways, we recompute the buildTag on-the-fly (should be

pretty cheap) and we remove `DynFlags.buildTag` field.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-06-27T11:57:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't generalize when typechecking a tuple section

The code is simpler and cleaner.

</pre>

</li>

<li>

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

<div>

<span>by Peter Trommler</span>

<i>at 2020-06-28T09:19:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">RTS: Refactor Haskell-C glue for PPC 64-bit

Make sure the stack is 16 byte aligned even when reserved stack

bytes are not a multiple of 16 bytes.

Avoid saving r2 (TOC). On ELF v1 the function descriptor of StgReturn

has the same TOC as StgRun, on ELF v2 the TOC is recomputed in the

function prologue.

Use the ABI provided functions to save clobbered GPRs and FPRs.

Improve comments. Describe what the stack looks like and how it relates

to the respective ABIs.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/42f797b0ad034a92389e7081aa50ef4ab3434d01">42f797b0</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-28T09:19:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use NHsCoreTy to embed types into GND-generated code

`GeneralizedNewtypeDeriving` is in the unique situation where it must

produce an `LHsType GhcPs` from a Core `Type`. Historically, this was

done with the `typeToLHsType` function, which walked over the entire

`Type` and attempted to construct an `LHsType` with the same overall

structure. `typeToLHsType` is quite complicated, however, and has

been the subject of numerous bugs over the years (e.g., #14579).

Luckily, there is an easier way to accomplish the same thing: the

`XHsType` constructor of `HsType`. `XHsType` bundles an `NHsCoreTy`,

which allows embedding a Core `Type` directly into an `HsType`,

avoiding the need to laboriously convert from one to another (as

`typeToLHsType` did). Moreover, renaming and typechecking an

`XHsType` is simple, since one doesn't need to do anything to a

Core `Type`...

...well, almost. For the reasons described in

`Note [Typechecking NHsCoreTys]` in `GHC.Tc.Gen.HsType`, we must

apply a substitution that we build from the local `tcl_env` type

environment. But that's a relatively modest price to pay.

Now that `GeneralizedNewtypeDeriving` uses `NHsCoreTy`, the

`typeToLHsType` function no longer has any uses in GHC, so this patch

rips it out. Some additional tweaks to `hsTypeNeedsParens` were

necessary to make the new `-ddump-deriv` output correctly

parenthesized, but other than that, this patch is quite

straightforward.

This is a mostly internal refactoring, although it is likely that

`GeneralizedNewtypeDeriving`-generated code will now need fewer

language extensions in certain situations than it did before.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/68530b1cd45629e5a353a37df80195ac54d26ade">68530b1c</a></strong>

<div>

<span>by Jan Hrček</span>

<i>at 2020-06-28T09:20:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix duplicated words and typos in comments and user guide

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-28T09:20:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add integer-gmp's ghc.mk and GNUmakefile to .gitignore

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-28T09:21:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix a typo in Lint

This simple error in GHC.Core.Litn.lintJoinLams meant that

Lint reported bogus errors.

Fixes #18399

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-30T07:10:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Reject nested foralls/contexts in instance types more consistently

GHC is very wishy-washy about rejecting instance declarations with

nested `forall`s or contexts that are surrounded by outermost

parentheses. This can even lead to some strange interactions with

`ScopedTypeVariables`, as demonstrated in #18240. This patch makes

GHC more consistently reject instance types with nested

`forall`s/contexts so as to prevent these strange interactions.

On the implementation side, this patch tweaks `splitLHsInstDeclTy`

and `getLHsInstDeclHead` to not look through parentheses, which can

be semantically significant. I've added a

`Note [No nested foralls or contexts in instance types]` in

`GHC.Hs.Type` to explain why. This also introduces a

`no_nested_foralls_contexts_err` function in `GHC.Rename.HsType` to

catch nested `forall`s/contexts in instance types. This function is

now used in `rnClsInstDecl` (for ordinary instance declarations) and

`rnSrcDerivDecl` (for standalone `deriving` declarations), the latter

of which fixes #18271.

On the documentation side, this adds a new

"Formal syntax for instance declaration types" section to the GHC

User's Guide that presents a BNF-style grammar for what is and isn't

allowed in instance types.

Fixes #18240. Fixes #18271.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-30T07:10:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add ghc-bignum to 8.12 release notes

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/81704a6f3b155b0bfbc20f53cd821be3cb9006a7">81704a6f</a></strong>

<div>

<span>by David Eichmann</span>

<i>at 2020-06-30T07:10:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update ssh keys in CI performance metrics upload script

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/85310fb83fdb7d7294bd453026102fc42000bf14">85310fb8</a></strong>

<div>

<span>by Joshua Price</span>

<i>at 2020-06-30T07:10:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add missing Ix instances for tuples of size 6 through 15 (#16643)

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-07-01T15:41:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement -XLexicalNegation (GHC Proposal #229)

This patch introduces a new extension, -XLexicalNegation, which detects

whether the minus sign stands for negation or subtraction using the

whitespace-based rules described in GHC Proposal #229.

Updates haddock submodule.

</pre>

</li>

<li>

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

<div>

<span>by Martin Handley</span>

<i>at 2020-07-01T15:42:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">#17169: Clarify Fixed's Enum instance.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-01T15:42:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve debug tracing for substitution

This patch improves debug tracing a bit (#18395)

* Remove the ancient SDoc argument to substitution, replacing it

  with a HasDebugCallStack constraint. The latter does the same

  job (indicate the call site) but much better.

* Add HasDebugCallStack to simpleOptExpr, exprIsConApp_maybe

  I needed this to help nail the lookupIdSubst panic in

  #18326, #17784

</pre>

</li>

<li>

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

<div>

<span>by Hécate</span>

<i>at 2020-07-01T15:43:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add most common return values for `os` and `arch`

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-07-01T15:44:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Desugar quoted uses of DerivingVia and expression type signatures properly

The way that `GHC.HsToCore.Quote` desugared quoted `via` types (e.g.,

`deriving via forall a. [a] instance Eq a => Eq (List a)`) and

explicit type annotations in signatures (e.g.,

`f = id @a :: forall a. a -> a`) was completely wrong, as it did not

implement the scoping guidelines laid out in

`Note [Scoped type variables in bindings]`. This is easily fixed.

While I was in town, I did some minor cleanup of related Notes:

* `Note [Scoped type variables in bindings]` and

  `Note [Scoped type variables in class and instance declarations]`

  say very nearly the same thing. I decided to just consolidate the

  two Notes into `Note [Scoped type variables in quotes]`.

* `Note [Don't quantify implicit type variables in quotes]` is

  somewhat outdated, as it predates GHC 8.10, where the

  `forall`-or-nothing rule requires kind variables to be explicitly

  quantified in the presence of an explicit `forall`. As a result,

  the running example in that Note doesn't even compile. I have

  changed the example to something simpler that illustrates the

  same point that the original Note was making.

Fixes #18388.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/44d6a3352d708785b75aeb616bfc7efff839184e">44d6a335</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-02T02:54:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">T16012: Be verbose on failure.

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-07-02T02:55:29-04:00</i>

</div>

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

Fixes #18279. Bumps the `text` submodule.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/23e4e04700f840e3c4e75ccb2085aea05bfb5318">23e4e047</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-02T10:46:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: fix PowerPC64le support (#17601)

[ci skip]

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-02T10:47:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">NCG: correctly handle addresses with huge offsets (#15570)

Before this patch we could generate addresses of this form:

   movzbl cP0_str+-9223372036854775808,%eax

The linker can't handle them because the offset is too large:

   ld.lld: error: Main.o:(.text+0xB3): relocation R_X86_64_32S out of range: -9223372036852653050 is not in [-2147483648, 2147483647]

With this patch we detect those cases and generate:

   movq $-9223372036854775808,%rax

   addq $cP0_str,%rax

   movzbl (%rax),%eax

I've also refactored `getAmode` a little bit to make it easier to

understand and to trace.

</pre>

</li>

<li>

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

<div>

<span>by Gabor Greif</span>

<i>at 2020-07-02T20:07:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">No need for CURSES_INCLUDE_DIRS

This is a leftover from ef63ff27251a20ff11e58c9303677fa31e609a88</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-02T20:08:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Replace Opt_SccProfilingOn flag with sccProfilingEnabled helper function

SCC profiling was enabled in a convoluted way: if WayProf was enabled,

Opt_SccProfilingOn general flag was set (in

`GHC.Driver.Ways.wayGeneralFlags`), and then this flag was queried in

various places.

There is no need to go via general flags, so this patch defines a

`sccProfilingEnabled :: DynFlags -> Bool` helper function that just

checks whether WayProf is enabled.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-03T02:49:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/ProfHeap: Only allocate the Censuses that we need

When not LDV profiling there is no reason to allocate 32 Censuses; one

will do. This is a very small memory footprint optimisation, but it

comes for free.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-03T02:49:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/ProfHeap: Free old allocations when reinitialising Censuses

Previously when not LDV profiling we would repeatedly reinitialise

`censuses[0]` with `initEra`. This failed to free the `Arena` and

`HashTable` from the old census, resulting in a memory leak.

Fixes #18348.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/34be6523a220b2be972b391d8ad26b75f7c26eb1">34be6523</a></strong>

<div>

<span>by Valery Tolstov</span>

<i>at 2020-07-03T02:50:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Mention flags that are not enabled by -Wall (#18372)

* Mention missing flags that are not actually enabled by -Wall (docs/users_guide/using-warnings.rst)

* Additionally remove -Wmissing-monadfail-instances from the list of flags enabled by -Wcompat, as it is not the case since 8.8

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-03T02:50:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">LLVM: support R9 and R10 registers

d535ef006d85dbdb7cda2b09c5bc35cb80108909 allowed the use of up to 10

vanilla registers but didn't update LLVM backend to support them. This

patch fixes it.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-03T08:37:42+01:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve handling of data type return kinds

Following a long conversation with Richard, this patch tidies up the

handling of return kinds for data/newtype declarations (vanilla,

family, and instance).

I have substantially edited the Notes in TyCl, so they would

bear careful reading.

Fixes #18300, #18357

In GHC.Tc.Instance.Family.newFamInst we were checking some Lint-like

properties with ASSSERT.  Instead Richard and I have added

a proper linter for axioms, and called it from lintGblEnv, which in

turn is called in tcRnModuleTcRnM

New tests (T18300, T18357) cause an ASSERT failure in HEAD.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/41d2649288a5debcb4c8003e54b7d3072ab951c5">41d26492</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-03T17:33:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: avoid the use of sdocWithDynFlags in GHC.Core.Rules (#17957)

</pre>

</li>

<li>

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

<div>

<span>by Hécate</span>

<i>at 2020-07-03T17:34:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add the __GHC_FULL_VERSION__ CPP macro to expose the full GHC version

</pre>

</li>

<li>

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

<div>

<span>by Chaitanya Koparkar</span>

<i>at 2020-07-07T13:55:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-prim: Turn some comments into haddocks

[ci skip]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/37743f91a3f5018a8894ca6d35e8b423e4e08b50">37743f91</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-07-07T13:56:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Support `timesInt2#` in LLVM backend

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/46397e530e1b107c6b8932f7ca79ebab53a3249a">46397e53</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-07-07T13:56:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">`genericIntMul2Op`: Call `genericWordMul2Op` directly

This unblocks a refactor, and removes partiality. It might be a PowerPC

regression but that should be fixable.

</pre>

</li>

<li>

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

<div>

<span>by John Ericson</span>

<i>at 2020-07-07T13:56:00-04:00</i>

</div>

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

Follow @simonpj's suggestion of pushing the "into regs" logic into

`emitPrimOp`. With the previous commit getting rid of the recursion in

`genericIntMul2Op`, this is now an easy refactor.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6607f203fb9ad11af1463145810e1bd3c6c4f2c8">6607f203</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-07-07T13:56:00-04:00</i>

</div>

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

The old name was and terrible and became worse after the previous

commit's refactor moved non-trivial funcationlity into its body.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-07T13:56:00-04:00</i>

</div>

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

We shouldn't directly call 'genericWordMul2Op' in genericIntMul2Op

because a target may provide a faster primop for 'WordMul2Op': we'd

better use it!

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/686e72253aed3880268dd6858eadd8c320f09e97">686e7225</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-07T13:56:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[linker/rtsSymbols] More linker symbols

Mostly symbols needed for aarch64/armv7l

and in combination with musl, where we have

to rely on loading *all* objects/archives

- __stack_chk_* only when not DYNAMIC

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-07T13:56:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">better if guards.

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-07T13:56:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix (1)

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-07T13:56:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">AArch32 symbols only on aarch32.

</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-07-07T13:56:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">add -flink-rts flag to link the rts when linking a shared or static library #18072

By default we don't link the RTS when linking shared libraries because in the

most usual mode a shared library is an intermediary product, for example a

Haskell library, that will be linked into some executable in the end. So we

wish to defer the RTS flavour to link to the final link.

However sometimes the final product is the shared library, for example when

writing a plugin for some other system, so we do wish the shared library to

link the RTS.

For consistency we also make -staticlib honor this flag and its inversion.

-staticlib currently implies -flink-shared.

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-07-07T13:56:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: link check-ppr against debugging RTS if ghcDebugged

</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-07-07T13:56:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts linker: teach the linker about GLIBC's special handling of *stat, mknod and atexit functions #7072

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9615343363a68313c4bfdb068696002ecca7786e">96153433</a></strong>

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-07-07T13:56:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: make hadrian/ghci use the bootstrap compiler from configure #18190

</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-07-07T13:56:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: ignore cabal configure verbosity related flags #18131

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7332bbffee9e2a712508540200eb52ed3d227426">7332bbff</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-07T13:56:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Widen T12234 acceptance window to 2%

Previously it wasn't uncommon to see +/-1% fluctuations in compiler

allocations on this test.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/180b63136f25d9fedb764cb9bc23637e7781ed4e">180b6313</a></strong>

<div>

<span>by Gabor Greif</span>

<i>at 2020-07-07T13:56:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">When running libtool, report it as such</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-07T13:56:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">BigNum: rename BigNat types

Before this patch BigNat names were confusing because we had:

* GHC.Num.BigNat.BigNat: unlifted type used everywhere else

* GHC.Num.BigNat.BigNatW: lifted type only used to share static constants

* GHC.Natural.BigNat: lifted type only used for backward compatibility

After this patch we have:

* GHC.Num.BigNat.BigNat#: unlifted type

* GHC.Num.BigNat.BigNat: lifted type (reexported from GHC.Natural)

Thanks to @RyanGlScott for spotting this.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/929d26db3080ec49ab67690952a316fc082b479f">929d26db</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-07T13:56:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: don't build ghc-bignum with stage0

Noticed by @Ericson2314

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-07T13:56:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: ghc-gmp.h shouldn't be a compiler dependency

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-07T13:56:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: factor out pprUnitId from "Outputable UnitId" instance

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/204f3f5ddec56403bfb12e74291b3b1d14824138">204f3f5d</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-07-07T13:56:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove unused function pprHsForAllExtra (#18423)

The function `pprHsForAllExtra` was called only on `Nothing`

since 2015 (1e041b7382b6aa).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3033e0e4940e6ecc43f478f1dcfbd0c3cb1e3ef8">3033e0e4</a></strong>

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-07-08T20:36:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: add flag to skip rebuilding dependency information #17636

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-07-09T09:49:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix GHCi :print on big-endian platforms

On big-endian platforms executing

  import GHC.Exts

  data Foo = Foo Float# deriving Show

  foo = Foo 42.0#

  foo

  :print foo

results in an arithmetic overflow exception which is caused by function

index where moveBytes equals

  word_size - (r + item_size_b) * 8

Here we have a mixture of units. Both, word_size and item_size_b have

unit bytes whereas r has unit bits.  On 64-bit platforms moveBytes

equals then

  8 - (0 + 4) * 8

which results in a negative and therefore invalid second parameter for a

shiftL operation.

In order to make things more clear the expression

  (word .&. (mask `shiftL` moveBytes)) `shiftR` moveBytes

is equivalent to

  (word `shiftR` moveBytes) .&. mask

On big-endian platforms the shift must be a left shift instead of a

right shift. For symmetry reasons not a mask is used but two shifts in

order to zero out bits. Thus the fixed version equals

  case endian of

    BigEndian    -> (word `shiftL` moveBits) `shiftR` zeroOutBits `shiftL` zeroOutBits

    LittleEndian -> (word `shiftR` moveBits) `shiftL` zeroOutBits `shiftR` zeroOutBits

Fixes #16548 and #14455

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3656dff8259199d0dab2d1a1f1b887c252a9c1a3">3656dff8</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-09T09:50:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">LLVM: fix MO_S_Mul2 support (#18434)

The value indicating if the carry is useful wasn't taken into account.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-10T10:33:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Define multiShotIO and use it in mkSplitUniqueSupply

This patch is part of the ongoing eta-expansion saga;

see #18238.

It implements a neat trick (suggested by Sebastian Graf)

that allows the programmer to disable the default one-shot behaviour

of IO (the "state hack").  The trick is to use a new multiShotIO

function; see Note [multiShotIO].  For now, multiShotIO is defined

here in Unique.Supply; but it should ultimately be moved to the IO

library.

The change is necessary to get good code for GHC's unique supply;

see Note [Optimising the unique supply].

However it makes no difference to GHC as-is.  Rather, it makes

a difference when a subsequent commit

   Improve eta-expansion using ArityType

lands.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-10T10:33:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make arityType deal with join points

As Note [Eta-expansion and join points] describes,

this patch makes arityType deal correctly with join points.

What was there before was not wrong, but yielded lower

arities than it could.

Fixes #18328

In base GHC this makes no difference to nofib.

        Program           Size    Allocs   Runtime   Elapsed  TotalMem

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

         n-body          -0.1%     -0.1%     -1.2%     -1.1%      0.0%

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

            Min          -0.1%     -0.1%    -55.0%    -56.5%      0.0%

            Max          -0.0%      0.0%    +16.1%    +13.4%      0.0%

 Geometric Mean          -0.0%     -0.0%    -30.1%    -31.0%     -0.0%

But it starts to make real difference when we land the change to the

way mkDupableAlts handles StrictArg, in fixing #13253 and friends.

I think this is because we then get more non-inlined join points.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-11T12:17:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve eta-expansion using ArityType

As #18355 shows, we were failing to preserve one-shot info when

eta-expanding.  It's rather easy to fix, by using ArityType more,

rather than just Arity.

This patch is important to suport the one-shot monad trick;

see #18202.  But the extra tracking of one-shot-ness requires

the patch

   Define multiShotIO and use it in mkSplitUniqueSupply

If that patch is missing, ths patch makes things worse in

GHC.Types.Uniq.Supply.  With it, however, we see these improvements

    T3064     compiler bytes allocated -2.2%

    T3294     compiler bytes allocated -1.3%

    T12707    compiler bytes allocated -1.3%

    T13056    compiler bytes allocated -2.2%

Metric Decrease:

    T3064

    T3294

    T12707

    T13056

</pre>

</li>

<li>

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

<div>

<span>by Artem Pelenitsyn</span>

<i>at 2020-07-12T02:53:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">add reproducer for #15630

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-12T02:53:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Give Uniq[D]FM a phantom type for its key.

This fixes #17667 and should help to avoid such issues going forward.

The changes are mostly mechanical in nature. With two notable

exceptions.

* The register allocator.

  The register allocator references registers by distinct uniques.

  However they come from the types of VirtualReg, Reg or Unique in

  various places. As a result we sometimes cast the key type of the

  map and use functions which operate on the now typed map but take

  a raw Unique as actual key. The logic itself has not changed it

  just becomes obvious where we do so now.

* <Type>Env Modules.

As an example a ClassEnv is currently queried using the types `Class`,

`Name`, and `TyCon`. This is safe since for a distinct class value all

these expressions give the same unique.

    getUnique cls

    getUnique (classTyCon cls)

    getUnique (className cls)

    getUnique (tcName $ classTyCon cls)

This is for the most part contained within the modules defining the

interface. However it requires us to play dirty when we are given a

`Name` to lookup in a `UniqFM Class a` map. But again the logic did

not change and it's for the most part hidden behind the Env Module.

Some of these cases could be avoided by refactoring but this is left

for future work.

We also bump the haddock submodule as it uses UniqFM.

</pre>

</li>

<li>

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

<div>

<span>by Aaron Allen</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Warn about empty Char enumerations (#18402)

Currently the "Enumeration is empty" warning (-Wempty-enumerations)

only fires for numeric literals. This patch adds support for `Char`

literals so that enumerating an empty list of `Char`s will also

trigger the warning.

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-07-13T09:01:10-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: build check-ppr dynamic if GHC is build dynamic

Fixes #18361

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-13T14:52:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use dumpStyle when printing inlinings

This just makes debug-printing consistent,

and more informative.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-13T14:52:49-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-13T14:52:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Reduce result discount in conSize

Ticket #18282 showed that the result discount given by conSize

was massively too large.  This patch reduces that discount to

a constant 10, which just balances the cost of the constructor

application itself.

Note [Constructor size and result discount] elaborates, as

does the ticket #18282.

Reducing result discount reduces inlining, which affects perf.  I

found that I could increase the unfoldingUseThrehold from 80 to 90 in

compensation; in combination with the result discount change I get

these overall nofib numbers:

        Program           Size    Allocs   Runtime   Elapsed  TotalMem

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

          boyer          -0.2%     +5.4%     -3.2%     -3.4%      0.0%

       cichelli          -0.1%     +5.9%    -11.2%    -11.7%      0.0%

      compress2          -0.2%     +9.6%     -6.0%     -6.8%      0.0%

   cryptarithm2          -0.1%     -3.9%     -6.0%     -5.7%      0.0%

         gamteb          -0.2%     +2.6%    -13.8%    -14.4%      0.0%

         genfft          -0.1%     -1.6%    -29.5%    -29.9%      0.0%

             gg          -0.0%     -2.2%    -17.2%    -17.8%    -20.0%

           life          -0.1%     -2.2%    -62.3%    -63.4%      0.0%

           mate          +0.0%     +1.4%     -5.1%     -5.1%    -14.3%

         parser          -0.2%     -2.1%     +7.4%     +6.7%      0.0%

      primetest          -0.2%    -12.8%    -14.3%    -14.2%      0.0%

         puzzle          -0.2%     +2.1%    -10.0%    -10.4%      0.0%

            rsa          -0.2%    -11.7%     -3.7%     -3.8%      0.0%

         simple          -0.2%     +2.8%    -36.7%    -38.3%     -2.2%

   wheel-sieve2          -0.1%    -19.2%    -48.8%    -49.2%    -42.9%

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

            Min          -0.4%    -19.2%    -62.3%    -63.4%    -42.9%

            Max          +0.3%     +9.6%     +7.4%    +11.0%    +16.7%

 Geometric Mean          -0.1%     -0.3%    -17.6%    -18.0%     -0.7%

I'm ok with these numbers, remembering that this change removes

an *exponential* increase in code size in some in-the-wild cases.

I investigated compress2.  The difference is entirely caused by this

function no longer inlining

WriteRoutines.$woutputCodes

  = \ (w :: [CodeEvent]) ->

      let result_s1Sr

            = case WriteRoutines.outputCodes_$s$woutput w 0# 0# 8# 9# of

                (# ww1, ww2 #) -> (ww1, ww2)

      in (# case result_s1Sr of (x, _) ->

              map @Int @Char WriteRoutines.outputCodes1 x

         , case result_s1Sr of { (_, y) -> y } #)

It was right on the cusp before, driven by the excessive result

discount.  Too bad!

Happily, the compiler/perf tests show a number of improvements:

    T12227     compiler bytes-alloc  -6.6%

    T12545     compiler bytes-alloc  -4.7%

    T13056     compiler bytes-alloc  -3.3%

    T15263     runtime  bytes-alloc -13.1%

    T17499     runtime  bytes-alloc -14.3%

    T3294      compiler bytes-alloc  -1.1%

    T5030      compiler bytes-alloc -11.7%

    T9872a     compiler bytes-alloc  -2.0%

    T9872b     compiler bytes-alloc  -1.2%

    T9872c     compiler bytes-alloc  -1.5%

Metric Decrease:

    T12227

    T12545

    T13056

    T15263

    T17499

    T3294

    T5030

    T9872a

    T9872b

    T9872c

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-13T14:52:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Widen acceptance threshold on T5837

This test is positively tiny and consequently the bytes allocated

measurement will be relatively noisy. Consequently I have seen this

fail spuriously quite often.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/118e1c3da622f17c67b4e0fbc12ed7c7084055dc">118e1c3d</a></strong>

<div>

<span>by Alp Mestanogullari</span>

<i>at 2020-07-14T21:30:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">compiler: re-engineer the treatment of rebindable if

Executing on the plan described in #17582, this patch changes the way if expressions

are handled in the compiler in the presence of rebindable syntax. We get rid of the

SyntaxExpr field of HsIf and instead, when rebindable syntax is on, we rewrite the HsIf

node to the appropriate sequence of applications of the local `ifThenElse` function.

In order to be able to report good error messages, with expressions as they were

written by the user (and not as desugared by the renamer), we make use of TTG

extensions to extend GhcRn expression ASTs with an `HsExpansion` construct, which

keeps track of a source (GhcPs) expression and the desugared (GhcRn) expression that

it gives rise to. This way, we can typecheck the latter while reporting the former in

error messages.

In order to discard the error context lines that arise from typechecking the desugared

expressions (because they talk about expressions that the user has not written), we

carefully give a special treatment to the nodes fabricated by this new renaming-time

transformation when typechecking them. See Note [Rebindable syntax and HsExpansion]

for more details. The note also includes a recipe to apply the same treatment to

other rebindable constructs.

Tests 'rebindable11' and 'rebindable12' have been added to make sure we report

identical error messages as before this patch under various circumstances.

We also now disable rebindable syntax when processing untyped TH quotes, as per

the discussion in #18102 and document the interaction of rebindable syntax and

Template Haskell, both in Note [Template Haskell quotes and Rebindable Syntax]

and in the user guide, adding a test to make sure that we do not regress in

that regard.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/64c774b043a2d9be3b98e445990c795f070dab3f">64c774b0</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-14T21:31:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Explain why keeping DynFlags in AnalEnv saves allocation.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/254245d01e3c1d4f9072abc4372fd3fb0a6ece9f">254245d0</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-14T21:32:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs/users-guide: Update default -funfolding-use-threshold value

This was changed in 3d2991f8 but I neglected to update the

documentation. Fixes #18419.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-14T21:32:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Escape backslashes in json profiling reports properly.

I also took the liberty to do away the fixed buffer size for escaping.

Using a fixed size here can only lead to issues down the line.

Fixes #18438.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2379722438cb551210c4899119ade05989c17166">23797224</a></strong>

<div>

<span>by Sergei Trofimovich</span>

<i>at 2020-07-14T21:33:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">.gitlab: re-enable integer-simple substitute (BIGNUM_BACKEND)

Recently build system migrated from INTEGER_LIBRARY to BIGNUM_BACKEND.

But gitlab CI was never updated. Let's enable BIGNUM_BACKEND=native.

Bug: https://gitlab.haskell.org/ghc/ghc/-/issues/18437

Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

</pre>

</li>

<li>

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

<div>

<span>by Sergei Trofimovich</span>

<i>at 2020-07-14T21:33:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-bignum: bring in sync .hs-boot files with module declarations

Before this change `BIGNUM_BACKEND=native` build was failing as:

```

libraries/ghc-bignum/src/GHC/Num/BigNat/Native.hs:708:16: error:

    * Variable not in scope: naturalFromBigNat# :: WordArray# -> t

    * Perhaps you meant one of these:

        `naturalFromBigNat' (imported from GHC.Num.Natural),

        `naturalToBigNat' (imported from GHC.Num.Natural)

    |

708 |           m' = naturalFromBigNat# m

    |

```

This happens because `.hs-boot` files are slightly out of date.

This change brings in data and function types in sync.

Bug: https://gitlab.haskell.org/ghc/ghc/-/issues/18437

Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-07-14T21:33:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Disassembler.c: Use FMT_HexWord for printing values in hex format

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/58ae62ebb5750e4dfbdb171efde8e3064b7afea8">58ae62eb</a></strong>

<div>

<span>by Matthias Andreas Benkard</span>

<i>at 2020-07-14T21:34:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">macOS: Load frameworks without stating them first.

macOS Big Sur makes the following change to how frameworks are shipped

with the OS:

> New in macOS Big Sur 11 beta, the system ships with a built-in

> dynamic linker cache of all system-provided libraries. As part of

> this change, copies of dynamic libraries are no longer present on

> the filesystem. Code that attempts to check for dynamic library

> presence by looking for a file at a path or enumerating a directory

> will fail. Instead, check for library presence by attempting to

> dlopen() the path, which will correctly check for the library in the

> cache. (62986286)

https://developer.apple.com/documentation/macos-release-notes/macos-big-sur-11-beta-release-notes/

Therefore, the previous method of checking whether a library exists

before attempting to load it makes GHC.Runtime.Linker.loadFramework

fail to find frameworks installed at /System/Library/Frameworks.

GHC.Runtime.Linker.loadFramework now opportunistically loads the

framework libraries without checking for their existence first,

failing only if all attempts to load a given framework from any of the

various possible locations fail.

</pre>

</li>

<li>

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

<div>

<span>by Matthias Andreas Benkard</span>

<i>at 2020-07-14T21:34:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">loadFramework: Output the errors collected in all loading attempts.

With the recent change away from first finding and then loading a

framework, loadFramework had no way of communicating the real reason

why loadDLL failed if it was any reason other than the framework

missing from the file system.  It now collects all loading attempt

errors into a list and concatenates them into a string to return to

the caller.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/51dbfa52df483822b99bb191d2ffc0943954e1d3">51dbfa52</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-15T04:05:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">StgToCmm: Use CmmRegOff smart constructor

Previously we would generate expressions of the form

`CmmRegOff BaseReg 0`. This should do no harm (and really should be

handled by the NCG anyways) but it's better to just generate a plain

`CmmReg`.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-15T04:06:08-04:00</i>

</div>

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

Test due to @monoidal.

</pre>

</li>

<li>

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

<div>

<span>by Simon Jakobi</span>

<i>at 2020-07-16T02:15:50+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update containers to v0.6.3.1

See https://github.com/haskell/containers/issues/737

in case of doubt about the correct release tag.

</pre>

</li>

</ul>

<h4>30 changed files:</h4>

<ul>

<li class="file-stats">

<a href="#587d266bb27a4dc3022bbed44dfa19849df3044c">

.gitlab-ci.yml

</a>

</li>

<li class="file-stats">

<a href="#157f7634c25bc6366cb7c9c9edb48e819dce38db">

.gitlab/ci.sh

</a>

</li>

<li class="file-stats">

<a href="#f656107cc03a27946448887125380c358788500e">

.gitlab/test-metrics.sh

</a>

</li>

<li class="file-stats">

<a href="#7445606fbf8f3683cd42bdc54b05d7a0bc2dfc44">

.gitmodules

</a>

</li>

<li class="file-stats">

<a href="#9ab3868b23ed5d5a6e12ef902049902556fa4009">

aclocal.m4

</a>

</li>

<li class="file-stats">

<a href="#d0d96a6d03668aeab20ebe05e2c4ccb798c7e64c">

compiler/GHC.hs

</a>

</li>

<li class="file-stats">

<a href="#0887cf39c5cdf9cf8d6758f410d7dab3023c0d77">

compiler/GHC/Builtin/Names.hs

</a>

</li>

<li class="file-stats">

<a href="#06764eb0158306b83ab1998d18316392a51838c2">

compiler/GHC/Builtin/Names/TH.hs

</a>

</li>

<li class="file-stats">

<a href="#a1519b7fe8a0d4b42e4aaa927fb6ab5b5da0fcdd">

compiler/GHC/Builtin/PrimOps.hs

</a>

</li>

<li class="file-stats">

<a href="#5f4b3cf094f6e2fc46805a6c447613ae13a08942">

<span class="new-file">

+

compiler/GHC/Builtin/RebindableNames.hs

</span>

</a>

</li>

<li class="file-stats">

<a href="#377cfd14c1f92357465df995ec6537b074051322">

compiler/GHC/Builtin/Types.hs

</a>

</li>

<li class="file-stats">

<a href="#be7a5c9dc04ecfe7bedb2a2afcc2a51be6719577">

compiler/GHC/Builtin/Types.hs-boot

</a>

</li>

<li class="file-stats">

<a href="#8a5cd068459120cddf3814e7b9e02003b87647ba">

compiler/GHC/Builtin/Types/Prim.hs

</a>

</li>

<li class="file-stats">

<a href="#d95fdf6575459444666f72b2281534e0558a4ba0">

compiler/GHC/Builtin/Utils.hs

</a>

</li>

<li class="file-stats">

<a href="#451725cc4e5d443a3b7c2adcdf224840f953b7e2">

compiler/GHC/Builtin/primops.txt.pp

</a>

</li>

<li class="file-stats">

<a href="#2f6f8d6d05acc04b08fff94df4b3996c65b87892">

compiler/GHC/ByteCode/Asm.hs

</a>

</li>

<li class="file-stats">

<a href="#16db773e94d0938489b415eb3231cadb2565b84d">

compiler/GHC/ByteCode/InfoTable.hs

</a>

</li>

<li class="file-stats">

<a href="#5c66928780aaad0eb5888511dc4b0b08492c69fa">

compiler/GHC/ByteCode/Types.hs

</a>

</li>

<li class="file-stats">

<a href="#db697f6aea9f93f1583f1d5c62d25570a1e07f73">

compiler/GHC/Cmm/CLabel.hs

</a>

</li>

<li class="file-stats">

<a href="#d088ba20f051734394bf7ca283f33ed8127bc8ab">

compiler/GHC/Cmm/CallConv.hs

</a>

</li>

<li class="file-stats">

<a href="#eae45922f6e633780395508f44c14a5ed7959e7a">

compiler/GHC/Cmm/Dataflow/Block.hs

</a>

</li>

<li class="file-stats">

<a href="#47cba74ae8965f1665cd11bf2b023760ea27594e">

compiler/GHC/Cmm/Info.hs

</a>

</li>

<li class="file-stats">

<a href="#2d3721ad8de95e1144493ca545db846672cb109f">

compiler/GHC/Cmm/Info/Build.hs

</a>

</li>

<li class="file-stats">

<a href="#066085df29cc928ac539d8feae6e5215cbbf1e14">

compiler/GHC/Cmm/LayoutStack.hs

</a>

</li>

<li class="file-stats">

<a href="#6fbb543d5fcea725882dd3b8d4dcd9b02022a4be">

compiler/GHC/Cmm/Monad.hs

</a>

</li>

<li class="file-stats">

<a href="#71e696f452eb493722d70306c6f304fc9b2f6a95">

compiler/GHC/Cmm/Parser.y

</a>

</li>

<li class="file-stats">

<a href="#d40f34584a7f4c0fa7587fb41f94a34bca0d1064">

compiler/GHC/Cmm/Pipeline.hs

</a>

</li>

<li class="file-stats">

<a href="#29a1593e7281c8a9103a19e3a7562e2365e23b47">

compiler/GHC/Cmm/ProcPoint.hs

</a>

</li>

<li class="file-stats">

<a href="#b1390f6749e1a2dddcae35f88d55623ea6269f56">

compiler/GHC/Cmm/Sink.hs

</a>

</li>

<li class="file-stats">

<a href="#10b61652f9817945bb54ccf8fc40f8a664ca3c30">

compiler/GHC/CmmToAsm.hs

</a>

</li>

</ul>

<h5>The diff was not included because it is too large.</h5>

</div>

<div class="footer" style="margin-top: 10px;">

<p style="font-size: small; color: #777;">

—

<br>

<a href="https://gitlab.haskell.org/ghc/ghc/-/compare/c2db248150018080a901dcf3dcdaa4d6c741e385...a5bbaf0a8f93d969ebba89f7c8f12b30686f0f29">View it on GitLab</a>.

<br>

You're receiving this email because of your account on gitlab.haskell.org.

If you'd like to receive fewer emails, you can

adjust your notification settings.

</p>

</div>

</body>

</html>