%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1995
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\section[FloatOut]{Float bindings outwards (towards the top level)}
``Long-distance'' floating of bindings towards the top level.
\begin{code}
-#include "HsVersions.h"
-
module FloatOut ( floatOutwards ) where
-IMPORT_Trace -- ToDo: rm (debugging)
-import Pretty
-import Outputable
+#include "HsVersions.h"
-import PlainCore
+import CoreSyn
+import CoreUtils ( mkSCC, exprIsHNF, exprIsTrivial )
-import BasicLit ( BasicLit(..), PrimKind )
-import CmdLineOpts ( GlobalSwitch(..) )
+import DynFlags ( DynFlags, DynFlag(..), FloatOutSwitches(..) )
+import ErrUtils ( dumpIfSet_dyn )
import CostCentre ( dupifyCC, CostCentre )
-import SetLevels
-import Id ( eqId )
-import IdEnv
-import Maybes ( Maybe(..), catMaybes, maybeToBool )
-import SplitUniq
-import Util
+import Id ( Id, idType )
+import Type ( isUnLiftedType )
+import CoreLint ( showPass, endPass )
+import SetLevels ( Level(..), LevelledExpr, LevelledBind,
+ setLevels, ltMajLvl, ltLvl, isTopLvl )
+import UniqSupply ( UniqSupply )
+import List ( partition )
+import Outputable
+import Util ( notNull )
\end{code}
+ -----------------
+ Overall game plan
+ -----------------
+
+The Big Main Idea is:
+
+ To float out sub-expressions that can thereby get outside
+ a non-one-shot value lambda, and hence may be shared.
+
+
+To achieve this we may need to do two thing:
+
+ a) Let-bind the sub-expression:
+
+ f (g x) ==> let lvl = f (g x) in lvl
+
+ Now we can float the binding for 'lvl'.
+
+ b) More than that, we may need to abstract wrt a type variable
+
+ \x -> ... /\a -> let v = ...a... in ....
+
+ Here the binding for v mentions 'a' but not 'x'. So we
+ abstract wrt 'a', to give this binding for 'v':
+
+ vp = /\a -> ...a...
+ v = vp a
+
+ Now the binding for vp can float out unimpeded.
+ I can't remember why this case seemed important enough to
+ deal with, but I certainly found cases where important floats
+ didn't happen if we did not abstract wrt tyvars.
+
+With this in mind we can also achieve another goal: lambda lifting.
+We can make an arbitrary (function) binding float to top level by
+abstracting wrt *all* local variables, not just type variables, leaving
+a binding that can be floated right to top level. Whether or not this
+happens is controlled by a flag.
+
+
Random comments
~~~~~~~~~~~~~~~
-At the moment we never float a binding out to between two adjacent lambdas. For
-example:
+
+At the moment we never float a binding out to between two adjacent
+lambdas. For example:
+
@
\x y -> let t = x+x in ...
===>
\x -> let t = x+x in \y -> ...
@
-Reason: this is less efficient in the case where the original lambda is
-never partially applied.
+Reason: this is less efficient in the case where the original lambda
+is never partially applied.
But there's a case I've seen where this might not be true. Consider:
@
@
\deq x ys -> let eq = eqFromEqDict deq in ...
@
-which might usefully be separated to
+vwhich might usefully be separated to
@
\deq -> let eq = eqFromEqDict deq in \xy -> ...
@
Well, maybe. We don't do this at the moment.
-
\begin{code}
-type LevelledExpr = CoreExpr (Id, Level) Id
-type LevelledBind = CoreBinding (Id, Level) Id
-type FloatingBind = (Level, Floater)
-type FloatingBinds = [FloatingBind]
-
-data Floater = LetFloater PlainCoreBinding
-
- | CaseFloater (PlainCoreExpr -> PlainCoreExpr)
- -- Give me a right-hand side of the
- -- (usually single) alternative, and
- -- I'll build the case
+type FloatBind = (Level, CoreBind) -- INVARIANT: a FloatBind is always lifted
+type FloatBinds = [FloatBind]
\end{code}
%************************************************************************
%************************************************************************
\begin{code}
-floatOutwards :: (GlobalSwitch -> Bool) -- access to all global cmd-line opts
- -> SplitUniqSupply
- -> PlainCoreProgram
- -> PlainCoreProgram
-
-floatOutwards sw_chker us pgm
- = case (setLevels pgm sw_chker us) of { annotated_w_levels ->
-
- case unzip3 (map (floatTopBind sw_chker) annotated_w_levels)
- of { (fcs, lcs, final_toplev_binds_s) ->
-
- (if sw_chker D_verbose_core2core
- then pprTrace "Levels added:\n" (ppr PprDebug annotated_w_levels)
- else id
- )
- ( if sw_chker D_simplifier_stats
- then pprTrace "FloatOut stats: " (ppBesides [
- ppInt (sum fcs), ppStr " Lets floated out of ",
- ppInt (sum lcs), ppStr " Lambdas"])
- else id
- )
- concat final_toplev_binds_s
- }}
+floatOutwards :: FloatOutSwitches
+ -> DynFlags
+ -> UniqSupply
+ -> [CoreBind] -> IO [CoreBind]
-floatTopBind sw bind@(CoNonRec _ _)
- = case (floatBind sw nullIdEnv tOP_LEVEL bind) of { (fc,lc, floats, bind', _) ->
- (fc,lc, floatsToBinds floats ++ [bind'])
- }
+floatOutwards float_sws dflags us pgm
+ = do {
+ showPass dflags float_msg ;
+
+ let { annotated_w_levels = setLevels float_sws pgm us ;
+ (fss, binds_s') = unzip (map floatTopBind annotated_w_levels)
+ } ;
+
+ dumpIfSet_dyn dflags Opt_D_verbose_core2core "Levels added:"
+ (vcat (map ppr annotated_w_levels));
-floatTopBind sw bind@(CoRec _)
- = case (floatBind sw nullIdEnv tOP_LEVEL bind) of { (fc,lc, floats, CoRec pairs', _) ->
- -- Actually floats will be empty
- --false:ASSERT(null floats)
- (fc,lc, [CoRec (floatsToBindPairs floats ++ pairs')])
+ let { (tlets, ntlets, lams) = get_stats (sum_stats fss) };
+
+ dumpIfSet_dyn dflags Opt_D_dump_simpl_stats "FloatOut stats:"
+ (hcat [ int tlets, ptext SLIT(" Lets floated to top level; "),
+ int ntlets, ptext SLIT(" Lets floated elsewhere; from "),
+ int lams, ptext SLIT(" Lambda groups")]);
+
+ endPass dflags float_msg Opt_D_verbose_core2core (concat binds_s')
+ {- no specific flag for dumping float-out -}
}
+ where
+ float_msg = showSDoc (text "Float out" <+> parens (sws float_sws))
+ sws (FloatOutSw lam const) = pp_not lam <+> text "lambdas" <> comma <+>
+ pp_not const <+> text "constants"
+ pp_not True = empty
+ pp_not False = text "not"
+
+floatTopBind bind@(NonRec _ _)
+ = case (floatBind bind) of { (fs, floats, bind') ->
+ (fs, floatsToBinds floats ++ [bind'])
+ }
+
+floatTopBind bind@(Rec _)
+ = case (floatBind bind) of { (fs, floats, Rec pairs') ->
+ WARN( notNull floats, ppr bind $$ ppr floats )
+ (fs, [Rec (floatsToBindPairs floats ++ pairs')]) }
\end{code}
%************************************************************************
\begin{code}
-floatBind :: (GlobalSwitch -> Bool)
- -> IdEnv Level
- -> Level
- -> LevelledBind
- -> (Int,Int, FloatingBinds, PlainCoreBinding, IdEnv Level)
+floatBind :: LevelledBind
+ -> (FloatStats, FloatBinds, CoreBind)
-floatBind sw env lvl (CoNonRec (name,level) rhs)
- = case (floatExpr sw env level rhs) of { (fc,lc, rhs_floats, rhs') ->
+floatBind (NonRec (TB name level) rhs)
+ = case (floatNonRecRhs level rhs) of { (fs, rhs_floats, rhs') ->
+ (fs, rhs_floats, NonRec name rhs') }
- -- A good dumping point
- case (partitionByMajorLevel level rhs_floats) of { (rhs_floats', heres) ->
+floatBind bind@(Rec pairs)
+ = case (unzip3 (map do_pair pairs)) of { (fss, rhss_floats, new_pairs) ->
- (fc,lc, rhs_floats',CoNonRec name (install heres rhs'), addOneToIdEnv env name level)
- }}
-
-floatBind sw env lvl bind@(CoRec pairs)
- = case (unzip4 (map do_pair pairs)) of { (fcs,lcs, rhss_floats, new_pairs) ->
-
- if not (isTopLvl bind_level) then
- -- Standard case
- (sum fcs,sum lcs, concat rhss_floats, CoRec new_pairs, new_env)
+ if not (isTopLvl bind_dest_level) then
+ -- Standard case; the floated bindings can't mention the
+ -- binders, because they couldn't be escaping a major level
+ -- if so.
+ (sum_stats fss, concat rhss_floats, Rec new_pairs)
else
- {- In a recursive binding, destined for the top level (only),
- the rhs floats may contain
- references to the bound things. For example
-
- f = ...(let v = ...f... in b) ...
-
- might get floated to
-
- v = ...f...
- f = ... b ...
-
- and hence we must (pessimistically) make all the floats recursive
- with the top binding. Later dependency analysis will unravel it.
- -}
-
- (sum fcs,sum lcs, [],
- CoRec (new_pairs ++ floatsToBindPairs (concat rhss_floats)),
- new_env)
-
+ -- In a recursive binding, *destined for* the top level
+ -- (only), the rhs floats may contain references to the
+ -- bound things. For example
+ -- f = ...(let v = ...f... in b) ...
+ -- might get floated to
+ -- v = ...f...
+ -- f = ... b ...
+ -- and hence we must (pessimistically) make all the floats recursive
+ -- with the top binding. Later dependency analysis will unravel it.
+ --
+ -- This can only happen for bindings destined for the top level,
+ -- because only then will partitionByMajorLevel allow through a binding
+ -- that only differs in its minor level
+ (sum_stats fss, [],
+ Rec (new_pairs ++ floatsToBindPairs (concat rhss_floats)))
}
where
- new_env = growIdEnvList env (map fst pairs)
-
- bind_level = getBindLevel bind
+ bind_dest_level = getBindLevel bind
- do_pair ((name, level), rhs)
- = case (floatExpr sw new_env level rhs) of { (fc,lc, rhs_floats, rhs') ->
-
- -- A good dumping point
- case (partitionByMajorLevel level rhs_floats) of { (rhs_floats', heres) ->
-
- (fc,lc, rhs_floats', (name, install heres rhs'))
- }}
+ do_pair (TB name level, rhs)
+ = case (floatRhs level rhs) of { (fs, rhs_floats, rhs') ->
+ (fs, rhs_floats, (name, rhs'))
+ }
\end{code}
%************************************************************************
%************************************************************************
\begin{code}
-floatExpr :: (GlobalSwitch -> Bool)
- -> IdEnv Level
- -> Level
- -> LevelledExpr
- -> (Int,Int, FloatingBinds, PlainCoreExpr)
-
-floatExpr sw env _ (CoVar v) = (0,0, [], CoVar v)
-
-floatExpr sw env _ (CoLit l) = (0,0, [], CoLit l)
-
-floatExpr sw env _ (CoPrim op ty as) = (0,0, [], CoPrim op ty as)
-floatExpr sw env _ (CoCon con ty as) = (0,0, [], CoCon con ty as)
-
-floatExpr sw env lvl (CoApp e a)
- = case (floatExpr sw env lvl e) of { (fc,lc, floating_defns, e') ->
- (fc,lc, floating_defns, CoApp e' a) }
-
-floatExpr sw env lvl (CoTyApp e ty)
- = case (floatExpr sw env lvl e) of { (fc,lc, floating_defns, e') ->
- (fc,lc, floating_defns, CoTyApp e' ty) }
-
-floatExpr sw env lvl (CoTyLam tv e)
- = let
- incd_lvl = incMinorLvl lvl
- in
- case (floatExpr sw env incd_lvl e) of { (fc,lc, floats, e') ->
-
- -- Dump any bindings which absolutely cannot go any further
- case (partitionByLevel incd_lvl floats) of { (floats', heres) ->
-
- (fc,lc, floats', CoTyLam tv (install heres e'))
- }}
-
-floatExpr sw env lvl (CoLam args@((_,incd_lvl):_) rhs)
+floatExpr, floatRhs, floatNonRecRhs
+ :: Level
+ -> LevelledExpr
+ -> (FloatStats, FloatBinds, CoreExpr)
+
+floatRhs lvl arg -- Used rec rhss, and case-alternative rhss
+ = case (floatExpr lvl arg) of { (fsa, floats, arg') ->
+ case (partitionByMajorLevel lvl floats) of { (floats', heres) ->
+ -- Dump bindings that aren't going to escape from a lambda;
+ -- in particular, we must dump the ones that are bound by
+ -- the rec or case alternative
+ (fsa, floats', install heres arg') }}
+
+floatNonRecRhs lvl arg -- Used for nested non-rec rhss, and fn args
+ = case (floatExpr lvl arg) of { (fsa, floats, arg') ->
+ -- Dump bindings that aren't going to escape from a lambda
+ -- This isn't a scoping issue (the binder isn't in scope in the RHS of a non-rec binding)
+ -- Rather, it is to avoid floating the x binding out of
+ -- f (let x = e in b)
+ -- unnecessarily. But we first test for values or trival rhss,
+ -- because (in particular) we don't want to insert new bindings between
+ -- the "=" and the "\". E.g.
+ -- f = \x -> let <bind> in <body>
+ -- We do not want
+ -- f = let <bind> in \x -> <body>
+ -- (a) The simplifier will immediately float it further out, so we may
+ -- as well do so right now; in general, keeping rhss as manifest
+ -- values is good
+ -- (b) If a float-in pass follows immediately, it might add yet more
+ -- bindings just after the '='. And some of them might (correctly)
+ -- be strict even though the 'let f' is lazy, because f, being a value,
+ -- gets its demand-info zapped by the simplifier.
+ if exprIsHNF arg' || exprIsTrivial arg' then
+ (fsa, floats, arg')
+ else
+ case (partitionByMajorLevel lvl floats) of { (floats', heres) ->
+ (fsa, floats', install heres arg') }}
+
+floatExpr _ (Var v) = (zeroStats, [], Var v)
+floatExpr _ (Type ty) = (zeroStats, [], Type ty)
+floatExpr _ (Lit lit) = (zeroStats, [], Lit lit)
+
+floatExpr lvl (App e a)
+ = case (floatExpr lvl e) of { (fse, floats_e, e') ->
+ case (floatNonRecRhs lvl a) of { (fsa, floats_a, a') ->
+ (fse `add_stats` fsa, floats_e ++ floats_a, App e' a') }}
+
+floatExpr lvl lam@(Lam _ _)
= let
- args' = map fst args
- new_env = growIdEnvList env args
+ (bndrs_w_lvls, body) = collectBinders lam
+ bndrs = [b | TB b _ <- bndrs_w_lvls]
+ lvls = [l | TB b l <- bndrs_w_lvls]
+
+ -- For the all-tyvar case we are prepared to pull
+ -- the lets out, to implement the float-out-of-big-lambda
+ -- transform; but otherwise we only float bindings that are
+ -- going to escape a value lambda.
+ -- In particular, for one-shot lambdas we don't float things
+ -- out; we get no saving by so doing.
+ partition_fn | all isTyVar bndrs = partitionByLevel
+ | otherwise = partitionByMajorLevel
in
- case (floatExpr sw new_env incd_lvl rhs) of { (fc,lc, floats, rhs') ->
+ case (floatExpr (last lvls) body) of { (fs, floats, body') ->
-- Dump any bindings which absolutely cannot go any further
- case (partitionByLevel incd_lvl floats) of { (floats', heres) ->
+ case (partition_fn (head lvls) floats) of { (floats', heres) ->
- (fc + length floats', lc + 1,
- floats', mkCoLam args' (install heres rhs'))
+ (add_to_stats fs floats', floats', mkLams bndrs (install heres body'))
}}
-floatExpr sw env lvl (CoSCC cc expr)
- = case (floatExpr sw env lvl expr) of { (fc,lc, floating_defns, expr') ->
+floatExpr lvl (Note note@(SCC cc) expr)
+ = case (floatExpr lvl expr) of { (fs, floating_defns, expr') ->
let
- -- annotate bindings floated outwards past an scc expression
+ -- Annotate bindings floated outwards past an scc expression
-- with the cc. We mark that cc as "duplicated", though.
annotated_defns = annotate (dupifyCC cc) floating_defns
in
- (fc,lc, annotated_defns, CoSCC cc expr') }
+ (fs, annotated_defns, Note note expr') }
where
- annotate :: CostCentre -> FloatingBinds -> FloatingBinds
+ annotate :: CostCentre -> FloatBinds -> FloatBinds
annotate dupd_cc defn_groups
= [ (level, ann_bind floater) | (level, floater) <- defn_groups ]
where
- ann_bind (LetFloater (CoNonRec binder rhs))
- = LetFloater (CoNonRec binder (ann_rhs rhs))
-
- ann_bind (LetFloater (CoRec pairs))
- = LetFloater (CoRec [(binder, ann_rhs rhs) | (binder, rhs) <- pairs])
-
- ann_bind (CaseFloater fn) = CaseFloater ( \ rhs -> CoSCC dupd_cc (fn rhs) )
-
- ann_rhs (CoLam args e) = CoLam args (ann_rhs e)
- ann_rhs (CoTyLam tv e) = CoTyLam tv (ann_rhs e)
- ann_rhs rhs@(CoCon _ _ _)= rhs -- no point in scc'ing WHNF data
- ann_rhs rhs = CoSCC dupd_cc rhs
-
- -- Note: Nested SCC's are preserved for the benefit of
- -- cost centre stack profiling (Durham)
-
-floatExpr sw env lvl (CoLet bind body)
- = case (floatBind sw env lvl bind) of { (fcb,lcb, rhs_floats, bind', new_env) ->
- case (floatExpr sw new_env lvl body) of { (fce,lce, body_floats, body') ->
- (fcb + fce, lcb + lce,
- rhs_floats ++ [(bind_lvl, LetFloater bind')] ++ body_floats, body')
- }}
+ ann_bind (NonRec binder rhs)
+ = NonRec binder (mkSCC dupd_cc rhs)
+
+ ann_bind (Rec pairs)
+ = Rec [(binder, mkSCC dupd_cc rhs) | (binder, rhs) <- pairs]
+
+floatExpr lvl (Note InlineMe expr) -- Other than SCCs
+ = case floatExpr InlineCtxt expr of { (fs, floating_defns, expr') ->
+ -- There can be some floating_defns, arising from
+ -- ordinary lets that were there all the time. It seems
+ -- more efficient to test once here than to avoid putting
+ -- them into floating_defns (which would mean testing for
+ -- inlineCtxt at every let)
+ (fs, [], Note InlineMe (install floating_defns expr')) } -- See notes in SetLevels
+
+floatExpr lvl (Note note expr) -- Other than SCCs
+ = case (floatExpr lvl expr) of { (fs, floating_defns, expr') ->
+ (fs, floating_defns, Note note expr') }
+
+floatExpr lvl (Let (NonRec (TB bndr bndr_lvl) rhs) body)
+ | isUnLiftedType (idType bndr) -- Treat unlifted lets just like a case
+ = case floatExpr lvl rhs of { (fs, rhs_floats, rhs') ->
+ case floatRhs bndr_lvl body of { (fs, body_floats, body') ->
+ (fs, rhs_floats ++ body_floats, Let (NonRec bndr rhs') body') }}
+
+floatExpr lvl (Let bind body)
+ = case (floatBind bind) of { (fsb, rhs_floats, bind') ->
+ case (floatExpr lvl body) of { (fse, body_floats, body') ->
+ (add_stats fsb fse,
+ rhs_floats ++ [(bind_lvl, bind')] ++ body_floats,
+ body') }}
where
bind_lvl = getBindLevel bind
-floatExpr sw env lvl (CoCase scrut alts)
- = case (floatExpr sw env lvl scrut) of { (fce,lce, fde, scrut') ->
+floatExpr lvl (Case scrut (TB case_bndr case_lvl) ty alts)
+ = case floatExpr lvl scrut of { (fse, fde, scrut') ->
+ case floatList float_alt alts of { (fsa, fda, alts') ->
+ (add_stats fse fsa, fda ++ fde, Case scrut' case_bndr ty alts')
+ }}
+ where
+ -- Use floatRhs for the alternatives, so that we
+ -- don't gratuitiously float bindings out of the RHSs
+ float_alt (con, bs, rhs)
+ = case (floatRhs case_lvl rhs) of { (fs, rhs_floats, rhs') ->
+ (fs, rhs_floats, (con, [b | TB b _ <- bs], rhs')) }
+
+
+floatList :: (a -> (FloatStats, FloatBinds, b)) -> [a] -> (FloatStats, FloatBinds, [b])
+floatList f [] = (zeroStats, [], [])
+floatList f (a:as) = case f a of { (fs_a, binds_a, b) ->
+ case floatList f as of { (fs_as, binds_as, bs) ->
+ (fs_a `add_stats` fs_as, binds_a ++ binds_as, b:bs) }}
+\end{code}
- case (scrut', float_alts alts) of
+%************************************************************************
+%* *
+\subsection{Utility bits for floating stats}
+%* *
+%************************************************************************
-{- CASE-FLOATING DROPPED FOR NOW. (SLPJ 7/2/94)
+I didn't implement this with unboxed numbers. I don't want to be too
+strict in this stuff, as it is rarely turned on. (WDP 95/09)
- (CoVar scrut_var, (fda, CoAlgAlts [(con,bs,rhs')] CoNoDefault))
- | scrut_var_lvl `ltMajLvl` lvl ->
+\begin{code}
+data FloatStats
+ = FlS Int -- Number of top-floats * lambda groups they've been past
+ Int -- Number of non-top-floats * lambda groups they've been past
+ Int -- Number of lambda (groups) seen
- -- Candidate for case floater; scrutinising a variable; it can
- -- escape outside a lambda; there's only one alternative.
- (fda ++ fde ++ [case_floater], rhs')
+get_stats (FlS a b c) = (a, b, c)
- where
- case_floater = (scrut_var_lvl, CaseFloater fn)
- fn body = CoCase scrut' (CoAlgAlts [(con,bs,body)] CoNoDefault)
- scrut_var_lvl = case lookupIdEnv env scrut_var of
- Nothing -> Level 0 0
- Just lvl -> unTopify lvl
+zeroStats = FlS 0 0 0
- END OF CASE FLOATING DROPPED -}
+sum_stats xs = foldr add_stats zeroStats xs
- (_, (fca,lca, fda, alts')) ->
+add_stats (FlS a1 b1 c1) (FlS a2 b2 c2)
+ = FlS (a1 + a2) (b1 + b2) (c1 + c2)
- (fce + fca, lce + lca, fda ++ fde, CoCase scrut' alts')
- }
+add_to_stats (FlS a b c) floats
+ = FlS (a + length top_floats) (b + length other_floats) (c + 1)
where
- incd_lvl = incMinorLvl lvl
-
- partition_fn = partitionByMajorLevel
-
-{- OMITTED
- We don't want to be too keen about floating lets out of case alternatives
- because they may benefit from seeing the evaluation done by the case.
-
- The main reason for doing this is to allocate in fewer larger blocks
- but that's really an STG-level issue.
-
- case alts of
- -- Just one alternative, then dump only
- -- what *has* to be dumped
- CoAlgAlts [_] CoNoDefault -> partitionByLevel
- CoAlgAlts [] (CoBindDefault _ _) -> partitionByLevel
- CoPrimAlts [_] CoNoDefault -> partitionByLevel
- CoPrimAlts [] (CoBindDefault _ _) -> partitionByLevel
-
- -- If there's more than one alternative, then
- -- this is a dumping point
- other -> partitionByMajorLevel
--}
-
- float_alts (CoAlgAlts alts deflt)
- = case (float_deflt deflt) of { (fcd,lcd, fdd, deflt') ->
- case (unzip4 (map float_alg_alt alts)) of { (fcas,lcas, fdas, alts') ->
- (fcd + sum fcas, lcd + sum lcas,
- concat fdas ++ fdd, CoAlgAlts alts' deflt') }}
-
- float_alts (CoPrimAlts alts deflt)
- = case (float_deflt deflt) of { (fcd,lcd, fdd, deflt') ->
- case (unzip4 (map float_prim_alt alts)) of { (fcas,lcas, fdas, alts') ->
- (fcd + sum fcas, lcd + sum lcas,
- concat fdas ++ fdd, CoPrimAlts alts' deflt') }}
-
- -------------
- float_alg_alt (con, bs, rhs)
- = let
- bs' = map fst bs
- new_env = growIdEnvList env bs
- in
- case (floatExpr sw new_env incd_lvl rhs) of { (fc,lc, rhs_floats, rhs') ->
- case (partition_fn incd_lvl rhs_floats) of { (rhs_floats', heres) ->
- (fc, lc, rhs_floats', (con, bs', install heres rhs'))
- }}
-
- --------------
- float_prim_alt (lit, rhs)
- = case (floatExpr sw env incd_lvl rhs) of { (fc,lc, rhs_floats, rhs') ->
- case (partition_fn incd_lvl rhs_floats) of { (rhs_floats', heres) ->
- (fc,lc, rhs_floats', (lit, install heres rhs'))
- }}
-
- --------------
- float_deflt CoNoDefault = (0,0, [], CoNoDefault)
-
- float_deflt (CoBindDefault (b,lvl) rhs)
- = case (floatExpr sw new_env lvl rhs) of { (fc,lc, rhs_floats, rhs') ->
- case (partition_fn incd_lvl rhs_floats) of { (rhs_floats', heres) ->
- (fc,lc, rhs_floats', CoBindDefault b (install heres rhs'))
- }}
- where
- new_env = addOneToIdEnv env b lvl
+ (top_floats, other_floats) = partition to_very_top floats
+
+ to_very_top (my_lvl, _) = isTopLvl my_lvl
\end{code}
+
%************************************************************************
%* *
-\subsection[FloatOut-utils]{Utility bits for floating}
+\subsection{Utility bits for floating}
%* *
%************************************************************************
\begin{code}
-getBindLevel (CoNonRec (_, lvl) _) = lvl
-getBindLevel (CoRec (((_,lvl), _) : _)) = lvl
+getBindLevel (NonRec (TB _ lvl) _) = lvl
+getBindLevel (Rec (((TB _ lvl), _) : _)) = lvl
\end{code}
\begin{code}
partitionByMajorLevel, partitionByLevel
:: Level -- Partitioning level
- -> FloatingBinds -- Defns to be divided into 2 piles...
+ -> FloatBinds -- Defns to be divided into 2 piles...
- -> (FloatingBinds, -- Defns with level strictly < partition level,
- FloatingBinds) -- The rest
+ -> (FloatBinds, -- Defns with level strictly < partition level,
+ FloatBinds) -- The rest
-partitionByMajorLevel ctxt_lvl defns
+partitionByMajorLevel ctxt_lvl defns
= partition float_further defns
where
- float_further (my_lvl, _) = my_lvl `ltMajLvl` ctxt_lvl ||
- isTopLvl my_lvl
+ -- Float it if we escape a value lambda, or if we get to the top level
+ float_further (my_lvl, bind) = my_lvl `ltMajLvl` ctxt_lvl || isTopLvl my_lvl
+ -- The isTopLvl part says that if we can get to the top level, say "yes" anyway
+ -- This means that
+ -- x = f e
+ -- transforms to
+ -- lvl = e
+ -- x = f lvl
+ -- which is as it should be
partitionByLevel ctxt_lvl defns
= partition float_further defns
\end{code}
\begin{code}
-floatsToBinds :: FloatingBinds -> [PlainCoreBinding]
-floatsToBinds floats = map get_bind floats
- where
- get_bind (_, LetFloater bind) = bind
- get_bind (_, CaseFloater _) = panic "floatsToBinds"
+floatsToBinds :: FloatBinds -> [CoreBind]
+floatsToBinds floats = map snd floats
-floatsToBindPairs :: FloatingBinds -> [(Id,PlainCoreExpr)]
+floatsToBindPairs :: FloatBinds -> [(Id,CoreExpr)]
floatsToBindPairs floats = concat (map mk_pairs floats)
where
- mk_pairs (_, LetFloater (CoRec pairs)) = pairs
- mk_pairs (_, LetFloater (CoNonRec binder rhs)) = [(binder,rhs)]
- mk_pairs (_, CaseFloater _) = panic "floatsToBindPairs"
+ mk_pairs (_, Rec pairs) = pairs
+ mk_pairs (_, NonRec binder rhs) = [(binder,rhs)]
-install :: FloatingBinds -> PlainCoreExpr -> PlainCoreExpr
+install :: FloatBinds -> CoreExpr -> CoreExpr
install defn_groups expr
= foldr install_group expr defn_groups
where
- install_group (_, LetFloater defns) body = CoLet defns body
- install_group (_, CaseFloater fn) body = fn body
+ install_group (_, defns) body = Let defns body
\end{code}
projects / ghc-hetmet.git / blobdiff