GitLab

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

Commits:

b791a293
by Simon Peyton Jones at 2026-11-03T17:42:49+00:00
```
Wibbles
```

2 changed files:

compiler/GHC/Builtin/WiredIn/Ids.hs
compiler/GHC/Core/Opt/Simplify/Iteration.hs

Changes:

@@ -602,7 +602,13 @@ Note [noinlineId magic]
  'noinline' is used to make sure that a function f is never inlined, e.g
     noinline f x
     noinline (f x)
 -Both of these will work.  Here are the moving parts:
 +Both of these will work.  The specification is this:
 +   - Given (noinline (f e1 .. en)) where `f` is a variable, we do not
 +     inline f, but we optimise e1..en freely.
 +   - If instead we have (noinline e) where `e` is not an application headed
 +     by a variable, we switch off inlining throughout `e`.
++
 +Here are the moving parts:
  * `noinline` is magic Id (see Note [magicIds]), whose wired-in behaviour is
    defined in this module,  GHC.Builtin.WiredIn.Ids.
@@ -679,6 +685,19 @@ Wrinkles
     so for now we simply disable (NOI1) magic if pushing arguments inward would result
     in an argument that doesn't have a fixed runtime rep.
 +(NOI7) Consider
 +            noinline (case x of ...) arg
 +            noinline (let .. in ..)  arg
 +  We switch off inlining throughout the let/case, but we do not want to move
 +  `arg` under the `noinline` because then we'll end up switching off inlining in
 +  `arg` too.  So don't move anything inside the `noinline`.
++
 +  Less happily, the same happens for SCC ticks:
 +     noinline ({-# SCC "foo" #-} f arg1) arg2
 +  The bit inside the `noinline` isn't a plain variable-headed application, so
 +  we just simplify the whole `noinline` argument with inlining switched off,
 +  like let/case.
++
  Note [nospecId magic]
  ~~~~~~~~~~~~~~~~~~~~~
  The 'nospec' magic Id is used to ensure to make a value opaque to the typeclass

compiler/GHC/Core/Opt/Simplify/Iteration.hs

@@ -2375,28 +2375,26 @@ simplOutId env fun cont
  simplOutId env noinline_fun cont
    | isNoinlineId noinline_fun
    , ApplyToTy  { sc_cont = cont1 } <- cont
 -  , ApplyToTy  { sc_cont = cont2 } <- cont1
 -  , ApplyToVal { sc_cont = cont3, sc_arg = the_call, sc_cast = arg_mco
 +  , ApplyToTy  { sc_cont = cont2, sc_arg_ty = call_ty } <- cont1
 +  , ApplyToVal { sc_cont = cont3, sc_arg = the_call, sc_cast = call_mco
                 , sc_env = UnSimplified arg_se } <- cont2
    , let -- encl_app_cont collects any /arguments/ from `cont3`
          (encl_app_cont, rest_cont) = splitContArgs cont3
          new_call_ty                = contHoleType rest_cont
 -  , typeHasFixedRuntimeRep new_call_ty  -- See (NOI6) in Note [noinlineId magic]
 -  = do { -- Push any arguments in `the_call` onto `encl_app_cont`
 -         let push_args :: InExpr -> SimplCont -> SimplM (InExpr, SimplCont)
 -             -- push_args just pushes multiple arguments onto the continuation
 -             push_args (Cast f co) cont = do { cont' <- pushInCast arg_se co cont
 -                                             ; push_args f cont' }
 -             push_args (App f a)   cont = do { cont' <- pushAppCont arg_se f a cont
 -                                             ; push_args f cont' }
 -             push_args fun         cont = return (fun, cont)
 -       ;  (inner_fun, call_cont) <- push_args the_call $
 -                                    addCastMCo arg_mco $
 -                                    encl_app_cont
+-
 -       -- Now simplify the function itself, crucially setting sm_inline = False
 -       -- The /arguments/, in `call_cont` will be simplified with their own
 -       -- flags, captured in `arg_se`
 +  = do { (inner_fun, call_cont, outer_cont)
 +             <- -- See Note [noinlineId magic]...
 +                if var_at_head the_call &&             -- (NOI7)
 +                   typeHasFixedRuntimeRep new_call_ty  -- (NOI6)
 +                then do { (inner_fun, call_cont) <- push_args arg_se the_call $
 +                                                    addCastMCo call_mco       $
 +                                                    encl_app_cont
 +                        ; return (inner_fun, call_cont, rest_cont) }
 +                else do { let call_stop = addCastMCo call_mco (mkBoringStop call_ty)
 +                        ; return (the_call, call_stop, cont3) }
++
 +       -- Now simplify the function itself, in call_cont, crucially setting
 +       -- sm_inline = False. The /arguments/ in `call_cont` will be simplified
 +       -- with their own flags, captured in `arg_se`
         ; let call_env = updMode updModeForNoInline $
                          arg_se `setInScopeFromE` env
         ; (floats1, call1) <- wrapJoinFloatsX $
@@ -2404,16 +2402,29 @@ simplOutId env noinline_fun cont
               -- wrapJoinFloatsX: any floating join bindings must stay
               --                  around the call, not be floated out
 -       -- Now `rebuild` does the rest
 +       -- Now `rebuild` does the rest, wrapping in outer_cont
         ; let (new_noinline_fun, rep) = getNoinlineId new_call_ty
               noinline_expr = Var new_noinline_fun
                               `App` Type rep
                               `App` Type new_call_ty
                               `App` call1
         ; (floats2, res) <- rebuild (env `setInScopeFromF` floats1)
 -                                   noinline_expr rest_cont
 +                                   noinline_expr outer_cont
         ; return (floats1 `addFloats` floats2 , res) }
    where
 +    var_at_head :: CoreExpr -> Bool
 +    var_at_head (Var {})   = True
 +    var_at_head (App f _)  = var_at_head f
 +    var_at_head (Cast f _) = var_at_head f
 +    var_at_head _          = False
++
 +    push_args :: SimplEnv -> InExpr -> SimplCont -> SimplM (InExpr, SimplCont)
 +    -- push_args just pushes multiple arguments onto the continuation
 +    push_args arg_se (Cast f co) cont = do { cont' <- pushInCast arg_se co cont
 +                                           ; push_args arg_se f cont' }
 +    push_args arg_se (App f a)   cont = do { cont' <- pushAppCont arg_se f a cont
 +                                           ; push_args arg_se f cont' }
 +    push_args _      fun         cont = return (fun, cont)
  -----------------------
  -- General fall-through case for (f e1 .. en)