#11444: 8.0 rc1 panics in applyTypeToArgs -------------------------------------+------------------------------------- Reporter: osa1 | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1-rc1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by osa1): Also reproduced with 8.1.20160116. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11444#comment:2 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11444: 8.0 rc1 panics in applyTypeToArgs -------------------------------------+------------------------------------- Reporter: osa1 | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1-rc1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonpj): Omer writes: I found one of the problems with #11444, but I don't know how to fix it. The problem is that the desugarer is generating this function: {{{ ptrEq [InlPrag=NOINLINE] :: forall a_a1wc. a_a1wc -> a_a1wc -> Bool [LclIdX, Str=DmdType] ptrEq = \ (@ a_a1Ts) (x_a1we :: a_a1Ts) (y_a1wf :: a_a1Ts) -> case x_a1we of x_X1wq { __DEFAULT -> case y_a1wf of y_X1ws { __DEFAULT -> == @ Int GHC.Classes.$fEqInt (case reallyUnsafePtrEquality# @ a_a1Ts x_X1wq y_X1ws of wild_00 { __DEFAULT -> GHC.Types.I# wild_00 }) (GHC.Types.I# 1#) } } }}} Which is lint-safe. Then, the optimizer is transforming this into: {{{ ptrEq [InlPrag=NOINLINE] :: forall a_a1wc. a_a1wc -> a_a1wc -> Bool [LclIdX, Arity=2, Str=DmdType, Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True, Guidance=IF_ARGS [20 20] 71 0}] ptrEq = \ (@ a_a1Ts) (x_a1we :: a_a1Ts) (y_a1wf :: a_a1Ts) -> case x_a1we of x_X1wq { __DEFAULT -> case y_a1wf of y_X1ws { __DEFAULT -> eqInt (I# (reallyUnsafePtrEquality# @ a_a1Ts x_X1wq y_X1ws)) (I# 1#) } } }}} The problem with this, according to the linter, is the argument of I# is not OK-for-speculation (the expression `reallyUnsafePtrEquality# @ a_a1Ts x_X1wq y_X1ws`). The reason is because arguments of `reallyUnsafePtrEquality#` are not OK-for-speculation, because their types are polymorphic, and variables with polymorphic types are not OK for speculation. However, I think this expression should be OK-for-speculation, because it can't fail, the primop is not out-of-line etc. I think all the requirements for being OK for speculation hold here. So my questions are: - Does that look like a correct optimization transformation? (it looked OK to me, but wanted to make sure) - Am I right that this expression should be OK for speculation? - What's a good way to make this code lint-safe? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11444#comment:4 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11444: 8.0 rc1 panics in applyTypeToArgs -------------------------------------+------------------------------------- Reporter: osa1 | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1-rc1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonpj): Omer, any thoughts about comment:5? On comment:2 * Assume for now that `reallyUnsafePtrEquality# @ a_a1Ts x_X1wq y_X1ws` is ''not'' ok-for-speculation. Then the transformation you show above should not happen. Look at this code in `Simplify`: {{{ -- 2b. Turn the case into a let, if -- a) it binds only the case-binder -- b) unlifted case: the scrutinee is ok-for-speculation -- lifted case: the scrutinee is in HNF (or will later be demanded) | all_dead_bndrs , if is_unlifted then exprOkForSpeculation scrut -- See Note [Case elimination: unlifted case] else exprIsHNF scrut -- See Note [Case elimination: lifted case] || scrut_is_demanded_var scrut = do { tick (CaseElim case_bndr) ; env' <- simplNonRecX env case_bndr scrut ; simplExprF env' rhs cont } }}} We are in the unlifted case, and `exprOkForSpeculation` is false, so this case should not fire. But I think it is firing. Why? Can you check that this really is happening (e.g. there is a `CaseElim` on this case binder)? And figure out why? Can you make a small test case so I can see? Separately, it's true that `exprOkForSpeculation` is being conservative; see this comment in `CoreUtils.app_ok` {{{ | otherwise -> primop_ok op -- A bit conservative: we don't really need && all (expr_ok primop_ok) args -- to care about lazy arguments, but this is easy }}} Let me know if you need more help. Simon -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11444#comment:6 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11444: 8.0 rc1 panics in applyTypeToArgs -------------------------------------+------------------------------------- Reporter: osa1 | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1-rc1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by RyanGlScott): Two things: 1. osa1, I can't seem to reproduce the error you originally reported in this ticket on GHC 8.0.1, 8.0.2, or HEAD. 2. On GHC HEAD, I noticed that the package fails to build with `-dcore- lint` on: {{{ *** Core Lint errors : in result of Float out(FOS {Lam = Just 0, Consts = True, OverSatApps = False}) *** <no location info>: warning: In the expression: I# (reallyUnsafePtrEquality# @ a x_a1B9 y_a1Ba) This argument does not satisfy the let/app invariant: reallyUnsafePtrEquality# @ a x_a1B9 y_a1Ba *** Offending Program *** ... ptrEq [InlPrag=NOINLINE] :: forall a. a -> a -> Bool [LclIdX, Arity=2] ptrEq = \ (@ a_a1Dh) (x_a1B9 :: a) (y_a1Ba :: a) -> case x_a1B9 of x_X1Bi { __DEFAULT -> case y_a1Ba of y_X1Bk { __DEFAULT -> eqInt (I# (reallyUnsafePtrEquality# @ a x_a1B9 y_a1Ba)) lvl_s1QL } } }}} Possibly related to #13027? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11444#comment:8 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11444: 8.0 rc1 panics in applyTypeToArgs -------------------------------------+------------------------------------- Reporter: osa1 | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1-rc1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by dfeuer): Replying to [comment:6 simonpj]:

Can you make a small test case so I can see?

Based on your investigation, I've constructed a small test case: {{{#!hs {-# LANGUAGE MagicHash, BangPatterns #-} module PtrEqTest where import GHC.Exts (reallyUnsafePtrEquality#, Int (..)) ptrEq :: a -> a -> Bool ptrEq !x !y = I# (reallyUnsafePtrEquality# x y) == 1 }}} This produces the following error: {{{ *** Core Lint errors : in result of Float out(FOS {Lam = Just 0, Consts = True, OverSatApps = False}) *** <no location info>: warning: In the expression: I# (reallyUnsafePtrEquality# @ a x_a2Pv y_a2Pw) This argument does not satisfy the let/app invariant: reallyUnsafePtrEquality# @ a x_a2Pv y_a2Pw *** Offending Program *** lvl_s3Ub :: Int [LclId] lvl_s3Ub = I# 1# ptrEq :: forall a. a -> a -> Bool [LclIdX, Arity=2] ptrEq = \ (@ a_a3ID) (x_a2Pv :: a) (y_a2Pw :: a) -> case x_a2Pv of x_X2Pz { __DEFAULT -> case y_a2Pw of y_X2PB { __DEFAULT -> eqInt (I# (reallyUnsafePtrEquality# @ a x_a2Pv y_a2Pw)) lvl_s3Ub } } $trModule_s3U7 :: TrName [LclId] $trModule_s3U7 = TrNameS "main"# $trModule_s3U8 :: TrName [LclId] $trModule_s3U8 = TrNameS "PtrEqTest"# $trModule :: Module [LclIdX] $trModule = Module $trModule_s3U7 $trModule_s3U8 }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11444#comment:10 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11444: 8.0 rc1 panics in applyTypeToArgs -------------------------------------+------------------------------------- Reporter: osa1 | Owner: Type: bug | Status: new Priority: normal | Milestone: 8.2.1 Component: Compiler | Version: 8.0.1-rc1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #13027 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonpj): Aha! This is closely linked to #13027; read esp comment:23 on that ticket. In that comment I quote this Note from `CoreUtils` {{{ Note [dataToTag speculation] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Is this OK? f x = let v::Int# = dataToTag# x in ... We say "yes", even though 'x' may not be evaluated. Reasons * dataToTag#'s strictness means that its argument often will be evaluated, but FloatOut makes that temporarily untrue case x of y -> let v = dataToTag# y in ... --> case x of y -> let v = dataToTag# x in ... Note that we look at 'x' instead of 'y' (this is to improve floating in FloatOut). So Lint complains. Moreover, it really *might* improve floating to let the v-binding float out }}} The remark about `FloatOut` is ''exactly'' what is happening here. So if we follow the "alternative path" described in comment:23, that'll fix this ticket too. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11444#comment:12 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11444: 8.0 rc1 panics in applyTypeToArgs -------------------------------------+------------------------------------- Reporter: osa1 | Owner: Type: bug | Status: new Priority: normal | Milestone: 8.2.1 Component: Compiler | Version: 8.0.1-rc1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #13027 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by dfeuer): Sorry; that last comment was unclear. If we have {{{#!hs case x of x' { _ -> case y of y' { _ -> case reallyUnsafePtrEquality# x' y' of {....}}} }}} and we substitute as above, {{{#!hs case x of x' { _ -> case y of y' { _ -> case reallyUnsafePtrEquality# x y of {....}}} }}} then wouldn't floating out lead to this? {{{#!hs let wrong = reallyUnsafePtrEquality# x y in { case x of x' { _ -> case y of y' { _ -> case wrong of { ... }}}} }}} Now the pointer equality test could be performed ''before'' the reductions that would make it much more precise! -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11444#comment:14 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11444: 8.0 rc1 panics in applyTypeToArgs -------------------------------------+------------------------------------- Reporter: osa1 | Owner: Type: bug | Status: new Priority: normal | Milestone: 8.2.1 Component: Compiler | Version: 8.0.1-rc1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #13027 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by dfeuer): That looks like overkill, strictly speaking, but I could definitely believe that it doesn't matter. It looks like overkill because if we have {{{#!hs foo !x !y = case x of Con1 p -> let rup1 = reallyUnsafePtrEquality# x y in ... Con2 p -> let rup2 = reallyUnsafePtrEquality# x y in ... }}} then we can safely float out just a drop: {{{#!hs foo !x !y = let rup1 = reallyUnsafePtrEquality# x y rup2 = reallyUnsafePtrEquality# x y in case x of Con1 p -> ... Con2 p -> ... }}} and then CSE the duplication out. What I don't know is if such a thing will ever occur (or matter) in practice, or whether it would be a good idea even if it did. I can certainly make the change and add some notes. There are some interactions with some discussion in #13027. At present, anyway, `reallyUnsafePtrEquality#` is only considered "safe for speculation" when its arguments are known to be forced, which sounded really weird before, but isn't that precisely when it should be safe to float it out? OTOH, this ticket reveals another issue relating to polymorphic arguments, so maybe we should make the conservative change? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11444#comment:16 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11444: 8.0 rc1 panics in applyTypeToArgs -------------------------------------+------------------------------------- Reporter: osa1 | Owner: Type: bug | Status: new Priority: normal | Milestone: 8.2.1 Component: Compiler | Version: 8.0.1-rc1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #13027 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonpj): Let's move this discussion about primops to #13027, which has more relevant discussion. I'll add a test for comment:10, which is indeed fixed by the patch in #13027. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11444#comment:18 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11444: 8.0 rc1 panics in applyTypeToArgs -------------------------------------+------------------------------------- Reporter: osa1 | Owner: Type: bug | Status: closed Priority: normal | Milestone: 8.2.1 Component: Compiler | Version: 8.0.1-rc1 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | simplCore/should_compile/T11444 Blocked By: | Blocking: Related Tickets: #13027 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by simonpj): * status: new => closed * testcase: => simplCore/should_compile/T11444 * resolution: => fixed -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11444#comment:20 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler