X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2FsimplCore%2FSimplify.lhs;h=39bf3d825cbade38fe1f041b13d65d17f7ad6eef;hb=4560a2d223f031462d4684b66e4e8f88ab8d75df;hp=27d2c541ddb7c3def2eade6c36dbb2b7212bcf8c;hpb=30c122df62ec75f9ed7f392f24c2925675bf1d06;p=ghc-hetmet.git diff --git a/compiler/simplCore/Simplify.lhs b/compiler/simplCore/Simplify.lhs index 27d2c54..39bf3d8 100644 --- a/compiler/simplCore/Simplify.lhs +++ b/compiler/simplCore/Simplify.lhs @@ -13,6 +13,7 @@ import SimplMonad import Type hiding ( substTy, extendTvSubst ) import SimplEnv import SimplUtils +import MkId ( rUNTIME_ERROR_ID ) import Id import Var import IdInfo @@ -20,11 +21,11 @@ import Coercion import FamInstEnv ( topNormaliseType ) import DataCon ( dataConRepStrictness, dataConUnivTyVars ) import CoreSyn -import NewDemand ( isStrictDmd ) +import NewDemand ( isStrictDmd, splitStrictSig ) import PprCore ( pprParendExpr, pprCoreExpr ) import CoreUnfold ( mkUnfolding, callSiteInline, CallCtxt(..) ) import CoreUtils -import Rules ( lookupRule ) +import Rules ( lookupRule, getRules ) import BasicTypes ( isMarkedStrict ) import CostCentre ( currentCCS ) import TysPrim ( realWorldStatePrimTy ) @@ -253,7 +254,7 @@ simplRecBind env0 top_lvl pairs0 ; env1 <- go (zapFloats env_with_info) triples ; return (env0 `addRecFloats` env1) } -- addFloats adds the floats from env1, - -- *and* updates env0 with the in-scope set from env1 + -- _and_ updates env0 with the in-scope set from env1 where add_rules :: SimplEnv -> (InBndr,InExpr) -> (SimplEnv, (InBndr, OutBndr, InExpr)) -- Add the (substituted) rules to the binder @@ -315,15 +316,21 @@ simplLazyBind :: SimplEnv simplLazyBind env top_lvl is_rec bndr bndr1 rhs rhs_se = do { let rhs_env = rhs_se `setInScope` env - (tvs, body) = collectTyBinders rhs + (tvs, body) = case collectTyBinders rhs of + (tvs, body) | not_lam body -> (tvs,body) + | otherwise -> ([], rhs) + not_lam (Lam _ _) = False + not_lam _ = True + -- Do not do the "abstract tyyvar" thing if there's + -- a lambda inside, becuase it defeats eta-reduction + -- f = /\a. \x. g a x + -- should eta-reduce + ; (body_env, tvs') <- simplBinders rhs_env tvs - -- See Note [Floating and type abstraction] - -- in SimplUtils + -- See Note [Floating and type abstraction] in SimplUtils - -- Simplify the RHS; note the mkRhsStop, which tells - -- the simplifier that this is the RHS of a let. - ; let rhs_cont = mkRhsStop (applyTys (idType bndr1) (mkTyVarTys tvs')) - ; (body_env1, body1) <- simplExprF body_env body rhs_cont + -- Simplify the RHS + ; (body_env1, body1) <- simplExprF body_env body mkBoringStop -- ANF-ise a constructor or PAP rhs ; (body_env2, body2) <- prepareRhs body_env1 body1 @@ -342,7 +349,8 @@ simplLazyBind env top_lvl is_rec bndr bndr1 rhs rhs_se do { tick LetFloatFromLet ; (poly_binds, body3) <- abstractFloats tvs' body_env2 body2 ; rhs' <- mkLam tvs' body3 - ; return (extendFloats env poly_binds, rhs') } + ; let env' = foldl (addPolyBind top_lvl) env poly_binds + ; return (env', rhs') } ; completeBind env' top_lvl bndr bndr1 rhs' } \end{code} @@ -358,20 +366,19 @@ simplNonRecX :: SimplEnv simplNonRecX env bndr new_rhs = do { (env', bndr') <- simplBinder env bndr - ; completeNonRecX env' NotTopLevel NonRecursive - (isStrictId bndr) bndr bndr' new_rhs } + ; completeNonRecX env' (isStrictId bndr) bndr bndr' new_rhs } completeNonRecX :: SimplEnv - -> TopLevelFlag -> RecFlag -> Bool + -> Bool -> InId -- Old binder -> OutId -- New binder -> OutExpr -- Simplified RHS -> SimplM SimplEnv -completeNonRecX env top_lvl is_rec is_strict old_bndr new_bndr new_rhs +completeNonRecX env is_strict old_bndr new_bndr new_rhs = do { (env1, rhs1) <- prepareRhs (zapFloats env) new_rhs ; (env2, rhs2) <- - if doFloatFromRhs top_lvl is_rec is_strict rhs1 env1 + if doFloatFromRhs NotTopLevel NonRecursive is_strict rhs1 env1 then do { tick LetFloatFromLet ; return (addFloats env env1, rhs1) } -- Add the floats to the main env else return (env, wrapFloats env1 rhs1) -- Wrap the floats around the RHS @@ -501,10 +508,20 @@ makeTrivial env expr | exprIsTrivial expr = return (env, expr) | otherwise -- See Note [Take care] below - = do { var <- newId FSLIT("a") (exprType expr) - ; env' <- completeNonRecX env NotTopLevel NonRecursive - False var var expr - ; return (env', substExpr env' (Var var)) } + = do { var <- newId (fsLit "a") (exprType expr) + ; env' <- completeNonRecX env False var var expr +-- pprTrace "makeTrivial" (vcat [ppr var <+> ppr (exprArity (substExpr env' (Var var))) +-- , ppr expr +-- , ppr (substExpr env' (Var var)) +-- , ppr (idArity (fromJust (lookupInScope (seInScope env') var))) ]) $ + ; return (env', substExpr env' (Var var)) } + -- The substitution is needed becase we're constructing a new binding + -- a = rhs + -- And if rhs is of form (rhs1 |> co), then we might get + -- a1 = rhs1 + -- a = a1 |> co + -- and now a's RHS is trivial and can be substituted out, and that + -- is what completeNonRecX will do \end{code} @@ -552,10 +569,67 @@ completeBind env top_lvl old_bndr new_bndr new_rhs -- Use the substitution to make quite, quite sure that the -- substitution will happen, since we are going to discard the binding - | otherwise - = let + | otherwise + = return (addNonRecWithUnf env new_bndr new_rhs unfolding wkr) + where + unfolding | omit_unfolding = NoUnfolding + | otherwise = mkUnfolding (isTopLevel top_lvl) new_rhs + old_info = idInfo old_bndr + occ_info = occInfo old_info + wkr = substWorker env (workerInfo old_info) + omit_unfolding = isNonRuleLoopBreaker occ_info + -- or not (activeInline env old_bndr) + -- Do *not* trim the unfolding in SimplGently, else + -- the specialiser can't see it! + +----------------- +addPolyBind :: TopLevelFlag -> SimplEnv -> OutBind -> SimplEnv +-- Add a new binding to the environment, complete with its unfolding +-- but *do not* do postInlineUnconditionally, because we have already +-- processed some of the scope of the binding +-- We still want the unfolding though. Consider +-- let +-- x = /\a. let y = ... in Just y +-- in body +-- Then we float the y-binding out (via abstractFloats and addPolyBind) +-- but 'x' may well then be inlined in 'body' in which case we'd like the +-- opportunity to inline 'y' too. + +addPolyBind top_lvl env (NonRec poly_id rhs) + = addNonRecWithUnf env poly_id rhs unfolding NoWorker + where + unfolding | not (activeInline env poly_id) = NoUnfolding + | otherwise = mkUnfolding (isTopLevel top_lvl) rhs + -- addNonRecWithInfo adds the new binding in the + -- proper way (ie complete with unfolding etc), + -- and extends the in-scope set + +addPolyBind _ env bind@(Rec _) = extendFloats env bind + -- Hack: letrecs are more awkward, so we extend "by steam" + -- without adding unfoldings etc. At worst this leads to + -- more simplifier iterations + +----------------- +addNonRecWithUnf :: SimplEnv + -> OutId -> OutExpr -- New binder and RHS + -> Unfolding -> WorkerInfo -- and unfolding + -> SimplEnv +-- Add suitable IdInfo to the Id, add the binding to the floats, and extend the in-scope set +addNonRecWithUnf env new_bndr rhs unfolding wkr + = ASSERT( isId new_bndr ) + WARN( new_arity < old_arity || new_arity < dmd_arity, + (ppr final_id <+> ppr old_arity <+> ppr new_arity <+> ppr dmd_arity) $$ ppr rhs ) + final_id `seq` -- This seq forces the Id, and hence its IdInfo, + -- and hence any inner substitutions + addNonRec env final_id rhs + -- The addNonRec adds it to the in-scope set too + where + dmd_arity = length $ fst $ splitStrictSig $ idNewStrictness new_bndr + old_arity = idArity new_bndr + -- Arity info - new_bndr_info = idInfo new_bndr `setArityInfo` exprArity new_rhs + new_arity = exprArity rhs + new_bndr_info = idInfo new_bndr `setArityInfo` new_arity -- Unfolding info -- Add the unfolding *only* for non-loop-breakers @@ -579,25 +653,12 @@ completeBind env top_lvl old_bndr new_bndr new_rhs -- (for example) be no longer strictly demanded. -- The solution here is a bit ad hoc... info_w_unf = new_bndr_info `setUnfoldingInfo` unfolding - `setWorkerInfo` worker_info + `setWorkerInfo` wkr - final_info | loop_breaker = new_bndr_info - | isEvaldUnfolding unfolding = zapDemandInfo info_w_unf `orElse` info_w_unf + final_info | isEvaldUnfolding unfolding = zapDemandInfo info_w_unf `orElse` info_w_unf | otherwise = info_w_unf - + final_id = new_bndr `setIdInfo` final_info - in - -- These seqs forces the Id, and hence its IdInfo, - -- and hence any inner substitutions - final_id `seq` - -- pprTrace "Binding" (ppr final_id <+> ppr unfolding) $ - return (addNonRec env final_id new_rhs) - where - unfolding = mkUnfolding (isTopLevel top_lvl) new_rhs - worker_info = substWorker env (workerInfo old_info) - loop_breaker = isNonRuleLoopBreaker occ_info - old_info = idInfo old_bndr - occ_info = occInfo old_info \end{code} @@ -648,14 +709,7 @@ might do the same again. \begin{code} simplExpr :: SimplEnv -> CoreExpr -> SimplM CoreExpr -simplExpr env expr = simplExprC env expr (mkBoringStop expr_ty') - where - expr_ty' = substTy env (exprType expr) - -- The type in the Stop continuation, expr_ty', is usually not used - -- It's only needed when discarding continuations after finding - -- a function that returns bottom. - -- Hence the lazy substitution - +simplExpr env expr = simplExprC env expr mkBoringStop simplExprC :: SimplEnv -> CoreExpr -> SimplCont -> SimplM CoreExpr -- Simplify an expression, given a continuation @@ -707,7 +761,7 @@ simplExprF' env (Type ty) cont do { ty' <- simplType env ty ; rebuild env (Type ty') cont } -simplExprF' env (Case scrut bndr case_ty alts) cont +simplExprF' env (Case scrut bndr _ alts) cont | not (switchIsOn (getSwitchChecker env) NoCaseOfCase) = -- Simplify the scrutinee with a Select continuation simplExprF env scrut (Select NoDup bndr alts env cont) @@ -718,8 +772,7 @@ simplExprF' env (Case scrut bndr case_ty alts) cont do { case_expr' <- simplExprC env scrut case_cont ; rebuild env case_expr' cont } where - case_cont = Select NoDup bndr alts env (mkBoringStop case_ty') - case_ty' = substTy env case_ty -- c.f. defn of simplExpr + case_cont = Select NoDup bndr alts env mkBoringStop simplExprF' env (Let (Rec pairs) body) cont = do { env' <- simplRecBndrs env (map fst pairs) @@ -759,7 +812,7 @@ rebuild env expr cont0 Stop {} -> return (env, expr) CoerceIt co cont -> rebuild env (mkCoerce co expr) cont Select _ bndr alts se cont -> rebuildCase (se `setFloats` env) expr bndr alts cont - StrictArg fun ty _ info cont -> rebuildCall env (fun `App` expr) (funResultTy ty) info cont + StrictArg fun _ info cont -> rebuildCall env (fun `App` expr) info cont StrictBind b bs body se cont -> do { env' <- simplNonRecX (se `setFloats` env) b expr ; simplLam env' bs body cont } ApplyTo _ arg se cont -> do { arg' <- simplExpr (se `setInScope` env) arg @@ -787,10 +840,10 @@ simplCast env body co0 cont0 add_coerce co1 (s1, _k2) (CoerceIt co2 cont) | (_l1, t1) <- coercionKind co2 - -- coerce T1 S1 (coerce S1 K1 e) + -- e |> (g1 :: S1~L) |> (g2 :: L~T1) -- ==> - -- e, if T1=K1 - -- coerce T1 K1 e, otherwise + -- e, if T1=T2 + -- e |> (g1 . g2 :: T1~T2) otherwise -- -- For example, in the initial form of a worker -- we may find (coerce T (coerce S (\x.e))) y @@ -800,25 +853,25 @@ simplCast env body co0 cont0 | otherwise = CoerceIt (mkTransCoercion co1 co2) cont add_coerce co (s1s2, _t1t2) (ApplyTo dup (Type arg_ty) arg_se cont) - -- (f `cast` g) ty ---> (f ty) `cast` (g @ ty) + -- (f |> g) ty ---> (f ty) |> (g @ ty) -- This implements the PushT rule from the paper | Just (tyvar,_) <- splitForAllTy_maybe s1s2 , not (isCoVar tyvar) = ApplyTo dup (Type ty') (zapSubstEnv env) (addCoerce (mkInstCoercion co ty') cont) where - ty' = substTy arg_se arg_ty + ty' = substTy (arg_se `setInScope` env) arg_ty -- ToDo: the PushC rule is not implemented at all add_coerce co (s1s2, _t1t2) (ApplyTo dup arg arg_se cont) | not (isTypeArg arg) -- This implements the Push rule from the paper , isFunTy s1s2 -- t1t2 must be a function type, becuase it's applied - -- co : s1s2 :=: t1t2 - -- (coerce (T1->T2) (S1->S2) F) E + -- (e |> (g :: s1s2 ~ t1->t2)) f -- ===> - -- coerce T2 S2 (F (coerce S1 T1 E)) + -- (e (f |> (arg g :: t1~s1)) + -- |> (res g :: s2->t2) -- - -- t1t2 must be a function type, T1->T2, because it's applied + -- t1t2 must be a function type, t1->t2, because it's applied -- to something but s1s2 might conceivably not be -- -- When we build the ApplyTo we can't mix the out-types @@ -829,12 +882,12 @@ simplCast env body co0 cont0 -- Example of use: Trac #995 = ApplyTo dup new_arg (zapSubstEnv env) (addCoerce co2 cont) where - -- we split coercion t1->t2 :=: s1->s2 into t1 :=: s1 and - -- t2 :=: s2 with left and right on the curried form: - -- (->) t1 t2 :=: (->) s1 s2 + -- we split coercion t1->t2 ~ s1->s2 into t1 ~ s1 and + -- t2 ~ s2 with left and right on the curried form: + -- (->) t1 t2 ~ (->) s1 s2 [co1, co2] = decomposeCo 2 co new_arg = mkCoerce (mkSymCoercion co1) arg' - arg' = substExpr arg_se arg + arg' = substExpr (arg_se `setInScope` env) arg add_coerce co _ cont = CoerceIt co cont \end{code} @@ -852,14 +905,7 @@ simplLam :: SimplEnv -> [InId] -> InExpr -> SimplCont simplLam env [] body cont = simplExprF env body cont - -- Type-beta reduction -simplLam env (bndr:bndrs) body (ApplyTo _ (Type ty_arg) arg_se cont) - = ASSERT( isTyVar bndr ) - do { tick (BetaReduction bndr) - ; ty_arg' <- simplType (arg_se `setInScope` env) ty_arg - ; simplLam (extendTvSubst env bndr ty_arg') bndrs body cont } - - -- Ordinary beta reduction + -- Beta reduction simplLam env (bndr:bndrs) body (ApplyTo _ arg arg_se cont) = do { tick (BetaReduction bndr) ; simplNonRecE env bndr (arg, arg_se) (bndrs, body) cont } @@ -875,7 +921,7 @@ simplLam env bndrs body cont simplNonRecE :: SimplEnv -> InId -- The binder -> (InExpr, SimplEnv) -- Rhs of binding (or arg of lambda) - -> ([InId], InExpr) -- Body of the let/lambda + -> ([InBndr], InExpr) -- Body of the let/lambda -- \xs.e -> SimplCont -> SimplM (SimplEnv, OutExpr) @@ -892,6 +938,13 @@ simplNonRecE :: SimplEnv -- Why? Because of the binder-occ-info-zapping done before -- the call to simplLam in simplExprF (Lam ...) + -- First deal with type applications and type lets + -- (/\a. e) (Type ty) and (let a = Type ty in e) +simplNonRecE env bndr (Type ty_arg, rhs_se) (bndrs, body) cont + = ASSERT( isTyVar bndr ) + do { ty_arg' <- simplType (rhs_se `setInScope` env) ty_arg + ; simplLam (extendTvSubst env bndr ty_arg') bndrs body cont } + simplNonRecE env bndr (rhs, rhs_se) (bndrs, body) cont | preInlineUnconditionally env NotTopLevel bndr rhs = do { tick (PreInlineUnconditionally bndr) @@ -902,7 +955,8 @@ simplNonRecE env bndr (rhs, rhs_se) (bndrs, body) cont (StrictBind bndr bndrs body env cont) } | otherwise - = do { (env1, bndr1) <- simplNonRecBndr env bndr + = ASSERT( not (isTyVar bndr) ) + do { (env1, bndr1) <- simplNonRecBndr env bndr ; let (env2, bndr2) = addBndrRules env1 bndr bndr1 ; env3 <- simplLazyBind env2 NotTopLevel NonRecursive bndr bndr2 rhs rhs_se ; simplLam env3 bndrs body cont } @@ -1001,12 +1055,13 @@ completeCall env var cont -- is recursive, and hence a loop breaker: -- foldr k z (build g) = g k z -- So it's up to the programmer: rules can cause divergence - ; rules <- getRules + ; rule_base <- getSimplRules ; let in_scope = getInScope env + rules = getRules rule_base var maybe_rule = case activeRule dflags env of Nothing -> Nothing -- No rules apply Just act_fn -> lookupRule act_fn in_scope - rules var args + var args rules ; case maybe_rule of { Just (rule, rule_rhs) -> do tick (RuleFired (ru_name rule)) @@ -1047,16 +1102,16 @@ completeCall env var cont ------------- No inlining! ---------------- -- Next, look for rules or specialisations that match -- - rebuildCall env (Var var) (idType var) + rebuildCall env (Var var) (mkArgInfo var n_val_args call_cont) cont }}}} rebuildCall :: SimplEnv - -> OutExpr -> OutType -- Function and its type + -> OutExpr -- Function -> ArgInfo -> SimplCont -> SimplM (SimplEnv, OutExpr) -rebuildCall env fun fun_ty (ArgInfo { ai_strs = [] }) cont +rebuildCall env fun (ArgInfo { ai_strs = [] }) cont -- When we run out of strictness args, it means -- that the call is definitely bottom; see SimplUtils.mkArgInfo -- Then we want to discard the entire strict continuation. E.g. @@ -1070,22 +1125,23 @@ rebuildCall env fun fun_ty (ArgInfo { ai_strs = [] }) cont | not (contIsTrivial cont) -- Only do this if there is a non-trivial = return (env, mk_coerce fun) -- contination to discard, else we do it where -- again and again! - cont_ty = contResultType cont + fun_ty = exprType fun + cont_ty = contResultType env fun_ty cont co = mkUnsafeCoercion fun_ty cont_ty mk_coerce expr | cont_ty `coreEqType` fun_ty = expr | otherwise = mkCoerce co expr -rebuildCall env fun fun_ty info (ApplyTo _ (Type arg_ty) se cont) +rebuildCall env fun info (ApplyTo _ (Type arg_ty) se cont) = do { ty' <- simplType (se `setInScope` env) arg_ty - ; rebuildCall env (fun `App` Type ty') (applyTy fun_ty ty') info cont } + ; rebuildCall env (fun `App` Type ty') info cont } -rebuildCall env fun fun_ty +rebuildCall env fun (ArgInfo { ai_rules = has_rules, ai_strs = str:strs, ai_discs = disc:discs }) (ApplyTo _ arg arg_se cont) - | str || isStrictType arg_ty -- Strict argument + | str -- Strict argument = -- pprTrace "Strict Arg" (ppr arg $$ ppr (seIdSubst env) $$ ppr (seInScope env)) $ simplExprF (arg_se `setFloats` env) arg - (StrictArg fun fun_ty cci arg_info' cont) + (StrictArg fun cci arg_info' cont) -- Note [Shadowing] | otherwise -- Lazy argument @@ -1094,15 +1150,14 @@ rebuildCall env fun fun_ty -- have to be very careful about bogus strictness through -- floating a demanded let. = do { arg' <- simplExprC (arg_se `setInScope` env) arg - (mkLazyArgStop arg_ty cci) - ; rebuildCall env (fun `App` arg') res_ty arg_info' cont } + (mkLazyArgStop cci) + ; rebuildCall env (fun `App` arg') arg_info' cont } where - (arg_ty, res_ty) = splitFunTy fun_ty arg_info' = ArgInfo { ai_rules = has_rules, ai_strs = strs, ai_discs = discs } cci | has_rules || disc > 0 = ArgCtxt has_rules disc -- Be keener here | otherwise = BoringCtxt -- Nothing interesting -rebuildCall env fun _ _ cont +rebuildCall env fun _ cont = rebuild env fun cont \end{code} @@ -1220,12 +1275,25 @@ rebuildCase env scrut case_bndr alts cont -- Simplify the alternatives ; (scrut', case_bndr', alts') <- simplAlts env' scrut case_bndr alts dup_cont - ; let res_ty' = contResultType dup_cont - ; case_expr <- mkCase scrut' case_bndr' res_ty' alts' - -- Notice that rebuildDone returns the in-scope set from env', not alt_env - -- The case binder *not* scope over the whole returned case-expression - ; rebuild env' case_expr nodup_cont } + -- Check for empty alternatives + ; if null alts' then + -- This isn't strictly an error, although it is unusual. + -- It's possible that the simplifer might "see" that + -- an inner case has no accessible alternatives before + -- it "sees" that the entire branch of an outer case is + -- inaccessible. So we simply put an error case here instead. + pprTrace "mkCase: null alts" (ppr case_bndr <+> ppr scrut) $ + let res_ty' = contResultType env' (substTy env' (coreAltsType alts)) dup_cont + lit = mkStringLit "Impossible alternative" + in return (env', mkApps (Var rUNTIME_ERROR_ID) [Type res_ty', lit]) + + else do + { case_expr <- mkCase scrut' case_bndr' alts' + + -- Notice that rebuild gets the in-scope set from env, not alt_env + -- The case binder *not* scope over the whole returned case-expression + ; rebuild env' case_expr nodup_cont } } \end{code} simplCaseBinder checks whether the scrutinee is a variable, v. If so, @@ -1235,15 +1303,18 @@ inlined. Note [no-case-of-case] ~~~~~~~~~~~~~~~~~~~~~~ -There is a time we *don't* want to do that, namely when --fno-case-of-case is on. This happens in the first simplifier pass, -and enhances full laziness. Here's the bad case: - f = \ y -> ...(case x of I# v -> ...(case x of ...) ... ) -If we eliminate the inner case, we trap it inside the I# v -> arm, -which might prevent some full laziness happening. I've seen this -in action in spectral/cichelli/Prog.hs: - [(m,n) | m <- [1..max], n <- [1..max]] -Hence the check for NoCaseOfCase. +We *used* to suppress the binder-swap in case expressoins when +-fno-case-of-case is on. Old remarks: + "This happens in the first simplifier pass, + and enhances full laziness. Here's the bad case: + f = \ y -> ...(case x of I# v -> ...(case x of ...) ... ) + If we eliminate the inner case, we trap it inside the I# v -> arm, + which might prevent some full laziness happening. I've seen this + in action in spectral/cichelli/Prog.hs: + [(m,n) | m <- [1..max], n <- [1..max]] + Hence the check for NoCaseOfCase." +However, now the full-laziness pass itself reverses the binder-swap, so this +check is no longer necessary. Note [Suppressing the case binder-swap] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -1455,7 +1526,7 @@ simplCaseBinder env0 scrut0 case_bndr0 alts improve_seq fam_envs env scrut case_bndr case_bndr1 [(DEFAULT,_,_)] | Just (co, ty2) <- topNormaliseType fam_envs (idType case_bndr1) - = do { case_bndr2 <- newId FSLIT("nt") ty2 + = do { case_bndr2 <- newId (fsLit "nt") ty2 ; let rhs = DoneEx (Var case_bndr2 `Cast` mkSymCoercion co) env2 = extendIdSubst env case_bndr rhs ; return (env2, scrut `Cast` co, case_bndr2) } @@ -1465,9 +1536,9 @@ simplCaseBinder env0 scrut0 case_bndr0 alts improve_case_bndr env scrut case_bndr - | switchIsOn (getSwitchChecker env) NoCaseOfCase - -- See Note [no-case-of-case] - = (env, case_bndr) + -- See Note [no-case-of-case] + -- | switchIsOn (getSwitchChecker env) NoCaseOfCase + -- = (env, case_bndr) | otherwise -- Failed try; see Note [Suppressing the case binder-swap] -- not (isEvaldUnfolding (idUnfolding v)) @@ -1537,7 +1608,8 @@ of the inner case y, which give us nowhere to go! simplAlts :: SimplEnv -> OutExpr -> InId -- Case binder - -> [InAlt] -> SimplCont + -> [InAlt] -- Non-empty + -> SimplCont -> SimplM (OutExpr, OutId, [OutAlt]) -- Includes the continuation -- Like simplExpr, this just returns the simplified alternatives; -- it not return an environment @@ -1653,7 +1725,8 @@ and then All this should happen in one sweep. \begin{code} -knownCon :: SimplEnv -> OutExpr -> AltCon -> [OutExpr] +knownCon :: SimplEnv -> OutExpr -> AltCon + -> [OutExpr] -- Args *including* the universal args -> InId -> [InAlt] -> SimplCont -> SimplM (SimplEnv, OutExpr) @@ -1739,7 +1812,7 @@ prepareCaseCont :: SimplEnv -- continunation) -- No need to make it duplicatable if there's only one alternative -prepareCaseCont env [_] cont = return (env, cont, mkBoringStop (contResultType cont)) +prepareCaseCont env [_] cont = return (env, cont, mkBoringStop) prepareCaseCont env _ cont = mkDupableCont env cont \end{code} @@ -1749,7 +1822,7 @@ mkDupableCont :: SimplEnv -> SimplCont mkDupableCont env cont | contIsDupable cont - = return (env, cont, mkBoringStop (contResultType cont)) + = return (env, cont, mkBoringStop) mkDupableCont _ (Stop {}) = panic "mkDupableCont" -- Handled by previous eqn @@ -1757,12 +1830,12 @@ mkDupableCont env (CoerceIt ty cont) = do { (env', dup, nodup) <- mkDupableCont env cont ; return (env', CoerceIt ty dup, nodup) } -mkDupableCont env cont@(StrictBind bndr _ _ se _) - = return (env, mkBoringStop (substTy se (idType bndr)), cont) +mkDupableCont env cont@(StrictBind {}) + = return (env, mkBoringStop, cont) -- See Note [Duplicating strict continuations] -mkDupableCont env cont@(StrictArg _ fun_ty _ _ _) - = return (env, mkBoringStop (funArgTy fun_ty), cont) +mkDupableCont env cont@(StrictArg {}) + = return (env, mkBoringStop, cont) -- See Note [Duplicating strict continuations] mkDupableCont env (ApplyTo _ arg se cont) @@ -1773,17 +1846,17 @@ mkDupableCont env (ApplyTo _ arg se cont) do { (env', dup_cont, nodup_cont) <- mkDupableCont env cont ; arg' <- simplExpr (se `setInScope` env') arg ; (env'', arg'') <- makeTrivial env' arg' - ; let app_cont = ApplyTo OkToDup arg'' (zapSubstEnv env') dup_cont + ; let app_cont = ApplyTo OkToDup arg'' (zapSubstEnv env'') dup_cont ; return (env'', app_cont, nodup_cont) } -mkDupableCont env cont@(Select _ case_bndr [(_, bs, _rhs)] se _case_cont) +mkDupableCont env cont@(Select _ case_bndr [(_, bs, _rhs)] _ _) -- See Note [Single-alternative case] -- | not (exprIsDupable rhs && contIsDupable case_cont) -- | not (isDeadBinder case_bndr) - | all isDeadBinder bs -- InIds - = return (env, mkBoringStop scrut_ty, cont) - where - scrut_ty = substTy se (idType case_bndr) + | all isDeadBinder bs -- InIds + && not (isUnLiftedType (idType case_bndr)) + -- Note [Single-alternative-unlifted] + = return (env, mkBoringStop, cont) mkDupableCont env (Select _ case_bndr alts se cont) = -- e.g. (case [...hole...] of { pi -> ei }) @@ -1813,8 +1886,7 @@ mkDupableCont env (Select _ case_bndr alts se cont) ; (env'', alts'') <- mkDupableAlts env' case_bndr' alts' ; return (env'', -- Note [Duplicated env] - Select OkToDup case_bndr' alts'' (zapSubstEnv env'') - (mkBoringStop (contResultType dup_cont)), + Select OkToDup case_bndr' alts'' (zapSubstEnv env'') mkBoringStop, nodup_cont) } @@ -1847,10 +1919,10 @@ mkDupableAlt env case_bndr' (con, bndrs', rhs') ; (final_bndrs', final_args) -- Note [Join point abstraction] <- if (any isId used_bndrs') then return (used_bndrs', varsToCoreExprs used_bndrs') - else do { rw_id <- newId FSLIT("w") realWorldStatePrimTy + else do { rw_id <- newId (fsLit "w") realWorldStatePrimTy ; return ([rw_id], [Var realWorldPrimId]) } - ; join_bndr <- newId FSLIT("$j") (mkPiTypes final_bndrs' rhs_ty') + ; join_bndr <- newId (fsLit "$j") (mkPiTypes final_bndrs' rhs_ty') -- Note [Funky mkPiTypes] ; let -- We make the lambdas into one-shot-lambdas. The @@ -1863,7 +1935,7 @@ mkDupableAlt env case_bndr' (con, bndrs', rhs') join_rhs = mkLams really_final_bndrs rhs' join_call = mkApps (Var join_bndr) final_args - ; return (addNonRec env join_bndr join_rhs, (con, bndrs', join_call)) } + ; return (addPolyBind NotTopLevel env (NonRec join_bndr join_rhs), (con, bndrs', join_call)) } -- See Note [Duplicated env] \end{code} @@ -2032,3 +2104,37 @@ Other choices: When x is inlined into its full context, we find that it was a bad idea to have pushed the outer case inside the (...) case. +Note [Single-alternative-unlifted] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Here's another single-alternative where we really want to do case-of-case: + +data Mk1 = Mk1 Int# +data Mk1 = Mk2 Int# + +M1.f = + \r [x_s74 y_s6X] + case + case y_s6X of tpl_s7m { + M1.Mk1 ipv_s70 -> ipv_s70; + M1.Mk2 ipv_s72 -> ipv_s72; + } + of + wild_s7c + { __DEFAULT -> + case + case x_s74 of tpl_s7n { + M1.Mk1 ipv_s77 -> ipv_s77; + M1.Mk2 ipv_s79 -> ipv_s79; + } + of + wild1_s7b + { __DEFAULT -> ==# [wild1_s7b wild_s7c]; + }; + }; + +So the outer case is doing *nothing at all*, other than serving as a +join-point. In this case we really want to do case-of-case and decide +whether to use a real join point or just duplicate the continuation. + +Hence: check whether the case binder's type is unlifted, because then +the outer case is *not* a seq.