import CoreSubst
import CoreUtils
import CoreUnfold ( couldBeSmallEnoughToInline )
-import CoreLint ( showPass, endPass )
import CoreFVs ( exprsFreeVars )
-import CoreTidy ( tidyRules )
-import PprCore ( pprRules )
import WwLib ( mkWorkerArgs )
import DataCon ( dataConRepArity, dataConUnivTyVars )
import Coercion
+import Rules
import Type hiding( substTy )
-import Id ( Id, idName, idType, isDataConWorkId_maybe, idArity,
- mkUserLocal, mkSysLocal, idUnfolding, isLocalId )
+import Id
import Var
import VarEnv
import VarSet
import Name
-import Rules ( addIdSpecialisations, mkLocalRule, rulesOfBinds )
import OccName ( mkSpecOcc )
-import ErrUtils ( dumpIfSet_dyn )
-import DynFlags ( DynFlags(..), DynFlag(..) )
+import DynFlags ( DynFlags(..) )
+import StaticFlags ( opt_PprStyle_Debug )
import StaticFlags ( opt_SpecInlineJoinPoints )
import BasicTypes ( Activation(..) )
import Maybes ( orElse, catMaybes, isJust, isNothing )
%************************************************************************
\begin{code}
-specConstrProgram :: DynFlags -> UniqSupply -> [CoreBind] -> IO [CoreBind]
-specConstrProgram dflags us binds
- = do
- showPass dflags "SpecConstr"
-
- let (binds', _) = initUs us (go (initScEnv dflags) binds)
-
- endPass dflags "SpecConstr" Opt_D_dump_spec binds'
-
- dumpIfSet_dyn dflags Opt_D_dump_rules "Top-level specialisations"
- (pprRules (tidyRules emptyTidyEnv (rulesOfBinds binds')))
-
- return binds'
+specConstrProgram :: DynFlags -> UniqSupply -> [CoreBind] -> [CoreBind]
+specConstrProgram dflags us binds = fst $ initUs us (go (initScEnv dflags) binds)
where
go _ [] = return []
go env (bind:binds) = do (env', bind') <- scTopBind env bind
---------------------
-- As we go, we apply a substitution (sc_subst) to the current term
-type InExpr = CoreExpr -- *Before* applying the subst
+type InExpr = CoreExpr -- _Before_ applying the subst
-type OutExpr = CoreExpr -- *After* applying the subst
+type OutExpr = CoreExpr -- _After_ applying the subst
type OutId = Id
type OutVar = Var
---------------------
type ValueEnv = IdEnv Value -- Domain is OutIds
-data Value = ConVal AltCon [CoreArg] -- *Saturated* constructors
+data Value = ConVal AltCon [CoreArg] -- _Saturated_ constructors
| LambdaVal -- Inlinable lambdas or PAPs
instance Outputable Value where
ppr (ConVal con args) = ppr con <+> interpp'SP args
- ppr LambdaVal = ptext SLIT("<Lambda>")
+ ppr LambdaVal = ptext (sLit "<Lambda>")
---------------------
initScEnv :: DynFlags -> ScEnv
extendValEnv env _ Nothing = env
extendValEnv env id (Just cv) = env { sc_vals = extendVarEnv (sc_vals env) id cv }
-extendCaseBndrs :: ScEnv -> CoreExpr -> Id -> AltCon -> [Var] -> ScEnv
+extendCaseBndrs :: ScEnv -> Id -> AltCon -> [Var] -> (ScEnv, [Var])
-- When we encounter
-- case scrut of b
-- C x y -> ...
--- we want to bind b, and perhaps scrut too, to (C x y)
--- NB: Extends only the sc_vals part of the envt
-extendCaseBndrs env scrut case_bndr con alt_bndrs
- = case scrut of
- Var v -> extendValEnv env1 v cval
- _other -> env1
+-- we want to bind b, to (C x y)
+-- NB1: Extends only the sc_vals part of the envt
+-- NB2: Kill the dead-ness info on the pattern binders x,y, since
+-- they are potentially made alive by the [b -> C x y] binding
+extendCaseBndrs env case_bndr con alt_bndrs
+ | isDeadBinder case_bndr
+ = (env, alt_bndrs)
+ | otherwise
+ = (env1, map zap alt_bndrs)
+ -- NB: We used to bind v too, if scrut = (Var v); but
+ -- the simplifer has already done this so it seems
+ -- redundant to do so here
+ -- case scrut of
+ -- Var v -> extendValEnv env1 v cval
+ -- _other -> env1
where
+ zap v | isTyVar v = v -- See NB2 above
+ | otherwise = zapIdOccInfo v
env1 = extendValEnv env case_bndr cval
cval = case con of
DEFAULT -> Nothing
-}
instance Outputable ArgOcc where
- ppr (ScrutOcc xs) = ptext SLIT("scrut-occ") <> ppr xs
- ppr UnkOcc = ptext SLIT("unk-occ")
- ppr BothOcc = ptext SLIT("both-occ")
- ppr NoOcc = ptext SLIT("no-occ")
+ ppr (ScrutOcc xs) = ptext (sLit "scrut-occ") <> ppr xs
+ ppr UnkOcc = ptext (sLit "unk-occ")
+ ppr BothOcc = ptext (sLit "both-occ")
+ ppr NoOcc = ptext (sLit "no-occ")
-- Experimentally, this vesion of combineOcc makes ScrutOcc "win", so
-- that if the thing is scrutinised anywhere then we get to see that
combineOccs xs ys = zipWithEqual "combineOccs" combineOcc xs ys
setScrutOcc :: ScEnv -> ScUsage -> OutExpr -> ArgOcc -> ScUsage
--- *Overwrite* the occurrence info for the scrutinee, if the scrutinee
+-- _Overwrite_ the occurrence info for the scrutinee, if the scrutinee
-- is a variable, and an interesting variable
setScrutOcc env usg (Cast e _) occ = setScrutOcc env usg e occ
setScrutOcc env usg (Note _ e) occ = setScrutOcc env usg e occ
; return (alt_usg `combineUsage` scrut_usg',
Case scrut' b' (scSubstTy env ty) alts') }
- sc_alt env scrut' b' (con,bs,rhs)
- = do { let (env1, bs') = extendBndrsWith RecArg env bs
- env2 = extendCaseBndrs env1 scrut' b' con bs'
+ sc_alt env _scrut' b' (con,bs,rhs)
+ = do { let (env1, bs1) = extendBndrsWith RecArg env bs
+ (env2, bs2) = extendCaseBndrs env1 b' con bs1
; (usg,rhs') <- scExpr env2 rhs
- ; let (usg', arg_occs) = lookupOccs usg bs'
+ ; let (usg', arg_occs) = lookupOccs usg bs2
scrut_occ = case con of
DataAlt dc -> ScrutOcc (unitUFM dc arg_occs)
- _ofther -> ScrutOcc emptyUFM
- ; return (usg', scrut_occ, (con,bs',rhs')) }
+ _ -> ScrutOcc emptyUFM
+ ; return (usg', scrut_occ, (con, bs2, rhs')) }
scExpr' env (Let (NonRec bndr rhs) body)
| isTyVar bndr -- Type-lets may be created by doBeta
; let spec_count' = length pats + spec_count
; case sc_count env of
Just max | spec_count' > max
- -> pprTrace "SpecConstr: too many specialisations for one function (see -fspec-constr-count):"
- (vcat [ptext SLIT("Function:") <+> ppr fn,
- ptext SLIT("Specialisations:") <+> ppr (pats ++ [p | OS p _ _ _ <- specs])])
- return (nullUsage, spec_info)
+ -> WARN( True, msg ) return (nullUsage, spec_info)
+ where
+ msg = vcat [ sep [ ptext (sLit "SpecConstr: specialisation of") <+> quotes (ppr fn)
+ , nest 2 (ptext (sLit "limited by bound of")) <+> int max ]
+ , ptext (sLit "Use -fspec-constr-count=n to set the bound")
+ , extra ]
+ extra | not opt_PprStyle_Debug = ptext (sLit "Use -dppr-debug to see specialisations")
+ | otherwise = ptext (sLit "Specialisations:") <+> ppr (pats ++ [p | OS p _ _ _ <- specs])
- _normal_case -> do
-
- { (spec_usgs, new_specs) <- mapAndUnzipM (spec_one env fn arg_bndrs body)
+ _normal_case -> do {
+
+ (spec_usgs, new_specs) <- mapAndUnzipM (spec_one env fn arg_bndrs body)
(pats `zip` [spec_count..])
; let spec_usg = combineUsages spec_usgs
else do
{ -- Make a wild-card pattern for the coercion
uniq <- getUniqueUs
- ; let co_name = mkSysTvName uniq FSLIT("sg")
+ ; let co_name = mkSysTvName uniq (fsLit "sg")
co_var = mkCoVar co_name (mkCoKind ty1 ty2)
; return (interesting, Cast arg' (mkTyVarTy co_var)) } }
wildCardPat :: Type -> UniqSM (Bool, CoreArg)
wildCardPat ty = do { uniq <- getUniqueUs
- ; let id = mkSysLocal FSLIT("sc") uniq ty
+ ; let id = mkSysLocal (fsLit "sc") uniq ty
; return (False, Var id) }
argsToPats :: InScopeSet -> ValueEnv
-- as well, for let-bound constructors!
isValue env (Lam b e)
- | isTyVar b = isValue env e
+ | isTyVar b = case isValue env e of
+ Just _ -> Just LambdaVal
+ Nothing -> Nothing
| otherwise = Just LambdaVal
isValue _env expr -- Maybe it's a constructor application
projects / ghc-hetmet.git / blobdiff