X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Fspecialise%2FSpecConstr.lhs;h=78d173140047e3369350d0e540c2e6e3960702e0;hb=79326edf58637add0e0913189365ccca72c7f82b;hp=9570c247bb89a22fd106c22024d44f1b2205fc04;hpb=b5f43414d0329b56abaaeb5e9e4708000e93670c;p=ghc-hetmet.git diff --git a/compiler/specialise/SpecConstr.lhs b/compiler/specialise/SpecConstr.lhs index 9570c24..78d1731 100644 --- a/compiler/specialise/SpecConstr.lhs +++ b/compiler/specialise/SpecConstr.lhs @@ -12,17 +12,16 @@ module SpecConstr( import CoreSyn import CoreLint ( showPass, endPass ) -import CoreUtils ( exprType, tcEqExpr, mkPiTypes ) +import CoreUtils ( exprType, mkPiTypes ) import CoreFVs ( exprsFreeVars ) -import CoreSubst ( Subst, mkSubst, substExpr ) import CoreTidy ( tidyRules ) import PprCore ( pprRules ) import WwLib ( mkWorkerArgs ) -import DataCon ( dataConRepArity, isVanillaDataCon ) -import Type ( tyConAppArgs, tyVarsOfTypes ) -import Unify ( coreRefineTys ) +import DataCon ( dataConRepArity, dataConUnivTyVars ) +import Type ( Type, tyConAppArgs ) +import Rules ( matchN ) import Id ( Id, idName, idType, isDataConWorkId_maybe, - mkUserLocal, mkSysLocal, idUnfolding ) + mkUserLocal, mkSysLocal, idUnfolding, isLocalId ) import Var ( Var ) import VarEnv import VarSet @@ -32,12 +31,13 @@ import OccName ( mkSpecOcc ) import ErrUtils ( dumpIfSet_dyn ) import DynFlags ( DynFlags, DynFlag(..) ) import BasicTypes ( Activation(..) ) -import Maybes ( orElse ) -import Util ( mapAccumL, lengthAtLeast, notNull ) +import Maybes ( orElse, catMaybes, isJust ) +import Util ( zipWithEqual, lengthAtLeast, notNull ) import List ( nubBy, partition ) import UniqSupply import Outputable import FastString +import UniqFM \end{code} ----------------------------------------------------- @@ -93,11 +93,40 @@ In Core, by the time we've w/wd (f is strict in i) we get At the call to f, we see that the argument, n is know to be (I# n#), and n is evaluated elsewhere in the body of f, so we can play the same -trick as above. However we don't want to do that if the boxed version -of n is needed (else we'd avoid the eval but pay more for re-boxing n). -So in this case we want that the *only* uses of n are in case statements. +trick as above. +Note [Reboxing] +~~~~~~~~~~~~~~~ +We must be careful not to allocate the same constructor twice. Consider + f p = (...(case p of (a,b) -> e)...p..., + ...let t = (r,s) in ...t...(f t)...) +At the recursive call to f, we can see that t is a pair. But we do NOT want +to make a specialised copy: + f' a b = let p = (a,b) in (..., ...) +because now t is allocated by the caller, then r and s are passed to the +recursive call, which allocates the (r,s) pair again. + +This happens if + (a) the argument p is used in other than a case-scrutinsation way. + (b) the argument to the call is not a 'fresh' tuple; you have to + look into its unfolding to see that it's a tuple + +Hence the "OR" part of Note [Good arguments] below. + +ALTERNATIVE: pass both boxed and unboxed versions. This no longer saves +allocation, but does perhaps save evals. In the RULE we'd have +something like + + f (I# x#) = f' (I# x#) x# + +If at the call site the (I# x) was an unfolding, then we'd have to +rely on CSE to eliminate the duplicate allocation.... This alternative +doesn't look attractive enough to pursue. + + +Note [Good arguments] +~~~~~~~~~~~~~~~~~~~~~ So we look for * A self-recursive function. Ignore mutual recursion for now, @@ -119,7 +148,7 @@ So we look for That same parameter is scrutinised by a case somewhere in the RHS of the function AND - Those are the only uses of the parameter + Those are the only uses of the parameter (see Note [Reboxing]) What to abstract over @@ -190,6 +219,161 @@ is to run deShadowBinds before running SpecConstr, but instead we run the simplifier. That gives the simplest possible program for SpecConstr to chew on; and it virtually guarantees no shadowing. +Note [Specialising for constant parameters] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +This one is about specialising on a *constant* (but not necessarily +constructor) argument + + foo :: Int -> (Int -> Int) -> Int + foo 0 f = 0 + foo m f = foo (f m) (+1) + +It produces + + lvl_rmV :: GHC.Base.Int -> GHC.Base.Int + lvl_rmV = + \ (ds_dlk :: GHC.Base.Int) -> + case ds_dlk of wild_alH { GHC.Base.I# x_alG -> + GHC.Base.I# (GHC.Prim.+# x_alG 1) + + T.$wfoo :: GHC.Prim.Int# -> (GHC.Base.Int -> GHC.Base.Int) -> + GHC.Prim.Int# + T.$wfoo = + \ (ww_sme :: GHC.Prim.Int#) (w_smg :: GHC.Base.Int -> GHC.Base.Int) -> + case ww_sme of ds_Xlw { + __DEFAULT -> + case w_smg (GHC.Base.I# ds_Xlw) of w1_Xmo { GHC.Base.I# ww1_Xmz -> + T.$wfoo ww1_Xmz lvl_rmV + }; + 0 -> 0 + } + +The recursive call has lvl_rmV as its argument, so we could create a specialised copy +with that argument baked in; that is, not passed at all. Now it can perhaps be inlined. + +When is this worth it? Call the constant 'lvl' +- If 'lvl' has an unfolding that is a constructor, see if the corresponding + parameter is scrutinised anywhere in the body. + +- If 'lvl' has an unfolding that is a inlinable function, see if the corresponding + parameter is applied (...to enough arguments...?) + + Also do this is if the function has RULES? + +Also + +Note [Specialising for lambda parameters] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + foo :: Int -> (Int -> Int) -> Int + foo 0 f = 0 + foo m f = foo (f m) (\n -> n-m) + +This is subtly different from the previous one in that we get an +explicit lambda as the argument: + + T.$wfoo :: GHC.Prim.Int# -> (GHC.Base.Int -> GHC.Base.Int) -> + GHC.Prim.Int# + T.$wfoo = + \ (ww_sm8 :: GHC.Prim.Int#) (w_sma :: GHC.Base.Int -> GHC.Base.Int) -> + case ww_sm8 of ds_Xlr { + __DEFAULT -> + case w_sma (GHC.Base.I# ds_Xlr) of w1_Xmf { GHC.Base.I# ww1_Xmq -> + T.$wfoo + ww1_Xmq + (\ (n_ad3 :: GHC.Base.Int) -> + case n_ad3 of wild_alB { GHC.Base.I# x_alA -> + GHC.Base.I# (GHC.Prim.-# x_alA ds_Xlr) + }) + }; + 0 -> 0 + } + +I wonder if SpecConstr couldn't be extended to handle this? After all, +lambda is a sort of constructor for functions and perhaps it already +has most of the necessary machinery? + +Furthermore, there's an immediate win, because you don't need to allocate the lamda +at the call site; and if perchance it's called in the recursive call, then you +may avoid allocating it altogether. Just like for constructors. + +Looks cool, but probably rare...but it might be easy to implement. + +----------------------------------------------------- + Stuff not yet handled +----------------------------------------------------- + +Here are notes arising from Roman's work that I don't want to lose. + +Example 1 +~~~~~~~~~ + data T a = T !a + + foo :: Int -> T Int -> Int + foo 0 t = 0 + foo x t | even x = case t of { T n -> foo (x-n) t } + | otherwise = foo (x-1) t + +SpecConstr does no specialisation, because the second recursive call +looks like a boxed use of the argument. A pity. + + $wfoo_sFw :: GHC.Prim.Int# -> T.T GHC.Base.Int -> GHC.Prim.Int# + $wfoo_sFw = + \ (ww_sFo [Just L] :: GHC.Prim.Int#) (w_sFq [Just L] :: T.T GHC.Base.Int) -> + case ww_sFo of ds_Xw6 [Just L] { + __DEFAULT -> + case GHC.Prim.remInt# ds_Xw6 2 of wild1_aEF [Dead Just A] { + __DEFAULT -> $wfoo_sFw (GHC.Prim.-# ds_Xw6 1) w_sFq; + 0 -> + case w_sFq of wild_Xy [Just L] { T.T n_ad5 [Just U(L)] -> + case n_ad5 of wild1_aET [Just A] { GHC.Base.I# y_aES [Just L] -> + $wfoo_sFw (GHC.Prim.-# ds_Xw6 y_aES) wild_Xy + } } }; + 0 -> 0 + +Example 2 +~~~~~~~~~ + data a :*: b = !a :*: !b + data T a = T !a + + foo :: (Int :*: T Int) -> Int + foo (0 :*: t) = 0 + foo (x :*: t) | even x = case t of { T n -> foo ((x-n) :*: t) } + | otherwise = foo ((x-1) :*: t) + +Very similar to the previous one, except that the parameters are now in +a strict tuple. Before SpecConstr, we have + + $wfoo_sG3 :: GHC.Prim.Int# -> T.T GHC.Base.Int -> GHC.Prim.Int# + $wfoo_sG3 = + \ (ww_sFU [Just L] :: GHC.Prim.Int#) (ww_sFW [Just L] :: T.T + GHC.Base.Int) -> + case ww_sFU of ds_Xws [Just L] { + __DEFAULT -> + case GHC.Prim.remInt# ds_Xws 2 of wild1_aEZ [Dead Just A] { + __DEFAULT -> + case ww_sFW of tpl_B2 [Just L] { T.T a_sFo [Just A] -> + $wfoo_sG3 (GHC.Prim.-# ds_Xws 1) tpl_B2 -- $wfoo1 + }; + 0 -> + case ww_sFW of wild_XB [Just A] { T.T n_ad7 [Just S(L)] -> + case n_ad7 of wild1_aFd [Just L] { GHC.Base.I# y_aFc [Just L] -> + $wfoo_sG3 (GHC.Prim.-# ds_Xws y_aFc) wild_XB -- $wfoo2 + } } }; + 0 -> 0 } + +We get two specialisations: +"SC:$wfoo1" [0] __forall {a_sFB :: GHC.Base.Int sc_sGC :: GHC.Prim.Int#} + Foo.$wfoo sc_sGC (Foo.T @ GHC.Base.Int a_sFB) + = Foo.$s$wfoo1 a_sFB sc_sGC ; +"SC:$wfoo2" [0] __forall {y_aFp :: GHC.Prim.Int# sc_sGC :: GHC.Prim.Int#} + Foo.$wfoo sc_sGC (Foo.T @ GHC.Base.Int (GHC.Base.I# y_aFp)) + = Foo.$s$wfoo y_aFp sc_sGC ; + +But perhaps the first one isn't good. After all, we know that tpl_B2 is +a T (I# x) really, because T is strict and Int has one constructor. (We can't +unbox the strict fields, becuase T is polymorphic!) + + %************************************************************************ %* * @@ -226,12 +410,14 @@ specConstrProgram dflags us binds %************************************************************************ \begin{code} -data ScEnv = SCE { scope :: VarEnv HowBound, +data ScEnv = SCE { scope :: InScopeEnv, -- Binds all non-top-level variables in scope cons :: ConstrEnv } +type InScopeEnv = VarEnv HowBound + type ConstrEnv = IdEnv ConValue data ConValue = CV AltCon [CoreArg] -- Variables known to be bound to a constructor @@ -241,24 +427,18 @@ data ConValue = CV AltCon [CoreArg] instance Outputable ConValue where ppr (CV con args) = ppr con <+> interpp'SP args -refineConstrEnv :: Subst -> ConstrEnv -> ConstrEnv --- The substitution is a type substitution only -refineConstrEnv subst env = mapVarEnv refine_con_value env - where - refine_con_value (CV con args) = CV con (map (substExpr subst) args) - emptyScEnv = SCE { scope = emptyVarEnv, cons = emptyVarEnv } -data HowBound = RecFun -- These are the recursive functions for which - -- we seek interesting call patterns +data HowBound = RecFun -- These are the recursive functions for which + -- we seek interesting call patterns - | RecArg -- These are those functions' arguments; we are - -- interested to see if those arguments are scrutinised + | RecArg -- These are those functions' arguments, or their sub-components; + -- we gather occurrence information for these - | Other -- We track all others so we know what's in scope - -- This is used in spec_one to check what needs to be - -- passed as a parameter and what is in scope at the - -- function definition site + | Other -- We track all others so we know what's in scope + -- This is used in spec_one to check what needs to be + -- passed as a parameter and what is in scope at the + -- function definition site instance Outputable HowBound where ppr RecFun = text "RecFun" @@ -275,52 +455,39 @@ extendBndr env bndr = env { scope = extendVarEnv (scope env) bndr Other } -- C x y -> ... -- we want to bind b, and perhaps scrut too, to (C x y) extendCaseBndrs :: ScEnv -> Id -> CoreExpr -> AltCon -> [Var] -> ScEnv -extendCaseBndrs env case_bndr scrut DEFAULT alt_bndrs - = extendBndrs env (case_bndr : alt_bndrs) - -extendCaseBndrs env case_bndr scrut con@(LitAlt lit) alt_bndrs - = ASSERT( null alt_bndrs ) extendAlt env case_bndr scrut (CV con []) [] - -extendCaseBndrs env case_bndr scrut con@(DataAlt data_con) alt_bndrs - | isVanillaDataCon data_con - = extendAlt env case_bndr scrut (CV con vanilla_args) alt_bndrs - - | otherwise -- GADT - = extendAlt env1 case_bndr scrut (CV con gadt_args) alt_bndrs +extendCaseBndrs env case_bndr scrut con alt_bndrs + = case con of + DEFAULT -> env1 + LitAlt lit -> extendCons env1 scrut case_bndr (CV con []) + DataAlt dc -> extend_data_con dc where - vanilla_args = map Type (tyConAppArgs (idType case_bndr)) ++ - map varToCoreExpr alt_bndrs - - gadt_args = map (substExpr subst . varToCoreExpr) alt_bndrs - -- This call generates some bogus warnings from substExpr, - -- because it's inconvenient to put all the Ids in scope - -- Will be fixed when we move to FC - - (alt_tvs, _) = span isTyVar alt_bndrs - Just (tv_subst, is_local) = coreRefineTys data_con alt_tvs (idType case_bndr) - subst = mkSubst in_scope tv_subst emptyVarEnv -- No Id substitition - in_scope = mkInScopeSet (tyVarsOfTypes (varEnvElts tv_subst)) - - env1 | is_local = env - | otherwise = env { cons = refineConstrEnv subst (cons env) } - - - -extendAlt :: ScEnv -> Id -> CoreExpr -> ConValue -> [Var] -> ScEnv -extendAlt env case_bndr scrut val alt_bndrs - = let - env1 = SCE { scope = extendVarEnvList (scope env) [(b,Other) | b <- case_bndr : alt_bndrs], - cons = extendVarEnv (cons env) case_bndr val } - in - case scrut of - Var v -> -- Bind the scrutinee in the ConstrEnv if it's a variable - -- Also forget if the scrutinee is a RecArg, because we're - -- now in the branch of a case, and we don't want to - -- record a non-scrutinee use of v if we have - -- case v of { (a,b) -> ...(f v)... } - SCE { scope = extendVarEnv (scope env1) v Other, - cons = extendVarEnv (cons env1) v val } - other -> env1 + cur_scope = scope env + env1 = env { scope = extendVarEnvList cur_scope + [(b,how_bound) | b <- case_bndr:alt_bndrs] } + + -- Record RecArg for the components iff the scrutinee is RecArg + -- [This comment looks plain wrong to me, so I'm ignoring it + -- "Also forget if the scrutinee is a RecArg, because we're + -- now in the branch of a case, and we don't want to + -- record a non-scrutinee use of v if we have + -- case v of { (a,b) -> ...(f v)... }" ] + how_bound = case scrut of + Var v -> lookupVarEnv cur_scope v `orElse` Other + other -> Other + + extend_data_con data_con = + extendCons env1 scrut case_bndr (CV con vanilla_args) + where + vanilla_args = map Type (tyConAppArgs (idType case_bndr)) ++ + varsToCoreExprs alt_bndrs + +extendCons :: ScEnv -> CoreExpr -> Id -> ConValue -> ScEnv +extendCons env scrut case_bndr val + = case scrut of + Var v -> env { cons = extendVarEnv cons1 v val } + other -> env { cons = cons1 } + where + cons1 = extendVarEnv (cons env) case_bndr val -- When we encounter a recursive function binding -- f = \x y -> ... @@ -361,18 +528,67 @@ combineUsage u1 u2 = SCU { calls = plusVarEnv_C (++) (calls u1) (calls u2), combineUsages [] = nullUsage combineUsages us = foldr1 combineUsage us -data ArgOcc = CaseScrut - | OtherOcc - | Both +lookupOcc :: ScUsage -> Var -> (ScUsage, ArgOcc) +lookupOcc (SCU { calls = sc_calls, occs = sc_occs }) bndr + = (SCU {calls = sc_calls, occs = delVarEnv sc_occs bndr}, + lookupVarEnv sc_occs bndr `orElse` NoOcc) + +lookupOccs :: ScUsage -> [Var] -> (ScUsage, [ArgOcc]) +lookupOccs (SCU { calls = sc_calls, occs = sc_occs }) bndrs + = (SCU {calls = sc_calls, occs = delVarEnvList sc_occs bndrs}, + [lookupVarEnv sc_occs b `orElse` NoOcc | b <- bndrs]) + +data ArgOcc = NoOcc -- Doesn't occur at all; or a type argument + | UnkOcc -- Used in some unknown way + + | ScrutOcc (UniqFM [ArgOcc]) -- See Note [ScrutOcc] + + | BothOcc -- Definitely taken apart, *and* perhaps used in some other way + +{- Note [ScrutOcc] + +An occurrence of ScrutOcc indicates that the thing is *only* taken apart or applied. + + Functions, litersl: ScrutOcc emptyUFM + Data constructors: ScrutOcc subs, + +where (subs :: UniqFM [ArgOcc]) gives usage of the *pattern-bound* components, +The domain of the UniqFM is the Unique of the data constructor + +The [ArgOcc] is the occurrences of the *pattern-bound* components +of the data structure. E.g. + data T a = forall b. MkT a b (b->a) +A pattern binds b, x::a, y::b, z::b->a, but not 'a'! + +-} instance Outputable ArgOcc where - ppr CaseScrut = ptext SLIT("case-scrut") - ppr OtherOcc = ptext SLIT("other-occ") - ppr Both = ptext SLIT("case-scrut and other") + ppr (ScrutOcc xs) = ptext SLIT("scrut-occ") <> parens (ppr xs) + ppr UnkOcc = ptext SLIT("unk-occ") + ppr BothOcc = ptext SLIT("both-occ") + ppr NoOcc = ptext SLIT("no-occ") + +combineOcc NoOcc occ = occ +combineOcc occ NoOcc = occ +combineOcc (ScrutOcc xs) (ScrutOcc ys) = ScrutOcc (plusUFM_C combineOccs xs ys) +combineOcc UnkOcc UnkOcc = UnkOcc +combineOcc _ _ = BothOcc + +combineOccs :: [ArgOcc] -> [ArgOcc] -> [ArgOcc] +combineOccs xs ys = zipWithEqual "combineOccs" combineOcc xs ys + +conArgOccs :: ArgOcc -> AltCon -> [ArgOcc] +-- Find usage of components of data con; returns [UnkOcc...] if unknown +-- See Note [ScrutOcc] for the extra UnkOccs in the vanilla datacon case + +conArgOccs (ScrutOcc fm) (DataAlt dc) + | Just pat_arg_occs <- lookupUFM fm dc + = tyvar_unks ++ pat_arg_occs + where + tyvar_unks | isVanillaDataCon dc = [UnkOcc | tv <- dataConUnivTyVars dc] + | otherwise = [] -combineOcc CaseScrut CaseScrut = CaseScrut -combineOcc OtherOcc OtherOcc = OtherOcc -combineOcc _ _ = Both +conArgOccs other con = repeat UnkOcc \end{code} @@ -392,25 +608,33 @@ scExpr :: ScEnv -> CoreExpr -> UniqSM (ScUsage, CoreExpr) scExpr env e@(Type t) = returnUs (nullUsage, e) scExpr env e@(Lit l) = returnUs (nullUsage, e) -scExpr env e@(Var v) = returnUs (varUsage env v OtherOcc, e) +scExpr env e@(Var v) = returnUs (varUsage env v UnkOcc, e) scExpr env (Note n e) = scExpr env e `thenUs` \ (usg,e') -> returnUs (usg, Note n e') +scExpr env (Cast e co)= scExpr env e `thenUs` \ (usg,e') -> + returnUs (usg, Cast e' co) scExpr env (Lam b e) = scExpr (extendBndr env b) e `thenUs` \ (usg,e') -> returnUs (usg, Lam b e') scExpr env (Case scrut b ty alts) - = sc_scrut scrut `thenUs` \ (scrut_usg, scrut') -> - mapAndUnzipUs sc_alt alts `thenUs` \ (alts_usgs, alts') -> - returnUs (combineUsages alts_usgs `combineUsage` scrut_usg, - Case scrut' b ty alts') + = do { (alt_usgs, alt_occs, alts') <- mapAndUnzip3Us sc_alt alts + ; let (alt_usg, b_occ) = lookupOcc (combineUsages alt_usgs) b + scrut_occ = foldr combineOcc b_occ alt_occs + -- The combined usage of the scrutinee is given + -- by scrut_occ, which is passed to scScrut, which + -- in turn treats a bare-variable scrutinee specially + ; (scrut_usg, scrut') <- scScrut env scrut scrut_occ + ; return (alt_usg `combineUsage` scrut_usg, + Case scrut' b ty alts') } where - sc_scrut e@(Var v) = returnUs (varUsage env v CaseScrut, e) - sc_scrut e = scExpr env e - - sc_alt (con,bs,rhs) = scExpr env1 rhs `thenUs` \ (usg,rhs') -> - returnUs (usg, (con,bs,rhs')) - where - env1 = extendCaseBndrs env b scrut con bs + sc_alt (con,bs,rhs) + = do { let env1 = extendCaseBndrs env b scrut con bs + ; (usg,rhs') <- scExpr env1 rhs + ; let (usg', arg_occs) = lookupOccs usg bs + scrut_occ = case con of + DataAlt dc -> ScrutOcc (unitUFM dc arg_occs) + other -> ScrutOcc emptyUFM + ; return (usg', scrut_occ, (con,bs,rhs')) } scExpr env (Let bind body) = scBind env bind `thenUs` \ (env', bind_usg, bind') -> @@ -418,22 +642,33 @@ scExpr env (Let bind body) returnUs (bind_usg `combineUsage` body_usg, Let bind' body') scExpr env e@(App _ _) - = let - (fn, args) = collectArgs e - in - mapAndUnzipUs (scExpr env) (fn:args) `thenUs` \ (usgs, (fn':args')) -> + = do { let (fn, args) = collectArgs e + ; (fn_usg, fn') <- scScrut env fn (ScrutOcc emptyUFM) -- Process the function too. It's almost always a variable, -- but not always. In particular, if this pass follows float-in, -- which it may, we can get -- (let f = ...f... in f) arg1 arg2 - let - call_usg = case fn of - Var f | Just RecFun <- lookupScopeEnv env f - -> SCU { calls = unitVarEnv f [(cons env, args)], - occs = emptyVarEnv } - other -> nullUsage - in - returnUs (combineUsages usgs `combineUsage` call_usg, mkApps fn' args') + -- We use scScrut to record the fact that the function is called + -- Perhpas we should check that it has at least one value arg, + -- but currently we don't bother + + ; (arg_usgs, args') <- mapAndUnzipUs (scExpr env) args + ; let call_usg = case fn of + Var f | Just RecFun <- lookupScopeEnv env f + -> SCU { calls = unitVarEnv f [(cons env, args)], + occs = emptyVarEnv } + other -> nullUsage + ; return (combineUsages arg_usgs `combineUsage` fn_usg + `combineUsage` call_usg, + mkApps fn' args') } + + +---------------------- +scScrut :: ScEnv -> CoreExpr -> ArgOcc -> UniqSM (ScUsage, CoreExpr) +-- Used for the scrutinee of a case, +-- or the function of an application +scScrut env e@(Var v) occ = returnUs (varUsage env v occ, e) +scScrut env e occ = scExpr env e ---------------------- @@ -441,7 +676,10 @@ scBind :: ScEnv -> CoreBind -> UniqSM (ScEnv, ScUsage, CoreBind) scBind env (Rec [(fn,rhs)]) | notNull val_bndrs = scExpr env_fn_body body `thenUs` \ (usg, body') -> - specialise env fn bndrs body usg `thenUs` \ (rules, spec_prs) -> + specialise env fn bndrs body' usg `thenUs` \ (rules, spec_prs) -> + -- Note body': the specialised copies should be based on the + -- optimised version of the body, in case there were + -- nested functions inside. let SCU { calls = calls, occs = occs } = usg in @@ -488,48 +726,50 @@ specialise :: ScEnv -> UniqSM ([CoreRule], -- Rules [(Id,CoreExpr)]) -- Bindings -specialise env fn bndrs body (SCU {calls=calls, occs=occs}) - = getUs `thenUs` \ us -> - let - all_calls = lookupVarEnv calls fn `orElse` [] - - good_calls :: [[CoreArg]] - good_calls = [ pats - | (con_env, call_args) <- all_calls, - call_args `lengthAtLeast` n_bndrs, -- App is saturated - let call = bndrs `zip` call_args, - any (good_arg con_env occs) call, -- At least one arg is a constr app - let (_, pats) = argsToPats con_env us call_args - ] - in - mapAndUnzipUs (spec_one env fn (mkLams bndrs body)) - (nubBy same_call good_calls `zip` [1..]) - where - n_bndrs = length bndrs - same_call as1 as2 = and (zipWith tcEqExpr as1 as2) +specialise env fn bndrs body body_usg + = do { let (_, bndr_occs) = lookupOccs body_usg bndrs ---------------------- -good_arg :: ConstrEnv -> IdEnv ArgOcc -> (CoreBndr, CoreArg) -> Bool -good_arg con_env arg_occs (bndr, arg) - = case is_con_app_maybe con_env arg of - Just _ -> bndr_usg_ok arg_occs bndr arg - other -> False - -bndr_usg_ok :: IdEnv ArgOcc -> Var -> CoreArg -> Bool -bndr_usg_ok arg_occs bndr arg - = case lookupVarEnv arg_occs bndr of - Just CaseScrut -> True -- Used only by case scrutiny - Just Both -> case arg of -- Used by case and elsewhere - App _ _ -> True -- so the arg should be an explicit con app - other -> False - other -> False -- Not used, or used wonkily - + ; mb_calls <- mapM (callToPats (scope env) bndr_occs) + (lookupVarEnv (calls body_usg) fn `orElse` []) + + ; let good_calls :: [([Var], [CoreArg])] + good_calls = catMaybes mb_calls + in_scope = mkInScopeSet $ unionVarSets $ + [ exprsFreeVars pats `delVarSetList` vs + | (vs,pats) <- good_calls ] + uniq_calls = nubBy (same_call in_scope) good_calls + ; mapAndUnzipUs (spec_one env fn (mkLams bndrs body)) + (uniq_calls `zip` [1..]) } + where + -- Two calls are the same if they match both ways + same_call in_scope (vs1,as1)(vs2,as2) + = isJust (matchN in_scope vs1 as1 as2) + && isJust (matchN in_scope vs2 as2 as1) + +callToPats :: InScopeEnv -> [ArgOcc] -> Call + -> UniqSM (Maybe ([Var], [CoreExpr])) + -- The VarSet is the variables to quantify over in the rule + -- The [CoreExpr] are the argument patterns for the rule +callToPats in_scope bndr_occs (con_env, args) + | length args < length bndr_occs -- Check saturated + = return Nothing + | otherwise + = do { prs <- argsToPats in_scope con_env (args `zip` bndr_occs) + ; let (good_pats, pats) = unzip prs + pat_fvs = varSetElems (exprsFreeVars pats) + qvars = filter (not . (`elemVarEnv` in_scope)) pat_fvs + -- Quantify over variables that are not in sccpe + -- See Note [Shadowing] at the top + + ; if or good_pats + then return (Just (qvars, pats)) + else return Nothing } --------------------- spec_one :: ScEnv -> Id -- Function -> CoreExpr -- Rhs of the original function - -> ([CoreArg], Int) + -> (([Var], [CoreArg]), Int) -> UniqSM (CoreRule, (Id,CoreExpr)) -- Rule and binding -- spec_one creates a specialised copy of the function, together @@ -553,17 +793,13 @@ spec_one :: ScEnv f (b,c) ((:) (a,(b,c)) (x,v) hw) = f_spec b c v hw -} -spec_one env fn rhs (pats, rule_number) +spec_one env fn rhs ((vars_to_bind, pats), rule_number) = getUniqueUs `thenUs` \ spec_uniq -> let fn_name = idName fn fn_loc = nameSrcLoc fn_name spec_occ = mkSpecOcc (nameOccName fn_name) - pat_fvs = varSetElems (exprsFreeVars pats) - vars_to_bind = filter not_avail pat_fvs - -- See Note [Shadowing] at the top - not_avail v = not (v `elemVarEnv` scope env) -- Put the type variables first; the type of a term -- variable may mention a type variable (tvs, ids) = partition isTyVar vars_to_bind @@ -604,6 +840,7 @@ specConstrActivation = ActiveAfter 0 -- Baked in; see comments above This code deals with analysing call-site arguments to see whether they are constructor applications. + \begin{code} -- argToPat takes an actual argument, and returns an abstracted -- version, consisting of just the "constructor skeleton" of the @@ -611,27 +848,78 @@ they are constructor applications. -- placeholder variables. For example: -- C a (D (f x) (g y)) ==> C p1 (D p2 p3) -argToPat :: ConstrEnv -> UniqSupply -> CoreArg -> (UniqSupply, CoreExpr) -argToPat env us (Type ty) - = (us, Type ty) - -argToPat env us arg - | Just (CV dc args) <- is_con_app_maybe env arg - = let - (us',args') = argsToPats env us args - in - (us', mk_con_app dc args') - -argToPat env us (Var v) -- Don't uniqify existing vars, - = (us, Var v) -- so that we can spot when we pass them twice - -argToPat env us arg - = (us1, Var (mkSysLocal FSLIT("sc") (uniqFromSupply us2) (exprType arg))) +argToPat :: InScopeEnv -- What's in scope at the fn defn site + -> ConstrEnv -- ConstrEnv at the call site + -> CoreArg -- A call arg (or component thereof) + -> ArgOcc + -> UniqSM (Bool, CoreArg) +-- Returns (interesting, pat), +-- where pat is the pattern derived from the argument +-- intersting=True if the pattern is non-trivial (not a variable or type) +-- E.g. x:xs --> (True, x:xs) +-- f xs --> (False, w) where w is a fresh wildcard +-- (f xs, 'c') --> (True, (w, 'c')) where w is a fresh wildcard +-- \x. x+y --> (True, \x. x+y) +-- lvl7 --> (True, lvl7) if lvl7 is bound +-- somewhere further out + +argToPat in_scope con_env arg@(Type ty) arg_occ + = return (False, arg) + +argToPat in_scope con_env (Var v) arg_occ + | not (isLocalId v) || v `elemVarEnv` in_scope + = -- The recursive call passes a variable that + -- is in scope at the function definition site + -- It's worth specialising on this if + -- (a) it's used in an interesting way in the body + -- (b) we know what its value is + if (case arg_occ of { UnkOcc -> False; other -> True }) -- (a) + && isValueUnfolding (idUnfolding v) -- (b) + then return (True, Var v) + else wildCardPat (idType v) + +argToPat in_scope con_env arg arg_occ + | is_value_lam arg + = return (True, arg) where - (us1,us2) = splitUniqSupply us - -argsToPats :: ConstrEnv -> UniqSupply -> [CoreArg] -> (UniqSupply, [CoreExpr]) -argsToPats env us args = mapAccumL (argToPat env) us args + is_value_lam (Lam v e) -- Spot a value lambda, even if + | isId v = True -- it is inside a type lambda + | otherwise = is_value_lam e + is_value_lam other = False + +argToPat in_scope con_env arg arg_occ + | Just (CV dc args) <- is_con_app_maybe con_env arg + , case arg_occ of + ScrutOcc _ -> True -- Used only by case scrutinee + BothOcc -> case arg of -- Used by case scrut + App {} -> True -- ...and elsewhere... + other -> False + other -> False -- No point; the arg is not decomposed + = do { args' <- argsToPats in_scope con_env (args `zip` conArgOccs arg_occ dc) + ; return (True, mk_con_app dc (map snd args')) } + +argToPat in_scope con_env (Var v) arg_occ + = -- A variable bound inside the function. + -- Don't make a wild-card, because we may usefully share + -- e.g. f a = let x = ... in f (x,x) + -- NB: this case follows the lambda and con-app cases!! + return (False, Var v) + +-- The default case: make a wild-card +argToPat in_scope con_env arg arg_occ = wildCardPat (exprType arg) + +wildCardPat :: Type -> UniqSM (Bool, CoreArg) +wildCardPat ty = do { uniq <- getUniqueUs + ; let id = mkSysLocal FSLIT("sc") uniq ty + ; return (False, Var id) } + +argsToPats :: InScopeEnv -> ConstrEnv + -> [(CoreArg, ArgOcc)] + -> UniqSM [(Bool, CoreArg)] +argsToPats in_scope con_env args + = mapUs do_one args + where + do_one (arg,occ) = argToPat in_scope con_env arg occ \end{code} @@ -648,8 +936,8 @@ is_con_app_maybe env (Var v) -> is_con_app_maybe env (unfoldingTemplate unf) where unf = idUnfolding v - -- However we do want to consult the unfolding as well, - -- for let-bound constructors! + -- However we do want to consult the unfolding + -- as well, for let-bound constructors! other -> Nothing @@ -668,4 +956,5 @@ is_con_app_maybe env expr mk_con_app :: AltCon -> [CoreArg] -> CoreExpr mk_con_app (LitAlt lit) [] = Lit lit mk_con_app (DataAlt con) args = mkConApp con args +mk_con_app other args = panic "SpecConstr.mk_con_app" \end{code}