Methods not inlined

This affects both 6.12 and the HEAD (albeit differently) but works fine with 6.10. It also works if everything is in one module. We are interested in the function U.foo; in particular, we want the call to deepSeq (resulting from inlining T.apply) to be inlined. This is what we get with 6.10 (compiling with -O2):

go_riA :: [GHC.Types.Double] -> ()
go_riA =
  \ (ds_agP :: [GHC.Types.Double]) ->
    case ds_agP of wild_agQ {
      [] -> GHC.Unit.();
      : y_agU ys_agV ->
        case y_agU of tpl2_ah1 { GHC.Types.D# ipv_ah3 -> go_riA ys_agV }
    }

U.foo :: GHC.Types.Int -> ()
U.foo =
  \ (n_afR :: GHC.Types.Int) ->
    case n_afR of w_Xhn { GHC.Types.I# ww_ahi ->
    go_riA (T.$wgen @ GHC.Types.Double T.$f2 ww_ahi)
    }

Everything has been nicely inlined. With 6.12, we get this:

U.foo [NEVER Nothing] :: GHC.Types.Int -> ()
U.foo =
  \ (n_adD :: GHC.Types.Int) ->
    case n_adD of _ { GHC.Types.I# ww_afv ->
    let {
      eta_sgc :: [GHC.Types.Double]
      eta_sgc = T.$wgen @ GHC.Types.Double T.$fCDouble ww_afv } in
    __inline_me (GHC.Base.foldr
                   @ GHC.Types.Double @ () (T.$fCDouble1 @ ()) GHC.Unit.() eta_sgc)
    }

The deepSeq call has been inlined but hasn't been optimised, I guess because GHC retained the __inline_me for some reason. Things are even worse with the HEAD:

U.foo :: GHC.Types.Int -> ()
U.foo =
  \ (n_aaO :: GHC.Types.Int) ->
    case n_aaO of _ { GHC.Types.I# ww_abR ->
    T.$fC[]1
      @ GHC.Types.Double
      T.$fCDouble
      @ ()
      (T.$w$cgen @ GHC.Types.Double T.$fCDouble ww_abR)
      GHC.Unit.()
    }

Here, deepSeq hasn't even been inlined. But let's add a dummy method to DeepSeq:

class DeepSeq a where
  deepSeq :: a -> b -> b

  dummy :: a
  dummy = undefined

Now, the HEAD actually inlines the call:

go_rcM :: [GHC.Types.Double] -> ()
go_rcM =
  \ (ds_acl :: [GHC.Types.Double]) ->
    case ds_acl of _ {
      [] -> GHC.Unit.();
      : y_acq ys_acr ->
        case y_acq of _ { GHC.Types.D# _ -> go_rcM ys_acr }
    }

U.foo :: GHC.Types.Int -> ()
U.foo =
  \ (n_aaQ :: GHC.Types.Int) ->
    case n_aaQ of _ { GHC.Types.I# ww_abI ->
    go_rcM (T.$w$cgen @ GHC.Types.Double T.$fCDouble ww_abI)
    }

Unfortunately, 6.12 still doesn't.

Trac metadata

Trac field	Value
Version	6.12.1
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture