GitLab

Zubin pushed to branch wip/9.12.3-backports at Glasgow Haskell Compiler / GHC

Commits:

82425570
by Zubin Duggal at 2025-09-11T17:28:38+05:30
```
Prepare 9.12.3
```

1a2e2500

by Simon Peyton Jones at 2025-09-11T17:28:38+05:30

Take more care in zonkEqTypes on AppTy/AppTy

This patch fixes #26256.

See Note [zonkEqTypes and the PKTI] in GHC.Tc.Solver.Equality

(cherry picked from commit 18036d5205ac648bb245217519fed2fd931a9982)

c6e5ce5c

by Andreas Klebinger at 2025-09-11T17:28:38+05:30

Make unexpected LLVM versions a warning rather than an error.

Typically a newer LLVM version *will* work so erroring out if
a user uses a newer LLVM version is too aggressive.

Fixes #25915

(cherry picked from commit 50842f83f467ff54dd22470559a7af79d2025c03)

7ec2f532

by Teo Camarasu at 2025-09-11T17:28:38+05:30

rts: spin if we see a WHITEHOLE in messageBlackHole

When a BLACKHOLE gets cancelled in raiseAsync, we indirect to a THUNK.
GC can then shortcut this, replacing our BLACKHOLE with a fresh THUNK.

This THUNK is not guaranteed to have a valid indirectee field.

If at the same time, a message intended for the previous BLACKHOLE is
processed and concurrently we BLACKHOLE the THUNK, thus temporarily
turning it into a WHITEHOLE, we can get a segfault, since we look at the
undefined indirectee field of the THUNK

The fix is simple: spin if we see a WHITEHOLE, and it will soon be
replaced with a valid BLACKHOLE.

Resolves #26205

(cherry picked from commit 4021181ee0860aca2054883a531f3312361cc701)

b3176a25

by Teo Camarasu at 2025-09-11T17:28:38+05:30

rts: ensure MessageBlackHole.link is always a valid closure

We turn a MessageBlackHole into an StgInd in wakeBlockingQueue().
Therefore it's important that the link field, which becomes the
indirection field, always points to a valid closure.

It's unclear whether it's currently possible for the previous behaviour
to lead to a crash, but it's good to be consistent about this invariant nonetheless.

Co-authored-by: Andreas Klebinger <klebinger.andreas@gmx.at>
(cherry picked from commit a8b2fbae6bcf20bc2f3fe58803096d2a9c5fc43d)

6f94a682

by Reed Mullanix at 2025-09-11T17:28:38+05:30

ghc-internal: Fix naturalAndNot for NB/NS case

When the first argument to `naturalAndNot` is larger than a `Word` and the second is `Word`-sized, `naturalAndNot` will truncate the
result:

```
>>> naturalAndNot ((2 ^ 65) .|. (2 ^ 3)) (2 ^ 3)
0
```

In contrast, `naturalAndNot` does not truncate when both arguments are larger than a `Word`, so this appears to be a bug.
Luckily, the fix is pretty easy: we just need to call `bigNatAndNotWord#` instead of truncating.

Fixes #26230

(cherry picked from commit a766286fe759251eceb304c54ba52841c2a51f86)

9fdad140

by Ben Gamari at 2025-09-11T17:28:38+05:30

llvmGen: Fix built-in variable predicate

Previously the predicate to identify LLVM builtin global variables was
checking for `$llvm` rather than `@llvm` as it should.

(cherry picked from commit 6e67fa083a50684e1cfae546e07cab4d4250e871)

21 changed files:

compiler/GHC/CmmToLlvm/Base.hs
compiler/GHC/Driver/Errors/Ppr.hs
compiler/GHC/Tc/Solver/Equality.hs
configure.ac
docs/users_guide/9.12.3-notes.rst
libraries/base/changelog.md
libraries/ghc-bignum/changelog.md
libraries/ghc-bignum/src/GHC/Num/Natural.hs
rts/Messages.c
rts/StgMiscClosures.cmm
rts/Updates.h
testsuite/driver/testlib.py
+ testsuite/tests/numeric/should_run/T26230.hs
+ testsuite/tests/numeric/should_run/T26230.stdout
testsuite/tests/numeric/should_run/all.T
+ testsuite/tests/partial-sigs/should_compile/T26256.hs
+ testsuite/tests/partial-sigs/should_compile/T26256.stderr
testsuite/tests/partial-sigs/should_compile/all.T
testsuite/tests/polykinds/T14172.stderr
+ testsuite/tests/typecheck/should_compile/T26256a.hs
testsuite/tests/typecheck/should_compile/all.T

Changes:

compiler/GHC/CmmToLlvm/Base.hs

@@ -526,10 +526,10 @@ generateExternDecls = do
    modifyEnv $ \env -> env { envAliases = emptyUniqSet }
    return (concat defss, [])
 --- | Is a variable one of the special @$llvm@ globals?
 +-- | Is a variable one of the special @\@llvm@ globals?
  isBuiltinLlvmVar :: LlvmVar -> Bool
  isBuiltinLlvmVar (LMGlobalVar lbl _ _ _ _ _) =
 -    "$llvm" `isPrefixOf` unpackFS lbl
 +    "llvm." `isPrefixOf` unpackFS lbl
  isBuiltinLlvmVar _ = False
  -- | Here we take a global variable definition, rename it with a

compiler/GHC/Driver/Errors/Ppr.hs

@@ -276,7 +276,7 @@ instance Diagnostic DriverMessage where
              ++ llvmVersionStr supportedLlvmVersionLowerBound
              ++ " and "
              ++ llvmVersionStr supportedLlvmVersionUpperBound
 -            ++ ") and reinstall GHC to make -fllvm work")
 +            ++ ") and reinstall GHC to ensure -fllvm works")
    diagnosticReason = \case
      DriverUnknownMessage m
@@ -347,7 +347,7 @@ instance Diagnostic DriverMessage where
      DriverInstantiationNodeInDependencyGeneration {}
        -> ErrorWithoutFlag
      DriverNoConfiguredLLVMToolchain
 -      -> ErrorWithoutFlag
 +      -> WarningWithoutFlag
    diagnosticHints = \case
      DriverUnknownMessage m

compiler/GHC/Tc/Solver/Equality.hs

@@ -193,12 +193,8 @@ zonkEqTypes ev eq_rel ty1 ty2
          then tycon tc1 tys1 tys2
          else bale_out ty1 ty2
 -    go ty1 ty2
 -      | Just (ty1a, ty1b) <- tcSplitAppTyNoView_maybe ty1
 -      , Just (ty2a, ty2b) <- tcSplitAppTyNoView_maybe ty2
 -      = do { res_a <- go ty1a ty2a
 -           ; res_b <- go ty1b ty2b
 -           ; return $ combine_rev mkAppTy res_b res_a }
 +    -- If you are temppted to add a case for AppTy/AppTy, be careful
 +    -- See Note [zonkEqTypes and the PKTI]
      go ty1@(LitTy lit1) (LitTy lit2)
        | lit1 == lit2
@@ -274,6 +270,32 @@ zonkEqTypes ev eq_rel ty1 ty2
      combine_rev f (Right tys) (Right ty) = Right (f ty tys)
 +{- Note [zonkEqTypes and the PKTI]
 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 +Because `zonkEqTypes` does /partial/ zonking, we need to be very careful
 +to maintain the Purely Kinded Type Invariant: see GHC.Tc.Gen/HsType
 +HsNote [The Purely Kinded Type Invariant (PKTI)].
++
 +In #26256 we try to solve this equality constraint:
 +   Int :-> Maybe Char ~# k0 Int (m0 Char)
 +where m0 and k0 are unification variables, and
 +   m0 :: Type -> Type
 +It happens that m0 was already unified
 +   m0 := (w0 :: kappa)
 +where kappa is another unification variable that is also already unified:
 +   kappa := Type->Type.
 +So the original type satisifed the PKTI, but a partially-zonked form
 +   k0 Int (w0 Char)
 +does not!! (This a bit reminiscent of Note [mkAppTyM].)
++
 +The solution I have adopted is simply to make `zonkEqTypes` bale out on `AppTy`.
 +After all, it's only supposed to be a quick hack to see if two types are already
 +equal; if we bale out we'll just get into the "proper" canonicaliser.
++
 +The only tricky thing about this approach is that it relies on /omitting/
 +code -- for the AppTy/AppTy case!  Hence this Note
 +-}
++
  {- *********************************************************************
  *                                                                      *
  *           canonicaliseEquality

configure.ac

@@ -22,7 +22,7 @@ AC_INIT([The Glorious Glasgow Haskell Compilation System], [9.12.2], [glasgow-ha
  AC_CONFIG_MACRO_DIRS([m4])
  # Set this to YES for a released version, otherwise NO
 -: ${RELEASE=YES}
 +: ${RELEASE=NO}
  # The primary version (e.g. 7.5, 7.4.1) is set in the AC_INIT line
  # above.  If this is not a released version, then we will append the

docs/users_guide/9.12.3-notes.rst

@@ -13,6 +13,83 @@ Compiler
  - Fixed re-exports of ``MkSolo`` and ``MkSolo#`` (:ghc-ticket:`25182`)
  - Fixed the behavior of ``Language.Haskell.TH.mkName "FUN"`` (:ghc-ticket:`25174`)
 +- Fixed miscompilation involving ``zonkEqTypes`` on ``AppTy/AppTy`` (:ghc-ticket:`26256`)
 +- Fixed CprAnal to detect recursive newtypes (:ghc-ticket:`25944`)
 +- Fixed specialisation of incoherent instances (:ghc-ticket:`25883`)
 +- Fixed bytecode generation for ``tagToEnum# <LITERAL>`` (:ghc-ticket:`25975`)
 +- Fixed panic with EmptyCase and RequiredTypeArguments (:ghc-ticket:`25004`)
 +- Fixed ``tyConStupidTheta`` to handle ``PromotedDataCon`` (:ghc-ticket:`25739`)
 +- Fixed unused import warnings for duplicate record fields (:ghc-ticket:`24035`)
 +- Fixed lexing of ``"\^\"`` (:ghc-ticket:`25937`)
 +- Fixed string gap collapsing (:ghc-ticket:`25784`)
 +- Fixed lexing of comments in multiline strings (:ghc-ticket:`25609`)
 +- Made unexpected LLVM versions a warning rather than an error (:ghc-ticket:`25915`)
 +- Disabled ``-fprof-late-overloaded-calls`` for join points to avoid invalid transformations
 +- Fixed bugs in ``integerRecipMod`` and ``integerPowMod`` (:ghc-ticket:`26017`)
 +- Fixed ``naturalAndNot`` for NB/NS case (:ghc-ticket:`26230`)
 +- Fixed ``ds_ev_typeable`` to use ``mkTrAppChecked`` (:ghc-ticket:`25998`)
 +- Fixed GHC settings to always unescape escaped spaces (:ghc-ticket:`25204`)
 +- Fixed issue with HasCallStack constraint caching (:ghc-ticket:`25529`)
 +- Fixed archive member size writing logic in ``GHC.SysTools.Ar`` (:ghc-ticket:`26120`, :ghc-ticket:`22586`)
++
 +Runtime System
 +~~~~~~~~~~~~~~
++
 +- Fixed ``MessageBlackHole.link`` to always be a valid closure
 +- Fixed handling of WHITEHOLE in ``messageBlackHole`` (:ghc-ticket:`26205`)
 +- Fixed ``rts_clearMemory`` logic when sanity checks are enabled (:ghc-ticket:`26011`)
 +- Fixed underflow frame lookups in the bytecode interpreter (:ghc-ticket:`25750`)
 +- Fixed overflows and reentrancy in interpreter statistics calculation (:ghc-ticket:`25756`)
 +- Fixed INTERP_STATS profiling code (:ghc-ticket:`25695`)
 +- Removed problematic ``n_free`` variable from nonmovingGC (:ghc-ticket:`26186`)
 +- Fixed incorrect format specifiers in era profiling
 +- Improved documentation of SLIDE and PACK bytecode instructions
 +- Eliminated redundant ``SLIDE x 0`` bytecode instructions
 +- Fixed compile issues on powerpc64 ELF v1
++
 +Code Generation
 +~~~~~~~~~~~~~~~
++
 +- Fixed LLVM built-in variable predicate (was checking ``$llvm`` instead of ``@llvm``)
 +- Fixed linkage of built-in arrays for LLVM (:ghc-ticket:`25769`)
 +- Fixed code generation for SSE vector operations (:ghc-ticket:`25859`)
 +- Fixed ``bswap64`` code generation on i386 (:ghc-ticket:`25601`)
 +- Fixed sub-word arithmetic right shift on AArch64 (:ghc-ticket:`26061`)
 +- Fixed LLVM vector literal emission to include type information
 +- Fixed LLVM version detection
 +- Fixed typo in ``padLiveArgs`` that caused segfaults (:ghc-ticket:`25770`, :ghc-ticket:`25773`)
 +- Fixed constant-folding for Word->Float bitcasts
 +- Added surface syntax for Word/Float bitcast operations
 +- Fixed ``MOVD`` format in x86 NCG for ``unpackInt64X2#``
 +- Added ``-finter-module-far-jumps`` flag for AArch64
 +- Fixed RV64 J instruction handling for non-local jumps (:ghc-ticket:`25738`)
 +- Reapplied division by constants optimization
 +- Fixed TNTC to set CmmProc entry_label properly (:ghc-ticket:`25565`)
++
 +Linker
 +~~~~~~
++
 +- Improved efficiency of proddable blocks structure (:ghc-ticket:`26009`)
 +- Fixed Windows DLL loading to avoid redundant ``LoadLibraryEx`` calls (:ghc-ticket:`26009`)
 +- Fixed incorrect use of ``break`` in nested for loop (:ghc-ticket:`26052`)
 +- Fixed linker to not fail due to ``RTLD_NOW`` (:ghc-ticket:`25943`)
 +- Dropped obsolete Windows XP compatibility checks
++
 +GHCi
 +~~~~
++
 +- Fixed ``mkTopLevEnv`` to use ``loadInterfaceForModule`` instead of ``loadSrcInterface`` (:ghc-ticket:`25951`)
++
 +Template Haskell
 +~~~~~~~~~~~~~~~~
++
 +- Added explicit export lists to all remaining template-haskell modules
++
 +Build system
 +~~~~~~~~~~~~~~~~
++
 +- Exposed all of Backtraces' internals for ghc-internal (:ghc-ticket:`26049`)
 +- Fixed cross-compilation configuration override (:ghc-ticket:`26236`)
  Included libraries
  ~~~~~~~~~~~~~~~~~~

libraries/base/changelog.md

  # Changelog for [`base` package](http://hackage.haskell.org/package/base)
 +## 4.21.2.0 *Sept 2024*
 +  * Fix bug where `naturalAndNot` was incorrectly truncating results ([CLC proposal #350](github.com/haskell/core-libraries-committee/issues/350))
++
  ## 4.21.1.0 *Sept 2024*
    * Fix incorrect results of `integerPowMod` when the base is 0 and the exponent is negative, and `integerRecipMod` when the modulus is zero ([#26017](https://gitlab.haskell.org/ghc/ghc/-/issues/26017)).

libraries/ghc-bignum/changelog.md

@@ -4,6 +4,7 @@
  - Expose backendName
  - Add `naturalSetBit[#]` (#21173), `naturalClearBit[#]` (#21175), `naturalComplementBit[#]` (#21181)
 +- Fix bug where `naturalAndNot` was incorrectly truncating results (#26230)
  ## 1.2

libraries/ghc-bignum/src/GHC/Num/Natural.hs

@@ -488,7 +488,7 @@ naturalAndNot :: Natural -> Natural -> Natural
  {-# NOINLINE naturalAndNot #-}
  naturalAndNot (NS n) (NS m) = NS (n `and#` not# m)
  naturalAndNot (NS n) (NB m) = NS (n `and#` not# (bigNatToWord# m))
 -naturalAndNot (NB n) (NS m) = NS (bigNatToWord# n `and#` not# m)
 +naturalAndNot (NB n) (NS m) = NB (bigNatAndNotWord# n m)
  naturalAndNot (NB n) (NB m) = naturalFromBigNat# (bigNatAndNot n m)
  naturalOr :: Natural -> Natural -> Natural

rts/Messages.c

@@ -180,13 +180,22 @@ uint32_t messageBlackHole(Capability *cap, MessageBlackHole *msg)
          bh_info != &stg_CAF_BLACKHOLE_info &&
          bh_info != &__stg_EAGER_BLACKHOLE_info &&
          bh_info != &stg_WHITEHOLE_info) {
 -        // if it is a WHITEHOLE, then a thread is in the process of
 -        // trying to BLACKHOLE it.  But we know that it was once a
 -        // BLACKHOLE, so there is at least a valid pointer in the
 -        // payload, so we can carry on.
          return 0;
+     }
 +    // If we see a WHITEHOLE then we should wait for it to turn into a BLACKHOLE.
 +    // Otherwise we might look at the indirectee and segfault.
 +    // See "Exception handling" in Note [Thunks, blackholes, and indirections]
 +    // We might be looking at a *fresh* THUNK being WHITEHOLE-d so we can't
 +    // guarantee that the indirectee is a valid pointer.
 +#if defined(THREADED_RTS)
 +    if (bh_info == &stg_WHITEHOLE_info) {
 +      while(ACQUIRE_LOAD(&bh->header.info) == &stg_WHITEHOLE_info) {
 +        busy_wait_nop();
 +      }
 +    }
 +#endif
++
      // The blackhole must indirect to a TSO, a BLOCKING_QUEUE, an IND,
      // or a value.
      StgClosure *p;

rts/StgMiscClosures.cmm

@@ -31,6 +31,7 @@ import CLOSURE ENT_VIA_NODE_ctr;
  import CLOSURE RtsFlags;
  import CLOSURE stg_BLOCKING_QUEUE_CLEAN_info;
  import CLOSURE stg_BLOCKING_QUEUE_DIRTY_info;
 +import CLOSURE stg_END_TSO_QUEUE_closure;
  import CLOSURE stg_IND_info;
  import CLOSURE stg_MSG_BLACKHOLE_info;
  import CLOSURE stg_TSO_info;
@@ -574,6 +575,9 @@ retry:
          MessageBlackHole_tso(msg) = CurrentTSO;
          MessageBlackHole_bh(msg) = node;
 +        // Ensure that the link field is a valid closure,
 +        // since we might turn this into an indirection in wakeBlockingQueue()
 +        MessageBlackHole_link(msg) = stg_END_TSO_QUEUE_closure;
          SET_HDR(msg, stg_MSG_BLACKHOLE_info, CCS_SYSTEM);
          // messageBlackHole has appropriate memory barriers when this object is exposed.
          // See Note [Heap memory barriers].

rts/Updates.h

@@ -333,6 +333,10 @@
   * `AP_STACK` closure recording the aborted execution state.
   * See `RaiseAsync.c:raiseAsync` for details.
+  *
 + * This can combine with indirection shortcutting during GC to replace a BLACKHOLE
 + * with a fresh THUNK. We should be very careful here since the THUNK will have an
 + * undefined value in the indirectee field. Looking at the indirectee field can then
 + * lead to a segfault such as #26205.
+  *
   * CAFs
   * ----

testsuite/driver/testlib.py

@@ -1725,7 +1725,7 @@ async def do_test(name: TestName,
          dst_makefile = in_testdir('Makefile')
          if src_makefile.exists():
              makefile = src_makefile.read_text(encoding='UTF-8')
 -            makefile = re.sub('TOP=.*', 'TOP=%s' % config.top, makefile, 1)
 +            makefile = re.sub('TOP=.*', 'TOP=%s' % config.top, makefile, count=1)
              dst_makefile.write_text(makefile, encoding='UTF-8')
      if opts.pre_cmd:

testsuite/tests/numeric/should_run/T26230.hs

 +import Data.Bits
 +import GHC.Num.Natural
++
 +main = do
 +  print $ naturalAndNot ((2 ^ 4) .|. (2 ^ 3)) (2 ^ 3)
 +  print $ naturalAndNot ((2 ^ 129) .|. (2 ^ 65)) (2 ^ 65)
 +  print $ naturalAndNot ((2 ^ 4) .|. (2 ^ 3)) ((2 ^ 65) .|. (2 ^ 3))
 +  print $ naturalAndNot ((2 ^ 65) .|. (2 ^ 3)) (2 ^ 3)

testsuite/tests/numeric/should_run/T26230.stdout

 +16
 +680564733841876926926749214863536422912
 +16
 +36893488147419103232

testsuite/tests/numeric/should_run/all.T

@@ -87,3 +87,4 @@ test('T24066', normal, compile_and_run, [''])
  test('div01', normal, compile_and_run, [''])
  test('T24245', normal, compile_and_run, [''])
  test('T25653', normal, compile_and_run, [''])
 +test('T26230', normal, compile_and_run, [''])

testsuite/tests/partial-sigs/should_compile/T26256.hs

 +{-# LANGUAGE GHC2021 #-}
 +{-# LANGUAGE TypeFamilies #-}
 +{-# LANGUAGE PartialTypeSignatures #-}
++
 +module M (go) where
++
 +import Data.Kind
++
 +type Apply :: (Type -> Type) -> Type
 +data Apply m
++
 +type (:->) :: Type -> Type -> Type
 +type family (:->) where (:->) = (->)
++
 +f :: forall (k :: Type -> Type -> Type) (m :: Type -> Type).
 +     k Int (m Char) -> k Bool (Apply m)
 +f = f
++
 +x :: Int :-> Maybe Char
 +x = x
++
 +go :: Bool -> _ _
 +go = f x

testsuite/tests/partial-sigs/should_compile/T26256.stderr

 +T26256.hs:22:15: warning: [GHC-88464] [-Wpartial-type-signatures (in -Wdefault)]
 +    • Found type wildcard ‘_’ standing for ‘Apply :: (* -> *) -> *’
 +    • In the type signature: go :: Bool -> _ _
++
 +T26256.hs:22:17: warning: [GHC-88464] [-Wpartial-type-signatures (in -Wdefault)]
 +    • Found type wildcard ‘_’ standing for ‘Maybe :: * -> *’
 +    • In the first argument of ‘_’, namely ‘_’
 +      In the type signature: go :: Bool -> _ _

testsuite/tests/partial-sigs/should_compile/all.T

@@ -108,3 +108,4 @@ test('T21667', normal, compile, [''])
  test('T22065', normal, compile, [''])
  test('T16152', normal, compile, [''])
  test('T20076', expect_broken(20076), compile, [''])
 +test('T26256', normal, compile, [''])

testsuite/tests/polykinds/T14172.stderr

  T14172.hs:7:46: error: [GHC-88464]
 -    • Found type wildcard ‘_’ standing for ‘a'1 :: k0’
 -      Where: ‘k0’ is an ambiguous type variable
 +    • Found type wildcard ‘_’ standing for ‘a'1 :: k30’
 +      Where: ‘k30’ is an ambiguous type variable
               ‘a'1’ is an ambiguous type variable
        To use the inferred type, enable PartialTypeSignatures
      • In the first argument of ‘h’, namely ‘_’

testsuite/tests/typecheck/should_compile/T26256a.hs

 +{-# LANGUAGE GHC2021 #-}
 +{-# LANGUAGE TypeFamilies #-}
++
 +module T26256 (go) where
++
 +import Data.Kind
++
 +class Cat k where (<<<) :: k a b -> k x a -> k x b
 +instance Cat (->) where (<<<) = (.)
 +class Pro k p where pro :: k a b s t -> p a b -> p s t
 +data Hiding o a b s t = forall e. Hiding (s -> o e a)
 +newtype Apply e a = Apply (e a)
++
 +type (:->) :: Type -> Type -> Type
 +type family (:->) where
 +  (:->) = (->)
++
 +go :: (Pro (Hiding Apply) p) => (s :-> e a) -> p a b -> p s t
 +go sea = pro (Hiding (Apply <<< sea))

testsuite/tests/typecheck/should_compile/all.T

@@ -935,3 +935,4 @@ test('T24845a', normal, compile, [''])
  test('T23501a', normal, compile, [''])
  test('T23501b', normal, compile, [''])
  test('T25597', normal, compile, [''])
 +test('T26256a', normal, compile, [''])