X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Fspecialise%2FSpecConstr.lhs;h=78d173140047e3369350d0e540c2e6e3960702e0;hb=79326edf58637add0e0913189365ccca72c7f82b;hp=9b7d2469bdbbf4abcd581822bd558c7bbbd38a80;hpb=c17dc70a1fbc9f376b5eab05b6a77c4af1aa7623;p=ghc-hetmet.git diff --git a/compiler/specialise/SpecConstr.lhs b/compiler/specialise/SpecConstr.lhs index 9b7d246..78d1731 100644 --- a/compiler/specialise/SpecConstr.lhs +++ b/compiler/specialise/SpecConstr.lhs @@ -14,14 +14,12 @@ import CoreSyn import CoreLint ( showPass, endPass ) 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 DataCon ( dataConRepArity, dataConUnivTyVars ) +import Type ( Type, tyConAppArgs ) import Rules ( matchN ) -import Unify ( coreRefineTys ) import Id ( Id, idName, idType, isDataConWorkId_maybe, mkUserLocal, mkSysLocal, idUnfolding, isLocalId ) import Var ( Var ) @@ -429,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" @@ -463,51 +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 -> ... @@ -561,17 +541,29 @@ lookupOccs (SCU { calls = sc_calls, occs = sc_occs }) bndrs data ArgOcc = NoOcc -- Doesn't occur at all; or a type argument | UnkOcc -- Used in some unknown way - | ScrutOcc (UniqFM [ArgOcc]) -- Only taken apart or applied - -- ScrutOcc emptyUFM for functions, literals - -- ScrutOcc subs for data constructors; - -- the [ArgOcc] gives usage of the *value* components, - -- The domain of the UniqFM is the Unique of the data constructor + | 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 (ScrutOcc xs) = ptext SLIT("scrut-occ") <+> ppr xs + 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") @@ -585,10 +577,18 @@ combineOcc _ _ = BothOcc combineOccs :: [ArgOcc] -> [ArgOcc] -> [ArgOcc] combineOccs xs ys = zipWithEqual "combineOccs" combineOcc xs ys -subOccs :: ArgOcc -> AltCon -> [ArgOcc] +conArgOccs :: ArgOcc -> AltCon -> [ArgOcc] -- Find usage of components of data con; returns [UnkOcc...] if unknown -subOccs (ScrutOcc fm) (DataAlt dc) = lookupUFM fm dc `orElse` repeat UnkOcc -subOccs other dc = repeat UnkOcc +-- 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 = [] + +conArgOccs other con = repeat UnkOcc \end{code} @@ -611,6 +611,8 @@ scExpr env e@(Lit l) = returnUs (nullUsage, 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') @@ -736,9 +738,8 @@ specialise env fn bndrs body body_usg [ exprsFreeVars pats `delVarSetList` vs | (vs,pats) <- good_calls ] uniq_calls = nubBy (same_call in_scope) good_calls - in - mapAndUnzipUs (spec_one env fn (mkLams bndrs body)) - (uniq_calls `zip` [1..]) } + ; 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) @@ -839,23 +840,6 @@ specConstrActivation = ActiveAfter 0 -- Baked in; see comments above This code deals with analysing call-site arguments to see whether they are constructor applications. ---------------------- -good_arg :: ConstrEnv -> IdEnv ArgOcc -> (CoreBndr, CoreArg) -> Bool --- See Note [Good arguments] above -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 ScrutOcc -> 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 - \begin{code} -- argToPat takes an actual argument, and returns an abstracted @@ -882,10 +866,17 @@ argToPat :: InScopeEnv -- What's in scope at the fn defn site argToPat in_scope con_env arg@(Type ty) arg_occ = return (False, arg) -argToPat in_scope con_env (Var v) arg_occ -- Don't uniqify existing vars, - = return (interesting, Var v) -- so that we can spot when we pass them twice - where - interesting = not (isLocalId v) || v `elemVarEnv` in_scope +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 @@ -904,13 +895,23 @@ argToPat in_scope con_env arg arg_occ App {} -> True -- ...and elsewhere... other -> False other -> False -- No point; the arg is not decomposed - = do { args' <- argsToPats in_scope con_env (args `zip` subOccs arg_occ dc) + = 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 arg arg_occ - = do { uniq <- getUniqueUs - ; let id = mkSysLocal FSLIT("sc") uniq (exprType arg) - ; return (False, Var id) } +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)] @@ -955,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}