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, dataConTyVars )
-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 )
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"
-- 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 -> ...
-}
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")
conArgOccs (ScrutOcc fm) (DataAlt dc)
| Just pat_arg_occs <- lookupUFM fm dc
- = tyvar_unks ++ pat_arg_occs
- where
- tyvar_unks | isVanillaDataCon dc = [UnkOcc | tv <- dataConTyVars dc]
- | otherwise = []
+ = [UnkOcc | tv <- dataConUnivTyVars dc] ++ pat_arg_occs
conArgOccs other con = repeat UnkOcc
\end{code}
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')
[ 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)
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
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 (Let _ arg) arg_occ
+ = argToPat in_scope con_env arg arg_occ
+ -- Look through let expressions
+ -- e.g. f (let v = rhs in \y -> ...v...)
+ -- Here we can specialise for f (\y -> ...)
+ -- because the rule-matcher will look through the let.
argToPat in_scope con_env arg arg_occ
| is_value_lam arg
= 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)]
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}
projects / ghc-hetmet.git / blobdiff