November 2025 - ghc-commits

[Git][ghc/ghc][wip/26543] Backtrack
by Simon Peyton Jones (＠simonpj) 28 Nov '25

28 Nov '25

Simon Peyton Jones pushed to branch wip/26543 at Glasgow Haskell Compiler / GHC Commits: fa545237 by Simon Peyton Jones at 2025-11-28T10:15:20+00:00 Backtrack Adding Note [QuickLook: arguments before result] - - - - - 1 changed file: - compiler/GHC/Tc/Gen/App.hs Changes: ===================================== compiler/GHC/Tc/Gen/App.hs ===================================== @@ -354,6 +354,44 @@ Unify result type /before/ typechecking the args • In the first argument of ‘Pair’, namely ‘"yes"’ The latter is much better. That is why we call checkResultType before tcValArgs. + +Note [QuickLook: arguments before result] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Generally we try to push the expected result type into the call; +see Note [Unify with expected type before typechecking arguments]. +But surprisingly we can't do that for QuickLook. (#26599 was a failed +attempt to suggest this.) Consider + h :: (Int->Int) -> Int ids :: [forall a. a->a] +and the call + h (head ids) +Let's say we instantiate `head :: [a] -> a` with `a:=kappa`. +We QuickLook at the argument with expected type (Int->Int). We must NOT +unify kappa:=(Int->Int), because kappa:=forall a. a->a is the only +solution, and one that we will find if we look at the argument first. + +TL;DR: we must do `quickLookArg` on all arguments before doing `quickLookResultType` +on the result type. + +Remember: `quickLookResultType` is really anticipating a /subsumption/ test, not +an equality test. Doing `qlUnify` on the result type (always a rho-type) is +in general wrong if there is an un-guarded kappa in the result type. It's wrong +UNLESS we have already gotten all the info about `kappa` (from the +arguments) that we are going to get. That's why we QuickLook the arguments first. + +This is a bit sad, as #26599 shows. Consider + + woo :: (x, [forall a. a->a]) + bar1 = snd woo + bar2 = snd (id woo) + +For `bar1` we instantiate `snd` at [a:=k1,b:=k2]. Then we QL on the argument `woo` +(instantiating with `x:=k3`. Since the result type is guarded we qlUnify + (k3,forall a.a->a) ~ (k1,k2) +and thus succeed in discovering k2:=forall a.a->a, as desired. + +But for `bar2` we fail. When quick-looking (id woo) we instantiate `id` with [a:=k], +and quick-look the argument `woo` with expected type `k`. That's not guarded, +so we get no information. Adding the `id` call makes it un-typeable. Boo. -} tcApp :: HsExpr GhcRn @@ -403,24 +441,23 @@ tcApp rn_expr exp_res_ty DoQL -> do { traceTc "tcApp:DoQL" (ppr rn_fun $$ ppr app_res_rho) -- Step 5.1: Take a quick look at the result type - ; inst_args_with_guards <- case exp_res_ty of - Check exp_rho -> do { qlUnify app_res_rho exp_rho - ; mapM reGuardArg inst_args } - Infer {} -> return inst_args - - ; inst_args_ql <- mapM quickLookArg inst_args_with_guards + -- See Note [QuickLook: arguments before result] + ; case exp_res_ty of + Check exp_rho -> quickLookResultType app_res_rho exp_rho + Infer {} -> return () -- Step 5.3: zonk to expose the polymorphism hidden under -- QuickLook instantiation variables in `app_res_rho` ; app_res_rho <- liftZonkM $ zonkTcType app_res_rho -- Step 5.4: subsumption check against the expected type - ; res_wrap <- checkResultTy rn_expr tc_head inst_args_ql - app_res_rho exp_res_ty + -- See Note [Unify with expected type before typechecking arguments] + ; res_wrap <- checkResultTy rn_expr tc_head inst_args + app_res_rho exp_res_ty -- Step 5.2: typecheck the arguments, and monomorphise -- any un-unified instantiation variables - ; tc_args <- tcValArgs DoQL inst_args_ql + ; tc_args <- tcValArgs DoQL inst_args -- Step 5.5: wrap up ; finishApp tc_head tc_args app_res_rho res_wrap } } @@ -589,13 +626,13 @@ tcValArg _ (EValArgQL { eaql_wanted = wanted -- Unify with context if we have not already done so -- See (QLA4) in Note [Quick Look at value arguments] - ; unless arg_influences_enclosing_call $ -- Don't repeat - qlUnify app_res_rho exp_arg_rho -- the qlUnify + ; unless arg_influences_enclosing_call $ -- Don't repeat + quickLookResultType app_res_rho exp_arg_rho -- the qlUnify - ; tc_args <- tcValArgs DoQL inst_args ; app_res_rho <- liftZonkM $ zonkTcType app_res_rho ; res_wrap <- checkResultTy rn_expr tc_head inst_args app_res_rho (mkCheckExpType exp_arg_rho) + ; tc_args <- tcValArgs DoQL inst_args ; finishApp tc_head tc_args app_res_rho res_wrap } ; traceTc "tcEValArgQL }" $ @@ -607,6 +644,10 @@ tcValArg _ (EValArgQL { eaql_wanted = wanted -------------------- +whenQL :: QLFlag -> ZonkM () -> TcM () +whenQL DoQL thing_inside = liftZonkM thing_inside +whenQL NoQL _ = return () + wantQuickLook :: HsExpr GhcRn -> TcM QLFlag wantQuickLook (HsVar _ (L _ (WithUserRdr _ f))) | getUnique f `elem` quickLookKeys = return DoQL @@ -839,11 +880,8 @@ tcInstFun do_ql inst_final (tc_fun, fun_ctxt) fun_sigma rn_args (Just $ HsExprTcThing tc_fun) (n_val_args, fun_sigma) fun_ty - ; let arg' = EValArg { ea_ctxt = ctxt - , ea_arg = arg - , ea_arg_ty = arg_ty } - acc' = arg' : addArgWrap (mkWpCastN fun_co) acc - + ; arg' <- quickLookArg do_ql ctxt arg arg_ty + ; let acc' = arg' : addArgWrap (mkWpCastN fun_co) acc ; go (pos+1) acc' res_ty rest_args } new_arg_ty :: LHsExpr GhcRn -> Int -> TcM (Scaled TcType) @@ -1841,21 +1879,28 @@ This turned out to be more subtle than I expected. Wrinkles: -} -quickLookArg :: HsExprArg 'TcpInst -> TcM (HsExprArg 'TcpInst) +quickLookArg :: QLFlag -> AppCtxt + -> LHsExpr GhcRn -- ^ Argument + -> Scaled TcSigmaTypeFRR -- ^ Type expected by the function + -> TcM (HsExprArg 'TcpInst) -- quickLookArg1 implements the "QL Argument" judgement in Fig 5 of the paper -- See Note [Quick Look at value arguments] -quickLookArg e_arg@(EValArg { ea_ctxt = ctxt - , ea_arg = larg@(L _ arg) - , ea_arg_ty = orig_arg_ty }) - = do { let !(Scaled _ orig_arg_rho) = orig_arg_ty - -- NB: orig_arg_rho may not be zonked, but that's ok - ; is_rho <- tcIsDeepRho orig_arg_rho +quickLookArg NoQL ctxt larg orig_arg_ty + = skipQuickLook ctxt larg orig_arg_ty +quickLookArg DoQL ctxt larg orig_arg_ty + = do { is_rho <- tcIsDeepRho (scaledThing orig_arg_ty) ; traceTc "qla" (ppr orig_arg_ty $$ ppr is_rho) ; if not is_rho - then return e_arg - else + then skipQuickLook ctxt larg orig_arg_ty + else quickLookArg1 ctxt larg orig_arg_ty } - addArgCtxt ctxt larg $ -- Context needed for constraints +quickLookArg1 :: AppCtxt -> LHsExpr GhcRn + -> Scaled TcRhoType -- Deeply skolemised + -> TcM (HsExprArg 'TcpInst) +-- quickLookArg1 implements the "QL Argument" judgement in Fig 5 of the paper +quickLookArg1 ctxt larg@(L _ arg) sc_arg_ty@(Scaled _ orig_arg_rho) + -- NB: orig_arg_rho may not be zonked, but that's ok + = addArgCtxt ctxt larg $ -- Context needed for constraints -- generated by calls in arg do { ((rn_fun, fun_ctxt), rn_args) <- splitHsApps arg @@ -1873,7 +1918,7 @@ quickLookArg e_arg@(EValArg { ea_ctxt = ctxt , text "args:" <+> ppr rn_args ] ; case mb_fun_ty of { - Nothing -> return e_arg ; -- fun is too complicated + Nothing -> skipQuickLook ctxt larg sc_arg_ty ; -- fun is too complicated Just (tc_fun, fun_sigma) -> -- step 2: use |-inst to instantiate the head applied to the arguments @@ -1903,37 +1948,40 @@ quickLookArg e_arg@(EValArg { ea_ctxt = ctxt -- unzonked orig_arg_rho, so that we deliberately do not exploit -- guardedness that emerges a result of QL on earlier args -- In contrast, we must do the `anyFreeKappa` test /after/ tcInstFun; see (QLA3). + ; arg_influences_enclosing_call + <- if isGuardedTy orig_arg_rho + then return True + else not <$> anyFreeKappa app_res_rho -- (B) + -- For (B) see Note [The fiv test in quickLookArg] - ; (arg_influences_call, inst_args_ql) - <- if isGuardedTy orig_arg_rho -- (A) - then do { qlUnify app_res_rho orig_arg_rho - ; inst_args_with_guards <- mapM reGuardArg inst_args - ; inst_args_ql <- mapM quickLookArg inst_args_with_guards - ; return (True, inst_args_ql) } - else do { inst_args_ql <- mapM quickLookArg inst_args - ; has_free_inst_vars <- anyFreeKappa app_res_rho --(B) - ; if has_free_inst_vars - then return (False, inst_args_ql) - else do { qlUnify app_res_rho orig_arg_rho - ; return (True, inst_args_ql) } } + -- Step 4: do quick-look unification if either (A) or (B) hold + -- NB: orig_arg_rho may not be zonked, but that's ok + ; when arg_influences_enclosing_call $ + quickLookResultType app_res_rho orig_arg_rho ; traceTc "quickLookArg done }" (ppr rn_fun) ; return (EValArgQL { eaql_ctxt = ctxt - , eaql_arg_ty = orig_arg_ty + , eaql_arg_ty = sc_arg_ty , eaql_larg = larg , eaql_tc_fun = tc_head , eaql_fun_ue = fun_ue - , eaql_args = inst_args_ql + , eaql_args = inst_args , eaql_wanted = wanted - , eaql_encl = arg_influences_call - , eaql_res_rho = app_res_rho }) }}}} + , eaql_encl = arg_influences_enclosing_call + , eaql_res_rho = app_res_rho }) }}} -quickLookArg other_arg = return other_arg +quickLookResultType :: TcRhoType -> TcRhoType -> TcM () +-- See Note [QuickLook: arguments before result] +quickLookResultType app_rest_rho exp_res_rho + = qlUnify app_rest_rho exp_res_rho -whenQL :: QLFlag -> ZonkM () -> TcM () -whenQL DoQL thing_inside = liftZonkM thing_inside -whenQL NoQL _ = return () +skipQuickLook :: AppCtxt -> LHsExpr GhcRn -> Scaled TcRhoType + -> TcM (HsExprArg 'TcpInst) +skipQuickLook ctxt larg arg_ty + = return (EValArg { ea_ctxt = ctxt + , ea_arg = larg + , ea_arg_ty = arg_ty }) tcIsDeepRho :: TcType -> TcM Bool -- This top-level zonk step, which is the reason we need a local 'go' loop, @@ -1961,15 +2009,6 @@ tcIsDeepRho ty | otherwise = return True -reGuardArg :: HsExprArg 'TcpInst -> TcM (HsExprArg 'TcpInst) --- Zonk the result type of an EValArg, so that a subseqent --- call to isGuardedTy will see the unifications so far -reGuardArg arg@(EValArg { ea_arg_ty = arg_ty }) - = do { arg_ty' <- liftZonkM $ zonkScaledTcType arg_ty - ; return (arg { ea_arg_ty = arg_ty' }) } -reGuardArg arg - = return arg - isGuardedTy :: TcType -> Bool isGuardedTy ty | Just (tc,_) <- tcSplitTyConApp_maybe ty = isGenerativeTyCon tc Nominal View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/fa545237fe7514276f690ae5fdfa789… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/fa545237fe7514276f690ae5fdfa789… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/backports-9.14] rts/linker/PEi386: Copy strings before they are inserted into LoadedDllCache....
by Zubin (＠wz1000) 28 Nov '25

28 Nov '25

Zubin pushed to branch wip/backports-9.14 at Glasgow Haskell Compiler / GHC Commits: 85e8147d by Zubin Duggal at 2025-11-28T14:00:24+05:30 rts/linker/PEi386: Copy strings before they are inserted into LoadedDllCache. The original strings are temporary and might be freed at an arbitrary point. Fixes #26613 (cherry picked from commit 5072da477b8ec883aea4b9ea27763fcc1971af1a) - - - - - 1 changed file: - rts/linker/PEi386.c Changes: ===================================== rts/linker/PEi386.c ===================================== @@ -552,7 +552,12 @@ static int compare_path(StgWord key1, StgWord key2) static void addLoadedDll(LoadedDllCache *cache, const pathchar *dll_name, HINSTANCE instance) { - insertHashTable_(cache->hash, (StgWord) dll_name, instance, hash_path); + // dll_name might be deallocated, we need to copy it to have a stable reference to the contents + // See #26613 + size_t size = wcslen(dll_name) + 1; + pathchar* dll_name_copy = stgMallocBytes(size * sizeof(pathchar), "addLoadedDll"); + wcsncpy(dll_name_copy, dll_name, size); + insertHashTable_(cache->hash, (StgWord) dll_name_copy, instance, hash_path); } static HINSTANCE isDllLoaded(const LoadedDllCache *cache, const pathchar *dll_name) View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/85e8147dd7893db46db1868d65f4cff… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/85e8147dd7893db46db1868d65f4cff… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/26613] rts/linker/PEi386: Copy strings before they are inserted into LoadedDllCache....
by Zubin (＠wz1000) 28 Nov '25

28 Nov '25

Zubin pushed to branch wip/26613 at Glasgow Haskell Compiler / GHC Commits: 5072da47 by Zubin Duggal at 2025-11-28T13:48:36+05:30 rts/linker/PEi386: Copy strings before they are inserted into LoadedDllCache. The original strings are temporary and might be freed at an arbitrary point. Fixes #26613 - - - - - 1 changed file: - rts/linker/PEi386.c Changes: ===================================== rts/linker/PEi386.c ===================================== @@ -552,7 +552,12 @@ static int compare_path(StgWord key1, StgWord key2) static void addLoadedDll(LoadedDllCache *cache, const pathchar *dll_name, HINSTANCE instance) { - insertHashTable_(cache->hash, (StgWord) dll_name, instance, hash_path); + // dll_name might be deallocated, we need to copy it to have a stable reference to the contents + // See #26613 + size_t size = wcslen(dll_name) + 1; + pathchar* dll_name_copy = stgMallocBytes(size * sizeof(pathchar), "addLoadedDll"); + wcsncpy(dll_name_copy, dll_name, size); + insertHashTable_(cache->hash, (StgWord) dll_name_copy, instance, hash_path); } static HINSTANCE isDllLoaded(const LoadedDllCache *cache, const pathchar *dll_name) View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/5072da477b8ec883aea4b9ea27763fc… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/5072da477b8ec883aea4b9ea27763fc… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][ghc-9.12] 20 commits: rts: fix top handler closure type signatures
by Zubin (＠wz1000) 28 Nov '25

28 Nov '25

Zubin pushed to branch ghc-9.12 at Glasgow Haskell Compiler / GHC Commits: d4489170 by Cheng Shao at 2025-11-21T15:50:36+01:00 rts: fix top handler closure type signatures This commit fixes the runIO/runNonIO closure type signatures in the RTS which should be extern StgClosure. This allows us to remove an unnecessary type cast in the C foreign desugaring logic, as well as unneeded complications of JSFFI desugaring logic that also needs to generate C stubs that may refer to those top handler closures. Otherwise, we'll have to take special care to avoid generating "extern StgClosure" declarations for them as we would for other closures, just to avoid conflicting type signature error at stub compile time. (cherry picked from commit c78d8f55afacfd559b1602bc2fbc35b1f326f1c1) - - - - - 18d6cf11 by Cheng Shao at 2025-11-21T15:50:36+01:00 compiler: allow arbitrary label string for JSFFI exports This commit allows arbitrary label string to appear in a foreign export declaration, as long as the calling convention is javascript. Well, doesn't make sense to enforce it's a C function symbol for a JSFFI declaration anyway, and it gets in the way of implementing the "sync" flavour of exports. (cherry picked from commit a204df3aa5a7be00c67aa7c92c5091ab32522226) - - - - - 3ecb5e0b by Cheng Shao at 2025-11-21T15:50:36+01:00 compiler: wasm backend JSFFI sync exports This commit implements the synchronous flavour of the wasm backend JSFFI exports: - `foreign export javascript "foo sync"` exports a top-level Haskell binding as a synchronous JS function - `foreign import javascript "wrapper sync"` dynamically exports a Haskell function closure as a synchronous JS function - `foreign import javascript unsafe` is now re-entrant by lowering to a safe ccall - Also fix the issue that JSFFI dynamic exports didn't really work in TH & ghci (#25473) (cherry picked from commit 03ebab52bd00d4726735829cf6a24e5c9d3ac0c1) - - - - - 5afe9c33 by Cheng Shao at 2025-11-21T15:50:36+01:00 testsuite: test wasm backend JSFFI sync exports This commit repurposes some existing JSFFI test cases to make them cover JSFFI sync exports as well. (cherry picked from commit b6ae908bd3ae7b75b79925e56c3e11ba5c40b5ec) - - - - - 9efbf3f4 by Cheng Shao at 2025-11-21T15:50:37+01:00 docs: document wasm backend JSFFI sync exports This commit updates wasm backend documentation to reflect the new JSFFI sync exports feature. (cherry picked from commit edae287402792c09fa92b655e0cbd01100db9856) - - - - - 61754416 by Cheng Shao at 2025-11-21T15:50:37+01:00 wasm: add error message to WouldBlockException This commit attaches an error message to WouldBlockException, for now the error message consists of the JS async import code snippet that thunk is trying to block for. This is useful for debugging synchronous callbacks that accidentally call an async JS function. (cherry picked from commit 9b54eecbee7329543e5016cec1574831bfb788c2) - - - - - 3b26d306 by Cheng Shao at 2025-11-21T15:50:37+01:00 ghc-experimental: make JSVal abstract in GHC.Wasm.Prim This commit makes JSVal an abstract type in the export list of GHC.Wasm.Prim. JSVal's internal representation is supposed to be a non user facing implementation detail subject to change at any time. We should only expose things that are newtypes of JSVal, not JSVal itself. (cherry picked from commit 8037f487ff1721973737b01e29136c671fd25157) - - - - - 03600749 by Cheng Shao at 2025-11-21T15:50:37+01:00 wasm: make JSVal internal Weak# point to lifted JSVal JSVal has an internal Weak# with the unlifted JSVal# object as key to arrange its builtin finalization logic. The Weak# used to designate Unit_closure as a dummy value; now this commit designates the lifted JSVal closure as the Weak# value. This allows the implementation of mkWeakJSVal which can be used to observe the liveliness of a JSVal and attach a user-specified finalizer. (cherry picked from commit 4f34243101684a0ad15f5986abec00c675b48955) - - - - - f66e52c8 by Cheng Shao at 2025-11-21T15:50:37+01:00 ghc-experimental: add mkWeakJSVal This commit adds a mkWeakJSVal function that can be used to set up a Weak pointer with a JSVal key to observe the key's lifetime and optionally attach a finalizer. (cherry picked from commit 55af20e6ed5c72a46a09b88e8590b6b2309eb41b) - - - - - da0ccd0e by Cheng Shao at 2025-11-21T15:50:37+01:00 wasm: don't create a wasm global for dyld poison There's a much more efficient way to convert an unsigned i32 to a signed one. Thanks, o3-mini-high. (cherry picked from commit 75fcc5c9ab900cb80834802c581283681cf8c398) - - - - - 8003474f by Cheng Shao at 2025-11-21T16:01:18+01:00 wasm: revamp JSFFI internal implementation and documentation This patch revamps the wasm backend's JSFFI internal implementation and documentation: - `JSValManager` logic to allocate a key is simplified to simple bumping. According to experiments with all major browsers, the internal `Map` would overflow the heap much earlier before we really exhaust the 32-bit key space, so there's no point in the extra complexity. - `freeJSVal` is now idempotent and safe to call more than once. This is achieved by attaching the `StablePtr#` to the `JSVal#` closure and nullifying it when calling `freeJSVal`, so the same stable pointer cannot be double freed. - `mkWeakJSVal` no longer exposes the internal `Weak#` pointer and always creates a new `Weak#` on the fly. Otherwise by finalizing that `Weak#`, user could accidentally drop the `JSVal`, but `mkWeakJSVal` is only supposed to create a `Weak` that observes the `JSVal`'s liveliness without actually interfering it. - `PromisePendingException` is no longer exported since it's never meant to be caught by user code; it's a severe bug if it's actually raised at runtime. - Everything exported by user-facing `GHC.Wasm.Prim` now has proper haddock documentation. - Note [JSVal representation for wasm] has been updated to reflect the new JSVal# memory layout. (cherry picked from commit fd40eaa17c6ce8716ec2eacc95beae194a935352) - - - - - 60acee61 by Cheng Shao at 2025-11-21T16:03:36+01:00 rts: add hs_try_putmvar_with_value to RTS API This commit adds hs_try_putmvar_with_value to rts. It allows more flexibility than hs_try_putmvar by taking an additional value argument as a closure to be put into the MVar. This function is used & tested by the wasm backend runtime, though it makes sense to expose it as a public facing RTS API function as well. (cherry picked from commit f75e823e0a9ac9fbe661fce232324c5b103ee8a8) - - - - - cdfb37c3 by Cheng Shao at 2025-11-21T16:03:36+01:00 wasm: use MVar as JSFFI import blocking mechanism Previously, when blocking on a JSFFI import, we push a custom stg_jsffi_block stack frame and arrange the `promise.then` callback to write to that stack frame. It turns out we can simply use the good old MVar to implement the blocking logic, with a few benefits: - Less maintenance burden. We can drop the stg_jsffi_block related Cmm code without loss of functionality. - It interacts better with existing async exception mechanism. throwTo would properly block the caller if the target thread is masking async exceptions. (cherry picked from commit 9cd9f34787b4d54e1ba3fbbf927a160a0f8eab99) - - - - - 8dfb64de by Cheng Shao at 2025-11-21T16:03:36+01:00 wasm: properly pin the raiseJSException closure We used to use keepAlive# to pin the raiseJSException closure when blocking on a JSFFI import thunk, since it can potentially be used by RTS. But raiseJSException may be used in other places as well (e.g. the promise.throwTo logic), and it's better to simply unconditionally pin it in the JSFFI initialization logic. (cherry picked from commit da34f0aa2082d1c5a306cc8356abba15f3d59aad) - - - - - 0166eb5d by Cheng Shao at 2025-11-21T16:03:36+01:00 wasm: implement promise.throwTo() for async JSFFI exports This commit implements promise.throwTo() for wasm backend JSFFI exports. This allows the JavaScript side to interrupt Haskell computation by raising an async exception. See subsequent docs/test commits for more details. (cherry picked from commit dc904bfdd17ed1108580367b34bbe7204ed4ea95) - - - - - 93de375e by Cheng Shao at 2025-11-21T16:03:36+01:00 testsuite: add test for wasm promise.throwTo() logic This commit adds a test case to test the wasm backend promise.throwTo() logic. (cherry picked from commit 7f80455ee45e70d142bbc69478b9a8db43082187) - - - - - 791ac161 by Cheng Shao at 2025-11-21T16:03:36+01:00 docs: document the wasm backend promise.throwTo() feature (cherry picked from commit afdd3fe7fff60e046f6a3ee4795c58abe81f03a2) - - - - - 8d8807f2 by Cheng Shao at 2025-11-21T16:24:59+01:00 rts: fix wasm JSFFI initialization constructor code This commit fixes wasm JSFFI initialization constructor code so that the constructor is self-contained and avoids invoking a fake __main_argc_argv function. The previous approach of reusing __main_void logic in wasi-libc saves a tiny bit of code, at the expense of link-time trouble whenever GHC links a wasm module without -no-hs-main, in which case the driver-generated main function would clash with the definition here, resulting in a linker error. It's simply better to avoid messing with the main function, and it would additionally allow linking wasm32-wasi command modules that does make use of synchronous JSFFI. (cherry picked from commit bdc9d130a838017f863f5c7a380cb0858035f859) - - - - - 6d38b32c by Cheng Shao at 2025-11-21T17:16:11+01:00 wasm: fix remaining regressions in upstream 9.12 branch This commit fixes remaining regressions in upstream 9.12 branch caused by broken backporting of !14892. Fixes #26600. - - - - - 3cd27895 by Cheng Shao at 2025-11-25T14:30:05+01:00 docs: add wasm related items in 9.12.3 notes - - - - - 31 changed files: - compiler/GHC/HsToCore/Foreign/C.hs - compiler/GHC/HsToCore/Foreign/Wasm.hs - compiler/GHC/Tc/Gen/Foreign.hs - docs/users_guide/9.12.3-notes.rst - docs/users_guide/exts/ffi.rst - docs/users_guide/wasm.rst - libraries/ghc-experimental/src/GHC/Wasm/Prim.hs - libraries/ghc-internal/src/GHC/Internal/Wasm/Prim.hs - libraries/ghc-internal/src/GHC/Internal/Wasm/Prim/Exports.hs - libraries/ghc-internal/src/GHC/Internal/Wasm/Prim/Flag.hs - libraries/ghc-internal/src/GHC/Internal/Wasm/Prim/Imports.hs - libraries/ghc-internal/src/GHC/Internal/Wasm/Prim/Types.hs - rts/RtsAPI.c - rts/RtsSymbols.c - rts/include/HsFFI.h - rts/wasm/JSFFI.c - rts/wasm/blocker.cmm - rts/wasm/jsval.cmm - rts/wasm/scheduler.cmm - testsuite/tests/jsffi/all.T - + testsuite/tests/jsffi/cancel.hs - + testsuite/tests/jsffi/cancel.mjs - + testsuite/tests/jsffi/cancel.stdout - testsuite/tests/jsffi/jsffigc.hs - testsuite/tests/jsffi/jsffigc.mjs - testsuite/tests/jsffi/jsffisleep.hs - testsuite/tests/jsffi/jsffisleep.stdout - testsuite/tests/jsffi/textconv.hs - testsuite/tests/jsffi/textconv.mjs - utils/jsffi/dyld.mjs - utils/jsffi/prelude.mjs The diff was not included because it is too large. View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/c7de5d8551824cb309c61dc625280f… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/c7de5d8551824cb309c61dc625280f… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/26613] rts/linker/PEi386: Copy strings before they are inserted into LoadedDllCache....
by Zubin (＠wz1000) 28 Nov '25

28 Nov '25

Zubin pushed to branch wip/26613 at Glasgow Haskell Compiler / GHC Commits: 259bc7fd by Zubin Duggal at 2025-11-28T13:43:25+05:30 rts/linker/PEi386: Copy strings before they are inserted into LoadedDllCache. The original strings are temporary and might be freed at an arbitrary point. Fixes #26613 - - - - - 1 changed file: - rts/linker/PEi386.c Changes: ===================================== rts/linker/PEi386.c ===================================== @@ -552,7 +552,12 @@ static int compare_path(StgWord key1, StgWord key2) static void addLoadedDll(LoadedDllCache *cache, const pathchar *dll_name, HINSTANCE instance) { - insertHashTable_(cache->hash, (StgWord) dll_name, instance, hash_path); + // dll_name might be deallocated, we need to copy it to have a stable reference to the contents + // See #26613 + size_t size = wcslen(dll_name) + 1; + pathchar* dll_name_copy = stgMallocBytes(size * sizeof(pathchar), "addLoadedDll"); + wcscpy(dll_name_copy, dll_name); + insertHashTable_(cache->hash, (StgWord) dll_name_copy, instance, hash_path); } static HINSTANCE isDllLoaded(const LoadedDllCache *cache, const pathchar *dll_name) View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/259bc7fdf5bc734b944de507cedfb8d… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/259bc7fdf5bc734b944de507cedfb8d… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][master] SimpleOpt: don't subst in pushCoercionIntoLambda
by Marge Bot (＠marge-bot) 27 Nov '25

27 Nov '25

Marge Bot pushed to branch master at Glasgow Haskell Compiler / GHC Commits: 1d4a1229 by sheaf at 2025-11-27T17:58:02-05:00 SimpleOpt: don't subst in pushCoercionIntoLambda It was noticed in #26589 that the change in 15b311be was incorrect: the simple optimiser carries two different substitution-like pieces of information: 'soe_subst' (from InVar to OutExpr) and 'soe_inl' (from InId to InExpr). It is thus incorrect to have 'pushCoercionIntoLambda' apply the substitution from 'soe_subst' while discarding 'soe_inl' entirely, which is what was done in 15b311be. Instead, we change back pushCoercionIntoLambda to take an InScopeSet, and optimise the lambda before calling 'pushCoercionIntoLambda' to avoid mixing InExpr with OutExpr, or mixing two InExpr with different environments. We can then call 'soeZapSubst' without problems. Fixes #26588 #26589 - - - - - 6 changed files: - compiler/GHC/Core/Opt/Arity.hs - compiler/GHC/Core/SimpleOpt.hs - compiler/GHC/Tc/Gen/App.hs - + testsuite/tests/simplCore/should_compile/T26588.hs - + testsuite/tests/simplCore/should_compile/T26589.hs - testsuite/tests/simplCore/should_compile/all.T Changes: ===================================== compiler/GHC/Core/Opt/Arity.hs ===================================== @@ -2993,12 +2993,12 @@ pushCoValArg co Pair tyL tyR = coercionKind co pushCoercionIntoLambda - :: HasDebugCallStack => Subst -> InVar -> InExpr -> OutCoercionR -> Maybe (OutVar, OutExpr) + :: HasDebugCallStack => InScopeSet -> Var -> CoreExpr -> CoercionR -> Maybe (Var, CoreExpr) -- This implements the Push rule from the paper on coercions -- (\x. e) |> co -- ===> -- (\x'. e |> co') -pushCoercionIntoLambda subst x e co +pushCoercionIntoLambda in_scope x e co | assert (not (isTyVar x) && not (isCoVar x)) True , Pair s1s2 t1t2 <- coercionKind co , Just {} <- splitFunTy_maybe s1s2 @@ -3011,9 +3011,9 @@ pushCoercionIntoLambda subst x e co -- Should we optimize the coercions here? -- Otherwise they might not match too well x' = x `setIdType` t1 `setIdMult` w1 - in_scope' = substInScopeSet subst `extendInScopeSet` x' + in_scope' = in_scope `extendInScopeSet` x' subst' = - extendIdSubst (setInScope subst in_scope') + extendIdSubst (setInScope emptySubst in_scope') x (mkCast (Var x') (mkSymCo co1)) -- We substitute x' for x, except we need to preserve types. ===================================== compiler/GHC/Core/SimpleOpt.hs ===================================== @@ -393,12 +393,19 @@ simple_app env e0@(Lam {}) as0@(_:_) = wrapLet mb_pr $ do_beta env'' body as where (env', b') = subst_opt_bndr env b - do_beta env e@(Lam b body) as@(CastIt co:rest) - -- See Note [Desugaring unlifted newtypes] + -- See Note [Eliminate casts in function position] + do_beta env e@(Lam b _) as@(CastIt out_co:rest) | isNonCoVarId b - , Just (b', body') <- pushCoercionIntoLambda (soe_subst env) b body co + -- Optimise the inner lambda to make it an 'OutExpr', which makes it + -- possible to call 'pushCoercionIntoLambda' with the 'OutCoercion' 'co'. + -- This is kind of horrible, as for nested casted lambdas with a big body, + -- we will repeatedly optimise the body (once for each binder). However, + -- we need to do this to avoid mixing 'InExpr' and 'OutExpr', or two + -- 'InExpr' with different environments (getting this wrong caused #26588 & #26589.) + , Lam out_b out_body <- simple_app env e [] + , Just (b', body') <- pushCoercionIntoLambda (soeInScope env) out_b out_body out_co = do_beta (soeZapSubst env) (Lam b' body') rest - -- soeZapSubst: pushCoercionIntoLambda applies the substitution + -- soeZapSubst: we've already optimised everything (the lambda and 'rest') by now. | otherwise = rebuild_app env (simple_opt_expr env e) as @@ -511,7 +518,31 @@ TL;DR: To avoid the rest of the compiler pipeline seeing these bad lambas, we rely on the simple optimiser to both inline the newtype unfolding and subsequently deal with the resulting lambdas (either beta-reducing them altogether or pushing coercions into them so that they satisfy the -representation-polymorphism invariants). +representation-polymorphism invariants). See Note [Eliminate casts in function position]. + +[Alternative approach] (GHC ticket #26608) + + We could instead, in the typechecker, emit a special form (a new constructor + of XXExprGhcTc) for instantiations of representation-polymorphic unlifted + newtypes (whether applied to a value argument or not): + + UnliftedNT :: DataCon -> [Type] -> Coercion -> XXExprGhcTc + + where "UnliftedNT nt_con [ty1, ...] co" represents the expression: + + ( nt_con @ty1 ... ) |> co + + The desugarer would then turn these AST nodes into appropriate Core, doing + what the simple optimiser does today: + - inline the compulsory unfolding of the newtype constructor + - apply it to its type arguments and beta reduce + - push the coercion into the resulting lambda + + This would have several advantages: + - the desugarer would never produce "invalid" Core that needs to be + tidied up by the simple optimiser, + - the ugly and inefficient implementation described in + Note [Eliminate casts in function position] could be removed. Wrinkle [Unlifted newtypes with wrappers] @@ -717,50 +748,49 @@ rhss here. Note [Eliminate casts in function position] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Consider the following program: +Due to the current implementation strategy for representation-polymorphic +unlifted newtypes, as described in Note [Desugaring unlifted newtypes], we rely +on the simple optimiser to push coercions into lambdas, such as in the following +example: type R :: Type -> RuntimeRep - type family R a where { R Float = FloatRep; R Double = DoubleRep } - type F :: forall (a :: Type) -> TYPE (R a) - type family F a where { F Float = Float# ; F Double = Double# } + type family R a where { R Int = IntRep } + type F :: forall a -> TYPE (R a) + type family F a where { F Int = Int# } - type N :: forall (a :: Type) -> TYPE (R a) newtype N a = MkN (F a) -As MkN is a newtype, its unfolding is a lambda which wraps its argument -in a cast: - - MkN :: forall (a :: Type). F a -> N a - MkN = /\a \(x::F a). x |> co_ax - -- recall that F a :: TYPE (R a) - -This is a representation-polymorphic lambda, in which the binder has an unknown -representation (R a). We can't compile such a lambda on its own, but we can -compile instantiations, such as `MkN @Float` or `MkN @Double`. +Now, an instantiated occurrence of 'MkN', such as 'MkN @Int' (whether applied +to a value argument or not) will lead, after inlining the compulsory unfolding +of 'MkN', to a lambda fo the form: -Our strategy to avoid running afoul of the representation-polymorphism -invariants of Note [Representation polymorphism invariants] in GHC.Core is thus: + ( \ ( x :: F Int ) -> body ) |> co - 1. Give the newtype a compulsory unfolding (it has no binding, as we can't - define lambdas with representation-polymorphic value binders in source Haskell). - 2. Rely on the optimiser to beta-reduce away any representation-polymorphic - value binders. + where + co :: ( F Int -> res ) ~# ( Int# -> res ) -For example, consider the application +The problem is that we now have a lambda abstraction whose binder does not have a +fixed RuntimeRep in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete. - MkN @Float 34.0# +However, if we use 'pushCoercionIntoLambda', we end up with: -After inlining MkN we'll get + ( \ ( x' :: Int# ) -> body' ) - ((/\a \(x:F a). x |> co_ax) @Float) |> co 34# +which satisfies the representation-polymorphism invariants of +Note [Representation polymorphism invariants] in GHC.Core. -where co :: (F Float -> N Float) ~ (Float# ~ N Float) +In conclusion: -But to actually beta-reduce that lambda, we need to push the 'co' -inside the `\x` with pushCoercionIntoLambda. Hence the extra -equation for Cast-of-Lam in simple_app. + 1. The simple optimiser must push casts into lambdas. + 2. It must also deal with a situation such as (MkN @Int) |> co, where we first + inline the compulsory unfolding of N. This means the simple optimiser must + "peel off" the casts and optimise the inner expression first, to determine + whether it is a lambda abstraction or not. -This is regrettably delicate. +This is regrettably delicate. If we could make sure the typechecker/desugarer +did not produce these bad lambdas in the first place (as described in +[Alternative approach] in Note [Desugaring unlifted newtypes]), we could +get rid of this ugly logic. Note [Preserve join-binding arity] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -1673,7 +1703,7 @@ exprIsLambda_maybe ise@(ISE in_scope_set _) (Cast casted_e co) -- this implies that x is not in scope in gamma (makes this code simpler) , not (isTyVar x) && not (isCoVar x) , assert (not $ x `elemVarSet` tyCoVarsOfCo co) True - , Just (x',e') <- pushCoercionIntoLambda (mkEmptySubst in_scope_set) x e co + , Just (x',e') <- pushCoercionIntoLambda in_scope_set x e co , let res = Just (x',e',ts) = --pprTrace "exprIsLambda_maybe:Cast" (vcat [ppr casted_e,ppr co,ppr res)]) res ===================================== compiler/GHC/Tc/Gen/App.hs ===================================== @@ -749,13 +749,13 @@ tcInstFun do_ql inst_final (tc_fun, fun_ctxt) fun_sigma rn_args go1 _pos acc fun_ty [] | XExpr (ConLikeTc (RealDataCon dc)) <- tc_fun , isNewDataCon dc - , [Scaled _ arg_ty] <- dataConOrigArgTys dc + , [Scaled _ orig_arg_ty] <- dataConOrigArgTys dc , n_val_args == 0 -- If we're dealing with an unsaturated representation-polymorphic -- UnliftedNewype, then perform a representation-polymorphism check. -- See Note [Representation-polymorphism checks for unsaturated unlifted newtypes] -- in GHC.Tc.Utils.Concrete. - , not $ typeHasFixedRuntimeRep arg_ty + , not $ typeHasFixedRuntimeRep orig_arg_ty = do { (wrap_co, arg_ty, res_ty) <- matchActualFunTy (FRRRepPolyUnliftedNewtype dc) (Just $ HsExprTcThing tc_fun) ===================================== testsuite/tests/simplCore/should_compile/T26588.hs ===================================== @@ -0,0 +1,32 @@ +module T26588 ( getOptionSettingFromText ) where + +import Control.Applicative ( Const(..) ) +import Data.Map (Map) +import qualified Data.Map.Strict as Map + +------------------------------------------------------------------------ +-- ConfigState + +data ConfigLeaf +data ConfigTrie = ConfigTrie !(Maybe ConfigLeaf) !ConfigMap + +type ConfigMap = Map Int ConfigTrie + +freshLeaf :: [Int] -> ConfigLeaf -> ConfigTrie +freshLeaf [] l = ConfigTrie (Just l) mempty +freshLeaf (a:as) l = ConfigTrie Nothing (Map.singleton a (freshLeaf as l)) + +adjustConfigTrie :: Functor t => [Int] -> (Maybe ConfigLeaf -> t (Maybe ConfigLeaf)) -> Maybe (ConfigTrie) -> t (Maybe ConfigTrie) +adjustConfigTrie as f Nothing = fmap (freshLeaf as) <$> f Nothing +adjustConfigTrie (a:as) f (Just (ConfigTrie x m)) = Just . ConfigTrie x <$> adjustConfigMap a as f m +adjustConfigTrie [] f (Just (ConfigTrie x m)) = g <$> f x + where g Nothing | Map.null m = Nothing + g x' = Just (ConfigTrie x' m) + +adjustConfigMap :: Functor t => Int -> [Int] -> (Maybe ConfigLeaf -> t (Maybe ConfigLeaf)) -> ConfigMap -> t ConfigMap +adjustConfigMap a as f = Map.alterF (adjustConfigTrie as f) a + +getOptionSettingFromText :: Int -> [Int] -> ConfigMap -> IO () +getOptionSettingFromText p ps = getConst . adjustConfigMap p ps f + where + f _ = Const (return ()) ===================================== testsuite/tests/simplCore/should_compile/T26589.hs ===================================== @@ -0,0 +1,44 @@ +module T26589 ( executeTest ) where + +-- base +import Data.Coerce ( coerce ) +import Data.Foldable ( foldMap ) + +-------------------------------------------------------------------------------- + +newtype Traversal f = Traversal { getTraversal :: f () } + +instance Applicative f => Semigroup (Traversal f) where + Traversal f1 <> Traversal f2 = Traversal $ f1 *> f2 +instance Applicative f => Monoid (Traversal f) where + mempty = Traversal $ pure () + +newtype Seq a = Seq (FingerTree (Elem a)) +newtype Elem a = Elem { getElem :: a } + +data FingerTree a + = EmptyT + | Deep !a (FingerTree a) !a + +executeTest :: Seq () -> IO () +executeTest fins = destroyResources + where + destroyResources :: IO () + destroyResources = + getTraversal $ + flip foldMap1 fins $ \ _ -> + Traversal $ return () + +foldMap1 :: forall m a. Monoid m => (a -> m) -> Seq a -> m +foldMap1 = coerce (foldMap2 :: (Elem a -> m) -> FingerTree (Elem a) -> m) + +foldMap2 :: Monoid m => (Elem a -> m) -> FingerTree (Elem a) -> m +foldMap2 _ EmptyT = mempty +foldMap2 f' (Deep pr' m' sf') = f' pr' <> foldMapTree f' m' <> f' sf' + where + foldMapTree :: Monoid m => (a -> m) -> FingerTree a -> m + foldMapTree _ EmptyT = mempty + foldMapTree f (Deep pr m sf) = + f pr <> + foldMapTree f m <> + f sf ===================================== testsuite/tests/simplCore/should_compile/all.T ===================================== @@ -544,6 +544,9 @@ test('T25883b', normal, compile_grep_core, ['']) test('T25883c', normal, compile_grep_core, ['']) test('T25883d', [extra_files(['T25883d_import.hs'])], multimod_compile_filter, ['T25883d', '-O -ddump-simpl -dno-typeable-binds -dsuppress-all -dsuppress-uniques', r'grep -e "y ="']) +test('T26588', normal, compile, ['-package containers -O']) +test('T26589', normal, compile, ['-O']) + test('T25976', [grep_errmsg('Dead Code')], compile, ['-O -ddump-simpl -dsuppress-uniques -dno-typeable-binds']) test('T25965', normal, compile, ['-O']) View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/1d4a122935cde58ac75b98f45966364… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/1d4a122935cde58ac75b98f45966364… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][master] rts: Fix a deadlock with eventlog flush interval and RTS shutdown
by Marge Bot (＠marge-bot) 27 Nov '25

27 Nov '25

Marge Bot pushed to branch master at Glasgow Haskell Compiler / GHC Commits: b7fe7445 by Matthew Pickering at 2025-11-27T17:56:59-05:00 rts: Fix a deadlock with eventlog flush interval and RTS shutdown The ghc_ticker thread attempts to flush at the eventlog tick interval, this requires waiting to take all capabilities. At the same time, the main thread is shutting down, the schedule is stopped and then we wait for the ticker thread to finish. Therefore we are deadlocked. The solution is to use `newBoundTask/exitMyTask`, so that flushing can cooperate with the scheduler shutdown. Fixes #26573 - - - - - 2 changed files: - rts/eventlog/EventLog.c - testsuite/tests/rts/all.T Changes: ===================================== rts/eventlog/EventLog.c ===================================== @@ -491,13 +491,7 @@ endEventLogging(void) eventlog_enabled = false; - // Flush all events remaining in the buffers. - // - // N.B. Don't flush if shutting down: this was done in - // finishCapEventLogging and the capabilities have already been freed. - if (getSchedState() != SCHED_SHUTTING_DOWN) { - flushEventLog(NULL); - } + flushEventLog(NULL); ACQUIRE_LOCK(&eventBufMutex); @@ -1626,15 +1620,24 @@ void flushEventLog(Capability **cap USED_IF_THREADS) return; } + // N.B. Don't flush if shutting down: this was done in + // finishCapEventLogging and the capabilities have already been freed. + // This can also race against the shutdown if the flush is triggered by the + // ticker thread. (#26573) + if (getSchedState() == SCHED_SHUTTING_DOWN) { + return; + } + ACQUIRE_LOCK(&eventBufMutex); printAndClearEventBuf(&eventBuf); RELEASE_LOCK(&eventBufMutex); #if defined(THREADED_RTS) - Task *task = getMyTask(); + Task *task = newBoundTask(); stopAllCapabilitiesWith(cap, task, SYNC_FLUSH_EVENT_LOG); flushAllCapsEventsBufs(); releaseAllCapabilities(getNumCapabilities(), cap ? *cap : NULL, task); + exitMyTask(); #else flushLocalEventsBuf(getCapability(0)); #endif ===================================== testsuite/tests/rts/all.T ===================================== @@ -2,6 +2,11 @@ test('testblockalloc', [c_src, only_ways(['normal','threaded1']), extra_run_opts('+RTS -I0')], compile_and_run, ['']) +test('numeric_version_eventlog_flush', + [ignore_stdout, req_ghc_with_threaded_rts], + run_command, + ['{compiler} --numeric-version +RTS -l --eventlog-flush-interval=1 -RTS']) + test('testmblockalloc', [c_src, only_ways(['normal','threaded1']), extra_run_opts('+RTS -I0 -xr0.125T'), when(arch('wasm32'), skip)], # MBlocks can't be freed on wasm32, see Note [Megablock allocator on wasm] in rts View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/b7fe744598b4569cd0236268e4f6f5b… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/b7fe744598b4569cd0236268e4f6f5b… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][master] 2 commits: Switch off specialisation in ExactPrint
by Marge Bot (＠marge-bot) 27 Nov '25

27 Nov '25

Marge Bot pushed to branch master at Glasgow Haskell Compiler / GHC Commits: fa2aaa00 by Simon Peyton Jones at 2025-11-27T17:56:18-05:00 Switch off specialisation in ExactPrint In !15057 (where we re-introduced -fpolymoprhic-specialisation) we found that ExactPrint's compile time blew up by a factor of 5. It turned out to be caused by bazillions of specialisations of `markAnnotated`. Since ExactPrint isn't perf-critical, it does not seem worth taking the performance hit, so this patch switches off specialisation in this one module. - - - - - 1fd25987 by Simon Peyton Jones at 2025-11-27T17:56:18-05:00 Switch -fpolymorphic-specialisation on by default This patch addresses #23559. Now that !10479 has landed and #26329 is fixed, we can switch on polymorphic specialisation by default, addressing a bunch of other tickets listed in #23559. Metric changes: * CoOpt_Singleton: +4% compiler allocations: we just get more specialisations * info_table_map_perf: -20% decrease in compiler allocations. This is caused by using -fno-specialise in ExactPrint.hs Without that change we get a 4x blow-up in compile time; see !15058 for details Metric Decrease: info_table_map_perf Metric Increase: CoOpt_Singletons - - - - - 5 changed files: - compiler/GHC/Driver/DynFlags.hs - compiler/GHC/Driver/Flags.hs - docs/users_guide/using-optimisation.rst - testsuite/tests/simplCore/should_compile/T8331.stderr - utils/check-exact/ExactPrint.hs Changes: ===================================== compiler/GHC/Driver/DynFlags.hs ===================================== @@ -1268,6 +1268,7 @@ optLevelFlags -- see Note [Documenting optimisation flags] , ([1,2], Opt_CfgBlocklayout) -- Experimental , ([1,2], Opt_Specialise) + , ([1,2], Opt_PolymorphicSpecialisation) -- Now on by default (#23559) , ([1,2], Opt_CrossModuleSpecialise) , ([1,2], Opt_InlineGenerics) , ([1,2], Opt_Strictness) ===================================== compiler/GHC/Driver/Flags.hs ===================================== @@ -909,6 +909,7 @@ optimisationFlags = EnumSet.fromList , Opt_SpecialiseAggressively , Opt_CrossModuleSpecialise , Opt_StaticArgumentTransformation + , Opt_PolymorphicSpecialisation , Opt_CSE , Opt_StgCSE , Opt_StgLiftLams ===================================== docs/users_guide/using-optimisation.rst ===================================== @@ -1325,10 +1325,7 @@ as such you shouldn't need to set any of them explicitly. A flag :reverse: -fno-polymorphic-specialisation :category: - :default: off - - Warning, this feature is highly experimental and may lead to incorrect runtime - results. Use at your own risk (:ghc-ticket:`23469`, :ghc-ticket:`23109`, :ghc-ticket:`21229`, :ghc-ticket:`23445`). + :default: on Enable specialisation of function calls to known dictionaries with free type variables. The created specialisation will abstract over the type variables free in the dictionary. ===================================== testsuite/tests/simplCore/should_compile/T8331.stderr ===================================== @@ -1,5 +1,148 @@ ==================== Tidy Core rules ==================== +"SPEC $c*> @(ST s) @_" + forall (@s) (@r) ($dApplicative :: Applicative (ST s)). + $fApplicativeReaderT_$c*> @(ST s) @r $dApplicative + = ($fApplicativeReaderT2 @s @r) + `cast` (forall (a ::~ <*>_N) (b ::~ <*>_N). + <ReaderT r (ST s) a>_R + ->_R <ReaderT r (ST s) b>_R + ->_R <r>_R ->_R Sym (N:ST <s>_N _R) + ; Sym (N:ReaderT <*>_N <r>_R <ST s>_R _N) + :: Coercible + (forall a b. + ReaderT r (ST s) a -> ReaderT r (ST s) b -> r -> STRep s b) + (forall a b. + ReaderT r (ST s) a -> ReaderT r (ST s) b -> ReaderT r (ST s) b)) +"SPEC $c<$ @(ST s) @_" + forall (@s) (@r) ($dFunctor :: Functor (ST s)). + $fFunctorReaderT_$c<$ @(ST s) @r $dFunctor + = ($fApplicativeReaderT6 @s @r) + `cast` (forall (a ::~ <*>_N) (b ::~ <*>_N). + <a>_R + ->_R <ReaderT r (ST s) b>_R + ->_R <r>_R ->_R Sym (N:ST <s>_N <a>_R) + ; Sym (N:ReaderT <*>_N <r>_R <ST s>_R <a>_N) + :: Coercible + (forall a b. a -> ReaderT r (ST s) b -> r -> STRep s a) + (forall a b. a -> ReaderT r (ST s) b -> ReaderT r (ST s) a)) +"SPEC $c<* @(ST s) @_" + forall (@s) (@r) ($dApplicative :: Applicative (ST s)). + $fApplicativeReaderT_$c<* @(ST s) @r $dApplicative + = ($fApplicativeReaderT1 @s @r) + `cast` (forall (a ::~ <*>_N) (b ::~ <*>_N). + <ReaderT r (ST s) a>_R + ->_R <ReaderT r (ST s) b>_R + ->_R <r>_R ->_R Sym (N:ST <s>_N <a>_R) + ; Sym (N:ReaderT <*>_N <r>_R <ST s>_R <a>_N) + :: Coercible + (forall a b. + ReaderT r (ST s) a -> ReaderT r (ST s) b -> r -> STRep s a) + (forall a b. + ReaderT r (ST s) a -> ReaderT r (ST s) b -> ReaderT r (ST s) a)) +"SPEC $c<*> @(ST s) @_" + forall (@s) (@r) ($dApplicative :: Applicative (ST s)). + $fApplicativeReaderT9 @(ST s) @r $dApplicative + = ($fApplicativeReaderT4 @s @r) + `cast` (forall (a ::~ <*>_N) (b ::~ <*>_N). + <ReaderT r (ST s) (a -> b)>_R + ->_R <ReaderT r (ST s) a>_R + ->_R <r>_R + ->_R Sym (N:ST <s>_N _R) + :: Coercible + (forall a b. + ReaderT r (ST s) (a -> b) -> ReaderT r (ST s) a -> r -> STRep s b) + (forall a b. + ReaderT r (ST s) (a -> b) -> ReaderT r (ST s) a -> r -> ST s b)) +"SPEC $c>> @(ST s) @_" + forall (@s) (@r) ($dMonad :: Monad (ST s)). + $fMonadReaderT1 @(ST s) @r $dMonad + = $fMonadAbstractIOSTReaderT_$s$c>> @s @r +"SPEC $c>>= @(ST s) @_" + forall (@s) (@r) ($dMonad :: Monad (ST s)). + $fMonadReaderT2 @(ST s) @r $dMonad + = ($fMonadAbstractIOSTReaderT2 @s @r) + `cast` (forall (a ::~ <*>_N) (b ::~ <*>_N). + <ReaderT r (ST s) a>_R + ->_R <a -> ReaderT r (ST s) b>_R + ->_R <r>_R + ->_R Sym (N:ST <s>_N _R) + :: Coercible + (forall a b. + ReaderT r (ST s) a -> (a -> ReaderT r (ST s) b) -> r -> STRep s b) + (forall a b. + ReaderT r (ST s) a -> (a -> ReaderT r (ST s) b) -> r -> ST s b)) +"SPEC $cfmap @(ST s) @_" + forall (@s) (@r) ($dFunctor :: Functor (ST s)). + $fFunctorReaderT_$cfmap @(ST s) @r $dFunctor + = ($fApplicativeReaderT7 @s @r) + `cast` (forall (a ::~ <*>_N) (b ::~ <*>_N). + <a -> b>_R + ->_R <ReaderT r (ST s) a>_R + ->_R <r>_R ->_R Sym (N:ST <s>_N _R) + ; Sym (N:ReaderT <*>_N <r>_R <ST s>_R _N) + :: Coercible + (forall a b. (a -> b) -> ReaderT r (ST s) a -> r -> STRep s b) + (forall a b. (a -> b) -> ReaderT r (ST s) a -> ReaderT r (ST s) b)) +"SPEC $cliftA2 @(ST s) @_" + forall (@s) (@r) ($dApplicative :: Applicative (ST s)). + $fApplicativeReaderT_$cliftA2 @(ST s) @r $dApplicative + = ($fApplicativeReaderT3 @s @r) + `cast` (forall (a ::~ <*>_N) (b ::~ <*>_N) (c ::~ <*>_N). + <a -> b -> c>_R + ->_R <ReaderT r (ST s) a>_R + ->_R <ReaderT r (ST s) b>_R + ->_R <r>_R ->_R Sym (N:ST <s>_N <c>_R) + ; Sym (N:ReaderT <*>_N <r>_R <ST s>_R <c>_N) + :: Coercible + (forall a b c. + (a -> b -> c) + -> ReaderT r (ST s) a -> ReaderT r (ST s) b -> r -> STRep s c) + (forall a b c. + (a -> b -> c) + -> ReaderT r (ST s) a -> ReaderT r (ST s) b -> ReaderT r (ST s) c)) +"SPEC $cp1Applicative @(ST s) @_" + forall (@s) (@r) ($dApplicative :: Applicative (ST s)). + $fApplicativeReaderT_$cp1Applicative @(ST s) @r $dApplicative + = $fApplicativeReaderT_$s$fFunctorReaderT @s @r +"SPEC $cp1Monad @(ST s) @_" + forall (@s) (@r) ($dMonad :: Monad (ST s)). + $fMonadReaderT_$cp1Monad @(ST s) @r $dMonad + = $fApplicativeReaderT_$s$fApplicativeReaderT @s @r +"SPEC $cpure @(ST s) @_" + forall (@s) (@r) ($dApplicative :: Applicative (ST s)). + $fApplicativeReaderT_$cpure @(ST s) @r $dApplicative + = ($fApplicativeReaderT5 @s @r) + `cast` (forall (a ::~ <*>_N). + <a>_R + ->_R <r>_R ->_R Sym (N:ST <s>_N <a>_R) + ; Sym (N:ReaderT <*>_N <r>_R <ST s>_R <a>_N) + :: Coercible + (forall a. a -> r -> STRep s a) + (forall a. a -> ReaderT r (ST s) a)) +"SPEC $creturn @(ST s) @_" + forall (@s) (@r) ($dMonad :: Monad (ST s)). + $fMonadReaderT_$creturn @(ST s) @r $dMonad + = ($fApplicativeReaderT5 @s @r) + `cast` (forall (a ::~ <*>_N). + <a>_R + ->_R <r>_R ->_R Sym (N:ST <s>_N <a>_R) + ; Sym (N:ReaderT <*>_N <r>_R <ST s>_R <a>_N) + :: Coercible + (forall a. a -> r -> STRep s a) + (forall a. a -> ReaderT r (ST s) a)) +"SPEC $fApplicativeReaderT @(ST s) @_" + forall (@s) (@r) ($dApplicative :: Applicative (ST s)). + $fApplicativeReaderT @(ST s) @r $dApplicative + = $fApplicativeReaderT_$s$fApplicativeReaderT @s @r +"SPEC $fFunctorReaderT @(ST s) @_" + forall (@s) (@r) ($dFunctor :: Functor (ST s)). + $fFunctorReaderT @(ST s) @r $dFunctor + = $fApplicativeReaderT_$s$fFunctorReaderT @s @r +"SPEC $fMonadReaderT @(ST s) @_" + forall (@s) (@r) ($dMonad :: Monad (ST s)). + $fMonadReaderT @(ST s) @r $dMonad + = $fMonadAbstractIOSTReaderT_$s$fMonadReaderT @s @r "USPEC useAbstractMonad @(ReaderT Int (ST s))" forall (@s) ($dMonadAbstractIOST :: MonadAbstractIOST (ReaderT Int (ST s))). ===================================== utils/check-exact/ExactPrint.hs ===================================== @@ -19,6 +19,13 @@ {-# LANGUAGE UndecidableInstances #-} -- For the (StmtLR GhcPs GhcPs (LocatedA (body GhcPs))) ExactPrint instance {-# OPTIONS_GHC -Wno-incomplete-uni-patterns -Wno-incomplete-record-updates #-} +-- We switch off specialisation in this module. Otherwise we get lots of functions +-- specialised on lots of (GHC syntax tree) data types. Compilation time allocation +-- (at least with -fpolymorphic-specialisation; see !15058) blows up from 17G to 108G. +-- Bad! ExactPrint is not a performance-critical module so it's not worth taking the +-- largely-fruitless hit in compile time. +{-# OPTIONS_GHC -fno-specialise #-} + module ExactPrint ( ExactPrint(..) View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/5b97e5ceb2f068b86a4eb4dd13a36f… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/5b97e5ceb2f068b86a4eb4dd13a36f… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][master] Fix broken RankNTypes example in user's guide
by Marge Bot (＠marge-bot) 27 Nov '25

27 Nov '25

Marge Bot pushed to branch master at Glasgow Haskell Compiler / GHC Commits: 5b97e5ce by Simon Hengel at 2025-11-27T17:55:37-05:00 Fix broken RankNTypes example in user's guide - - - - - 1 changed file: - docs/users_guide/exts/rank_polymorphism.rst Changes: ===================================== docs/users_guide/exts/rank_polymorphism.rst ===================================== @@ -195,7 +195,7 @@ For example: :: g3c :: Int -> forall x y. y -> x -> x f4 :: (Int -> forall a. (Eq a, Show a) => a -> a) -> Bool - g4 :: Int -> forall x. (Show x, Eq x) => x -> x) -> Bool + g4 :: Int -> forall x. (Show x, Eq x) => x -> x Then the application ``f3 g3a`` is well-typed, because ``g3a`` has a type that matches the type expected by ``f3``. But ``f3 g3b`` is not well typed, because the foralls are in different places. View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/5b97e5ceb2f068b86a4eb4dd13a36fb… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/5b97e5ceb2f068b86a4eb4dd13a36fb… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][master] Fix typo in docs/users_guide/exts/type_families.rst
by Marge Bot (＠marge-bot) 27 Nov '25

27 Nov '25

Marge Bot pushed to branch master at Glasgow Haskell Compiler / GHC Commits: 98fa0d36 by Simon Hengel at 2025-11-27T17:54:57-05:00 Fix typo in docs/users_guide/exts/type_families.rst - - - - - 1 changed file: - docs/users_guide/exts/type_families.rst Changes: ===================================== docs/users_guide/exts/type_families.rst ===================================== @@ -680,7 +680,7 @@ thus: :: When doing so, we (optionally) may drop the "``family``" keyword. The type parameters must all be type variables, of course, and some (but -not necessarily all) of then can be the class parameters. Each class +not necessarily all) of them can be the class parameters. Each class parameter may only be used at most once per associated type, but some may be omitted and they may be in an order other than in the class head. Hence, the following contrived example is admissible: :: View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/98fa0d3616847fa170f8ab25fe9cc6c… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/98fa0d3616847fa170f8ab25fe9cc6c… You're receiving this email because of your account on gitlab.haskell.org.

1 0