#include "HsVersions.h"
-import DynFlags ( DynFlags, DynFlag(..) )
import CoreSyn
import CoreUtils ( exprIsHNF, exprIsDupable )
-import CoreLint ( showPass, endPass )
import CoreFVs ( CoreExprWithFVs, freeVars, freeVarsOf, idRuleVars )
import Id ( isOneShotBndr, idType )
import Var
actually float any bindings downwards from the top-level.
\begin{code}
-floatInwards :: DynFlags -> [CoreBind] -> IO [CoreBind]
-
-floatInwards dflags binds
- = do {
- showPass dflags "Float inwards";
- let { binds' = map fi_top_bind binds };
- endPass dflags "Float inwards" Opt_D_verbose_core2core binds'
- {- no specific flag for dumping float-in -}
- }
-
+floatInwards :: [CoreBind] -> [CoreBind]
+floatInwards = map fi_top_bind
where
fi_top_bind (NonRec binder rhs)
= NonRec binder (fiExpr [] (freeVars rhs))
[drop_here, fun_drop, arg_drop] = sepBindsByDropPoint False [freeVarsOf fun, freeVarsOf arg] to_drop
\end{code}
-We are careful about lambdas:
-
+Note [Floating in past a lambda group]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* We must be careful about floating inside inside a value lambda.
That risks losing laziness.
The float-out pass might rescue us, but then again it might not.
This is bad as now f is an updatable closure (update PAP)
and has arity 0.
+* Hack alert! We only float in through one-shot lambdas,
+ not (as you might guess) through lone big lambdas.
+ Reason: we float *out* past big lambdas (see the test in the Lam
+ case of FloatOut.floatExpr) and we don't want to float straight
+ back in again.
+
+ It *is* important to float into one-shot lambdas, however;
+ see the remarks with noFloatIntoRhs.
+
So we treat lambda in groups, using the following rule:
- Float inside a group of lambdas only if
- they are all either type lambdas or one-shot lambdas.
+ Float in if (a) there is at least one Id,
+ and (b) there are no non-one-shot Ids
+
+ Otherwise drop all the bindings outside the group.
- Otherwise drop all the bindings outside the group.
+This is what the 'go' function in the AnnLam case is doing.
+
+Urk! if all are tyvars, and we don't float in, we may miss an
+ opportunity to float inside a nested case branch
\begin{code}
- -- Hack alert! We only float in through one-shot lambdas,
- -- not (as you might guess) through big lambdas.
- -- Reason: we float *out* past big lambdas (see the test in the Lam
- -- case of FloatOut.floatExpr) and we don't want to float straight
- -- back in again.
- --
- -- It *is* important to float into one-shot lambdas, however;
- -- see the remarks with noFloatIntoRhs.
fiExpr to_drop lam@(_, AnnLam _ _)
- | all is_one_shot bndrs -- Float in
+ | go False bndrs -- Float in
= mkLams bndrs (fiExpr to_drop body)
| otherwise -- Dump it all here
where
(bndrs, body) = collectAnnBndrs lam
+
+ go seen_one_shot_id [] = seen_one_shot_id
+ go seen_one_shot_id (b:bs)
+ | isTyVar b = go seen_one_shot_id bs
+ | isOneShotBndr b = go True bs
+ | otherwise = False -- Give up at a non-one-shot Id
\end{code}
We don't float lets inwards past an SCC.
-- Push rhs_binds into the right hand side of the binding
rhs' = fiExpr rhs_binds rhs
- rhs_fvs' = rhs_fvs `unionVarSet` floatedBindsFVs rhs_binds
+ rhs_fvs' = rhs_fvs `unionVarSet` floatedBindsFVs rhs_binds `unionVarSet` rule_fvs
+ -- Don't forget the rule_fvs; the binding mentions them!
fiExpr to_drop (_,AnnLet (AnnRec bindings) body)
= fiExpr new_to_drop body
where
- rhss = map snd bindings
-
+ (ids, rhss) = unzip bindings
rhss_fvs = map freeVarsOf rhss
body_fvs = freeVarsOf body
-- See Note [extra_fvs (1,2)]
- extra_fvs = foldr (unionVarSet . get_extras) emptyVarSet bindings
- get_extras (id, (rhs_fvs, rhs))
- | noFloatIntoRhs rhs = idRuleVars id `unionVarSet` rhs_fvs
- | otherwise = idRuleVars id
+ rule_fvs = foldr (unionVarSet . idRuleVars) emptyVarSet ids
+ extra_fvs = rule_fvs `unionVarSet`
+ unionVarSets [ fvs | (fvs, rhs) <- rhss
+ , noFloatIntoRhs rhs ]
(shared_binds:extra_binds:body_binds:rhss_binds)
= sepBindsByDropPoint False (extra_fvs:body_fvs:rhss_fvs) to_drop
extra_binds ++ -- Note [extra_fvs (1,2)]
shared_binds -- Used in more than one place
- rhs_fvs' = unionVarSet (unionVarSets rhss_fvs)
- (unionVarSets (map floatedBindsFVs rhss_binds))
+ rhs_fvs' = unionVarSets rhss_fvs `unionVarSet`
+ unionVarSets (map floatedBindsFVs rhss_binds) `unionVarSet`
+ rule_fvs -- Don't forget the rule variables!
-- Push rhs_binds into the right hand side of the binding
fi_bind :: [FloatingBinds] -- one per "drop pt" conjured w/ fvs_of_rhss