import PprCore ( pprParendExpr, pprCoreExpr )
import CoreUnfold ( mkUnfolding, callSiteInline, CallCtxt(..) )
import CoreUtils
+import CoreArity ( exprArity )
import Rules ( lookupRule, getRules )
import BasicTypes ( isMarkedStrict )
import CostCentre ( currentCCS )
RecFlag(..), isNonRuleLoopBreaker )
import Maybes ( orElse )
import Data.List ( mapAccumL )
-import MonadUtils ( foldlM )
-import StaticFlags ( opt_PassCaseBndrToJoinPoints )
import Outputable
import FastString
\end{code}
; (env', rhs')
<- if not (doFloatFromRhs top_lvl is_rec False body2 body_env2)
then -- No floating, just wrap up!
- do { rhs' <- mkLam tvs' (wrapFloats body_env2 body2)
+ do { rhs' <- mkLam env tvs' (wrapFloats body_env2 body2)
; return (env, rhs') }
else if null tvs then -- Simple floating
else -- Do type-abstraction first
do { tick LetFloatFromLet
; (poly_binds, body3) <- abstractFloats tvs' body_env2 body2
- ; rhs' <- mkLam tvs' body3
+ ; rhs' <- mkLam env tvs' body3
; let env' = foldl (addPolyBind top_lvl) env poly_binds
; return (env', rhs') }
simplLam env bndrs body cont
= do { (env', bndrs') <- simplLamBndrs env bndrs
; body' <- simplExpr env' body
- ; new_lam <- mkLam bndrs' body'
+ ; new_lam <- mkLam env' bndrs' body'
; rebuild env' new_lam cont }
------------------
Just unfolding -- There is an inlining!
-> do { tick (UnfoldingDone var)
; (if dopt Opt_D_dump_inlinings dflags then
- pprTrace ("Inlining done" ++ showSDoc (ppr var)) (vcat [
+ pprTrace ("Inlining done: " ++ showSDoc (ppr var)) (vcat [
text "Before:" <+> ppr var <+> sep (map pprParendExpr args),
text "Inlined fn: " <+> nest 2 (ppr unfolding),
text "Cont: " <+> ppr call_cont])
LiberateCase gets to see it.)
-Historical note [no-case-of-case]
-~~~~~~~~~~~~~~~~~~~~~~
-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.
-
-Historical note [Suppressing the case binder-swap]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-There is another situation when it might make sense to suppress the
-case-expression binde-swap. If we have
-
- case x of w1 { DEFAULT -> case x of w2 { A -> e1; B -> e2 }
- ...other cases .... }
-
-We'll perform the binder-swap for the outer case, giving
-
- case x of w1 { DEFAULT -> case w1 of w2 { A -> e1; B -> e2 }
- ...other cases .... }
-
-But there is no point in doing it for the inner case, because w1 can't
-be inlined anyway. Furthermore, doing the case-swapping involves
-zapping w2's occurrence info (see paragraphs that follow), and that
-forces us to bind w2 when doing case merging. So we get
-
- case x of w1 { A -> let w2 = w1 in e1
- B -> let w2 = w1 in e2
- ...other cases .... }
-
-This is plain silly in the common case where w2 is dead.
-
-Even so, I can't see a good way to implement this idea. I tried
-not doing the binder-swap if the scrutinee was already evaluated
-but that failed big-time:
-
- data T = MkT !Int
-
- case v of w { MkT x ->
- case x of x1 { I# y1 ->
- case x of x2 { I# y2 -> ...
-
-Notice that because MkT is strict, x is marked "evaluated". But to
-eliminate the last case, we must either make sure that x (as well as
-x1) has unfolding MkT y1. THe straightforward thing to do is to do
-the binder-swap. So this whole note is a no-op.
\begin{code}
mkDupableAlt :: SimplEnv -> OutId -> (AltCon, [CoreBndr], CoreExpr)
-> SimplM (SimplEnv, (AltCon, [CoreBndr], CoreExpr))
-mkDupableAlt env case_bndr1 (con, bndrs1, rhs1)
- | exprIsDupable rhs1 -- Note [Small alternative rhs]
- = return (env, (con, bndrs1, rhs1))
+mkDupableAlt env case_bndr' (con, bndrs', rhs')
+ | exprIsDupable rhs' -- Note [Small alternative rhs]
+ = return (env, (con, bndrs', rhs'))
| otherwise
- = do { let abstract_over bndr
+ = do { let rhs_ty' = exprType rhs'
+ used_bndrs' = filter abstract_over (case_bndr' : bndrs')
+ abstract_over bndr
| isTyVar bndr = True -- Abstract over all type variables just in case
| otherwise = not (isDeadBinder bndr)
-- The deadness info on the new Ids is preserved by simplBinders
- inst_tys1 = tyConAppArgs (idType case_bndr1)
- con_app dc = mkConApp dc (map Type inst_tys1 ++ varsToCoreExprs bndrs1)
-
- (rhs2, final_bndrs) -- See Note [Passing the case binder to join points]
- | isDeadBinder case_bndr1
- = (rhs1, filter abstract_over bndrs1)
- | opt_PassCaseBndrToJoinPoints, not (null bndrs1)
- = (rhs1, (case_bndr1 : filter abstract_over bndrs1))
- | otherwise
- = case con of
- DataAlt dc -> (Let (NonRec case_bndr1 (con_app dc)) rhs1, bndrs1)
- LitAlt lit -> ASSERT( null bndrs1 ) (Let (NonRec case_bndr1 (Lit lit)) rhs1, [])
- DEFAULT -> ASSERT( null bndrs1 ) (rhs1, [case_bndr1])
-
- ; (final_bndrs1, final_args) -- Note [Join point abstraction]
- <- if (any isId final_bndrs)
- then return (final_bndrs, varsToCoreExprs final_bndrs)
+ ; (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
- ; return (rw_id : final_bndrs,
- Var realWorldPrimId : varsToCoreExprs final_bndrs) }
+ ; return ([rw_id], [Var realWorldPrimId]) }
- ; let rhs_ty1 = exprType rhs1
- ; join_bndr <- newId (fsLit "$j") (mkPiTypes final_bndrs1 rhs_ty1)
+ ; join_bndr <- newId (fsLit "$j") (mkPiTypes final_bndrs' rhs_ty')
-- Note [Funky mkPiTypes]
; let -- We make the lambdas into one-shot-lambdas. The
-- join point is sure to be applied at most once, and doing so
-- prevents the body of the join point being floated out by
-- the full laziness pass
- really_final_bndrs = map one_shot final_bndrs1
+ really_final_bndrs = map one_shot final_bndrs'
one_shot v | isId v = setOneShotLambda v
| otherwise = v
- join_rhs = mkLams really_final_bndrs rhs2
+ join_rhs = mkLams really_final_bndrs rhs'
join_call = mkApps (Var join_bndr) final_args
- ; env1 <- addPolyBind NotTopLevel env (NonRec join_bndr join_rhs)
- ; return (env1, (con, bndrs1, join_call)) }
+ ; return (addPolyBind NotTopLevel env (NonRec join_bndr join_rhs), (con, bndrs', join_call)) }
-- See Note [Duplicated env]
\end{code}
-Note [Passing the case binder to join points]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Suppose we have
- case e of cb { C1 -> r1[cb]; C2 x y z -> r2[cb,x] }
-and we want to make join points for the two alternatives,
-which mention the case binder 'cb'. Should we pass 'cb' to
-the join point, or reconstruct it? Here are the two alternatives
-for the C2 alternative:
-
- Plan A(pass cb): j2 cb x = r2[cb,x]
-
- Plan B(reconstruct cb): j2 x y z = let cb = C2 x y z in r2[cb,x]
-
-The advantge of Plan B is that we can "see" the definition of cb
-in r2, and that may be important when we inline stuff in r2. The
-disadvantage is that if this optimisation doesn't happen, we end up
-re-allocating C2, when it already exists. This does happen occasionally;
-an example is the function nofib/spectral/cichelli/Auxil.$whinsert.
-
-Plan B is always better if the constructor is nullary.
-
-In both cases we don't have liveness info for cb on a branch-by-branch
-basis, and it's possible that 'cb' is used in some branches but not
-others. Well, the absence analyser will find that out later, so it's
-not too bad.
-
-Sadly, at the time of writing, neither choice seems an unequivocal
-win. Here are nofib results, for adding -fpass-case-bndr-to-join-points
-(all others are zero effect):
-
- Program Size Allocs Runtime Elapsed
---------------------------------------------------------------------------------
- cichelli +0.0% -4.4% 0.13 0.13
- pic +0.0% -0.7% 0.01 0.04
- transform -0.0% +2.8% -0.4% -9.1%
- wave4main +0.0% +10.5% +3.1% +3.4%
---------------------------------------------------------------------------------
- Min -0.0% -4.4% -7.0% -31.9%
- Max +0.1% +10.5% +3.1% +15.0%
- Geometric Mean +0.0% +0.1% -1.7% -6.1%
-
-
Note [Duplicated env]
~~~~~~~~~~~~~~~~~~~~~
Some of the alternatives are simplified, but have not been turned into a join point