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 VarEnv
import VarSet
import Name
-import Rules ( addIdSpecialisations, mkLocalRule, rulesOfBinds )
import OccName ( mkSpecOcc )
import ErrUtils ( dumpIfSet_dyn )
import DynFlags ( DynFlags(..), DynFlag(..) )
+import StaticFlags ( opt_PprStyle_Debug )
import StaticFlags ( opt_SpecInlineJoinPoints )
import BasicTypes ( Activation(..) )
import Maybes ( orElse, catMaybes, isJust, isNothing )
endPass dflags "SpecConstr" Opt_D_dump_spec binds'
dumpIfSet_dyn dflags Opt_D_dump_rules "Top-level specialisations"
- (pprRules (tidyRules emptyTidyEnv (rulesOfBinds binds')))
+ (pprRulesForUser (rulesOfBinds binds'))
return binds'
where
---------------------
-- 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
-}
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
; let (usg', arg_occs) = lookupOccs usg bs'
scrut_occ = case con of
DataAlt dc -> ScrutOcc (unitUFM dc arg_occs)
- _ofther -> ScrutOcc emptyUFM
+ _ -> ScrutOcc emptyUFM
; return (usg', scrut_occ, (con,bs',rhs')) }
scExpr' env (Let (NonRec bndr rhs) body)
; 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