X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FsimplCore%2FFloatOut.lhs;h=988bd53015d53474cc51ccb94b8ddf35e5657b55;hb=3034a6c8cfb50e2b5af4ef57c419986039b53a94;hp=91b66e6f293ef100113ca5f719ab428afcf115e6;hpb=1fb1ab5d53a09607e7f6d2450806760688396387;p=ghc-hetmet.git diff --git a/ghc/compiler/simplCore/FloatOut.lhs b/ghc/compiler/simplCore/FloatOut.lhs index 91b66e6..988bd53 100644 --- a/ghc/compiler/simplCore/FloatOut.lhs +++ b/ghc/compiler/simplCore/FloatOut.lhs @@ -1,37 +1,72 @@ % -% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996 +% (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 -IMP_Ubiq(){-uitous-} -IMPORT_1_3(List(partition)) +#include "HsVersions.h" import CoreSyn - -import CmdLineOpts ( opt_D_verbose_core2core, opt_D_simplifier_stats ) -import CostCentre ( dupifyCC ) -import Id ( nullIdEnv, addOneToIdEnv, growIdEnvList, SYN_IE(IdEnv), - GenId{-instance Outputable-} - ) -import Outputable ( Outputable(..){-instance (,)-} ) -import PprCore -import PprStyle ( PprStyle(..) ) -import PprType ( GenTyVar ) -import Pretty ( ppInt, ppPStr, ppBesides, ppAboves ) -import SetLevels -- all of it -import TyVar ( GenTyVar{-instance Eq-} ) -import Unique ( Unique{-instance Eq-} ) -import Usage ( SYN_IE(UVar) ) -import Util ( pprTrace, panic ) +import CoreUtils ( mkSCC, exprIsHNF, exprIsTrivial ) + +import DynFlags ( DynFlags, DynFlag(..), FloatOutSwitches(..) ) +import ErrUtils ( dumpIfSet_dyn ) +import CostCentre ( dupifyCC, CostCentre ) +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 ~~~~~~~~~~~~~~~ @@ -58,25 +93,15 @@ It turns out that this generates a subexpression of the form @ \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 = GenCoreExpr (Id, Level) Id TyVar UVar -type LevelledBind = GenCoreBinding (Id, Level) Id TyVar UVar -type FloatingBind = (Level, Floater) -type FloatingBinds = [FloatingBind] - -data Floater - = LetFloater CoreBinding - | CaseFloater (CoreExpr -> CoreExpr) - -- A CoreExpr with a hole in it: - -- "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} %************************************************************************ @@ -86,44 +111,48 @@ data Floater %************************************************************************ \begin{code} -floatOutwards :: UniqSupply -> [CoreBinding] -> [CoreBinding] - -floatOutwards us pgm - = case (setLevels pgm us) of { annotated_w_levels -> - - case (unzip (map floatTopBind annotated_w_levels)) - of { (fss, final_toplev_binds_s) -> - - (if opt_D_verbose_core2core - then pprTrace "Levels added:\n" - (ppAboves (map (ppr PprDebug) annotated_w_levels)) - else id - ) - ( if not (opt_D_simplifier_stats) then - id - else - let - (tlets, ntlets, lams) = get_stats (sum_stats fss) - in - pprTrace "FloatOut stats: " (ppBesides [ - ppInt tlets, ppPStr SLIT(" Lets floated to top level; "), - ppInt ntlets, ppPStr SLIT(" Lets floated elsewhere; from "), - ppInt lams, ppPStr SLIT(" Lambda groups")]) - ) - concat final_toplev_binds_s - }} +floatOutwards :: FloatOutSwitches + -> DynFlags + -> UniqSupply + -> [CoreBind] -> IO [CoreBind] + +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)); + + 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 nullIdEnv tOP_LEVEL bind) of { (fs, floats, bind', _) -> + = case (floatBind bind) of { (fs, floats, bind') -> (fs, floatsToBinds floats ++ [bind']) } floatTopBind bind@(Rec _) - = case (floatBind nullIdEnv tOP_LEVEL bind) of { (fs, floats, Rec pairs', _) -> - -- Actually floats will be empty - --false:ASSERT(null floats) - (fs, [Rec (floatsToBindPairs floats ++ pairs')]) - } + = case (floatBind bind) of { (fs, floats, Rec pairs') -> + WARN( notNull floats, ppr bind $$ ppr floats ) + (fs, [Rec (floatsToBindPairs floats ++ pairs')]) } \end{code} %************************************************************************ @@ -134,63 +163,45 @@ floatTopBind bind@(Rec _) \begin{code} -floatBind :: IdEnv Level - -> Level - -> LevelledBind - -> (FloatStats, FloatingBinds, CoreBinding, IdEnv Level) +floatBind :: LevelledBind + -> (FloatStats, FloatBinds, CoreBind) -floatBind env lvl (NonRec (name,level) rhs) - = case (floatExpr env level rhs) of { (fs, 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) -> - - (fs, rhs_floats', - NonRec name (install heres rhs'), - addOneToIdEnv env name level) - }} - -floatBind env lvl bind@(Rec pairs) +floatBind bind@(Rec pairs) = case (unzip3 (map do_pair pairs)) of { (fss, rhss_floats, new_pairs) -> - if not (isTopLvl bind_level) then - -- Standard case - (sum_stats fss, concat rhss_floats, Rec 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_stats fss, - [], - Rec (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_dest_level = getBindLevel bind - bind_level = getBindLevel bind - - do_pair ((name, level), rhs) - = case (floatExpr new_env level rhs) of { (fs, rhs_floats, rhs') -> - - -- A good dumping point - case (partitionByMajorLevel level rhs_floats) of { (rhs_floats', heres) -> - - (fs, 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} %************************************************************************ @@ -200,181 +211,143 @@ floatBind env lvl bind@(Rec pairs) %************************************************************************ \begin{code} -floatExpr :: IdEnv Level - -> Level - -> LevelledExpr - -> (FloatStats, FloatingBinds, CoreExpr) - -floatExpr env _ (Var v) = (zero_stats, [], Var v) -floatExpr env _ (Lit l) = (zero_stats, [], Lit l) -floatExpr env _ (Prim op as) = (zero_stats, [], Prim op as) -floatExpr env _ (Con con as) = (zero_stats, [], Con con as) - -floatExpr env lvl (App e a) - = case (floatExpr env lvl e) of { (fs, floating_defns, e') -> - (fs, floating_defns, App e' a) } - -floatExpr env lvl (Lam (UsageBinder _) e) - = panic "FloatOut.floatExpr: Lam UsageBinder" - -floatExpr env lvl (Lam (TyBinder tv) e) - = let - incd_lvl = incMinorLvl lvl - in - case (floatExpr env incd_lvl e) of { (fs, floats, e') -> - - -- Dump any bindings which absolutely cannot go any further - case (partitionByLevel incd_lvl floats) of { (floats', heres) -> +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 in + -- We do not want + -- f = let in \x -> + -- (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') }} - (fs, floats', Lam (TyBinder tv) (install heres e')) - }} +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 env lvl (Lam (ValBinder (arg,incd_lvl)) rhs) +floatExpr lvl lam@(Lam _ _) = let - new_env = addOneToIdEnv env arg incd_lvl + (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 new_env incd_lvl rhs) of { (fs, 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) -> - (add_to_stats fs floats', - floats', - Lam (ValBinder arg) (install heres rhs')) + (add_to_stats fs floats', floats', mkLams bndrs (install heres body')) }} -floatExpr env lvl (SCC cc expr) - = case (floatExpr env lvl expr) of { (fs, 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 - (fs, annotated_defns, SCC 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 (NonRec binder rhs)) - = LetFloater (NonRec binder (ann_rhs rhs)) - - ann_bind (LetFloater (Rec pairs)) - = LetFloater (Rec [(binder, ann_rhs rhs) | (binder, rhs) <- pairs]) - - ann_bind (CaseFloater fn) = CaseFloater ( \ rhs -> SCC dupd_cc (fn rhs) ) - - ann_rhs (Lam arg e) = Lam arg (ann_rhs e) - ann_rhs rhs@(Con _ _) = rhs -- no point in scc'ing WHNF data - ann_rhs rhs = SCC dupd_cc rhs - - -- Note: Nested SCC's are preserved for the benefit of - -- cost centre stack profiling (Durham) - -floatExpr env lvl (Coerce c ty expr) - = case (floatExpr env lvl expr) of { (fs, floating_defns, expr') -> - (fs, floating_defns, Coerce c ty expr') } - -floatExpr env lvl (Let bind body) - = case (floatBind env lvl bind) of { (fsb, rhs_floats, bind', new_env) -> - case (floatExpr new_env lvl body) of { (fse, 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, LetFloater bind')] ++ body_floats, - body') - }} + rhs_floats ++ [(bind_lvl, bind')] ++ body_floats, + body') }} where bind_lvl = getBindLevel bind -floatExpr env lvl (Case scrut alts) - = case (floatExpr env lvl scrut) of { (fse, fde, scrut') -> - - case (scrut', float_alts alts) of - (_, (fsa, fda, alts')) -> - (add_stats fse fsa, fda ++ fde, Case scrut' alts') - } - {- OLD CASE-FLOATING CODE: DROPPED FOR NOW. (SLPJ 7/2/94) - - (Var scrut_var, (fda, AlgAlts [(con,bs,rhs')] NoDefault)) - | scrut_var_lvl `ltMajLvl` lvl -> - - -- Candidate for case floater; scrutinising a variable; it can - -- escape outside a lambda; there's only one alternative. - (fda ++ fde ++ [case_floater], rhs') - - where - case_floater = (scrut_var_lvl, CaseFloater fn) - fn body = Case scrut' (AlgAlts [(con,bs,body)] NoDefault) - scrut_var_lvl = case lookupIdEnv env scrut_var of - Nothing -> Level 0 0 - Just lvl -> unTopify lvl - - END OF CASE FLOATING DROPPED -} +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 - 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 - AlgAlts [_] NoDefault -> partitionByLevel - AlgAlts [] (BindDefault _ _) -> partitionByLevel - PrimAlts [_] NoDefault -> partitionByLevel - PrimAlts [] (BindDefault _ _) -> partitionByLevel - - -- If there's more than one alternative, then - -- this is a dumping point - other -> partitionByMajorLevel --} - - float_alts (AlgAlts alts deflt) - = case (float_deflt deflt) of { (fsd, fdd, deflt') -> - case (unzip3 (map float_alg_alt alts)) of { (fsas, fdas, alts') -> - (foldr add_stats fsd fsas, - concat fdas ++ fdd, - AlgAlts alts' deflt') }} - - float_alts (PrimAlts alts deflt) - = case (float_deflt deflt) of { (fsd, fdd, deflt') -> - case (unzip3 (map float_prim_alt alts)) of { (fsas, fdas, alts') -> - (foldr add_stats fsd fsas, - concat fdas ++ fdd, - PrimAlts alts' deflt') }} - - ------------- - float_alg_alt (con, bs, rhs) - = let - bs' = map fst bs - new_env = growIdEnvList env bs - in - case (floatExpr new_env incd_lvl rhs) of { (fs, rhs_floats, rhs') -> - case (partition_fn incd_lvl rhs_floats) of { (rhs_floats', heres) -> - (fs, rhs_floats', (con, bs', install heres rhs')) }} - - -------------- - float_prim_alt (lit, rhs) - = case (floatExpr env incd_lvl rhs) of { (fs, rhs_floats, rhs') -> - case (partition_fn incd_lvl rhs_floats) of { (rhs_floats', heres) -> - (fs, rhs_floats', (lit, install heres rhs')) }} - - -------------- - float_deflt NoDefault = (zero_stats, [], NoDefault) - - float_deflt (BindDefault (b,lvl) rhs) - = case (floatExpr new_env lvl rhs) of { (fs, rhs_floats, rhs') -> - case (partition_fn incd_lvl rhs_floats) of { (rhs_floats', heres) -> - (fs, rhs_floats', BindDefault b (install heres rhs')) }} - where - new_env = addOneToIdEnv env b lvl + -- 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} %************************************************************************ @@ -394,9 +367,9 @@ data FloatStats get_stats (FlS a b c) = (a, b, c) -zero_stats = FlS 0 0 0 +zeroStats = FlS 0 0 0 -sum_stats xs = foldr add_stats zero_stats xs +sum_stats xs = foldr add_stats zeroStats xs add_stats (FlS a1 b1 c1) (FlS a2 b2 c2) = FlS (a1 + a2) (b1 + b2) (c1 + c2) @@ -409,6 +382,7 @@ add_to_stats (FlS a b c) floats to_very_top (my_lvl, _) = isTopLvl my_lvl \end{code} + %************************************************************************ %* * \subsection{Utility bits for floating} @@ -416,25 +390,32 @@ add_to_stats (FlS a b c) floats %************************************************************************ \begin{code} -getBindLevel (NonRec (_, lvl) _) = lvl -getBindLevel (Rec (((_,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 = 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 @@ -443,25 +424,20 @@ partitionByLevel ctxt_lvl defns \end{code} \begin{code} -floatsToBinds :: FloatingBinds -> [CoreBinding] -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,CoreExpr)] +floatsToBindPairs :: FloatBinds -> [(Id,CoreExpr)] floatsToBindPairs floats = concat (map mk_pairs floats) where - mk_pairs (_, LetFloater (Rec pairs)) = pairs - mk_pairs (_, LetFloater (NonRec binder rhs)) = [(binder,rhs)] - mk_pairs (_, CaseFloater _) = panic "floatsToBindPairs" + mk_pairs (_, Rec pairs) = pairs + mk_pairs (_, NonRec binder rhs) = [(binder,rhs)] -install :: FloatingBinds -> CoreExpr -> CoreExpr +install :: FloatBinds -> CoreExpr -> CoreExpr install defn_groups expr = foldr install_group expr defn_groups where - install_group (_, LetFloater defns) body = Let defns body - install_group (_, CaseFloater fn) body = fn body + install_group (_, defns) body = Let defns body \end{code}