-%\r
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998\r
-%\r
-\section[SimplCore]{Driver for simplifying @Core@ programs}\r
-\r
-\begin{code}\r
-module SimplCore ( core2core ) where\r
-\r
-#include "HsVersions.h"\r
-\r
-import CmdLineOpts ( CoreToDo(..), SimplifierSwitch(..), \r
- SwitchResult(..), switchIsOn, intSwitchSet,\r
- opt_D_dump_occur_anal, opt_D_dump_rules,\r
- opt_D_dump_simpl_iterations,\r
- opt_D_dump_simpl_stats,\r
- opt_D_dump_simpl, opt_D_dump_rules,\r
- opt_D_verbose_core2core,\r
- opt_D_dump_occur_anal,\r
- opt_UsageSPOn,\r
- )\r
-import CoreLint ( beginPass, endPass )\r
-import CoreTidy ( tidyCorePgm )\r
-import CoreSyn\r
-import Rules ( RuleBase, ProtoCoreRule(..), pprProtoCoreRule, prepareRuleBase, orphanRule )\r
-import CoreUnfold\r
-import PprCore ( pprCoreBindings )\r
-import OccurAnal ( occurAnalyseBinds )\r
-import CoreUtils ( exprIsTrivial, coreExprType )\r
-import Simplify ( simplTopBinds, simplExpr )\r
-import SimplUtils ( etaCoreExpr, findDefault, simplBinders )\r
-import SimplMonad\r
-import Const ( Con(..), Literal(..), literalType, mkMachInt )\r
-import ErrUtils ( dumpIfSet )\r
-import FloatIn ( floatInwards )\r
-import FloatOut ( floatOutwards )\r
-import Id ( Id, mkSysLocal, mkVanillaId, isBottomingId,\r
- idType, setIdType, idName, idInfo, setIdNoDiscard\r
- )\r
-import VarEnv\r
-import VarSet\r
-import Module ( Module )\r
-import Name ( mkLocalName, tidyOccName, tidyTopName, \r
- NamedThing(..), OccName\r
- )\r
-import TyCon ( TyCon, isDataTyCon )\r
-import PrimOp ( PrimOp(..) )\r
-import PrelInfo ( unpackCStringId, unpackCString2Id, addr2IntegerId )\r
-import Type ( Type, splitAlgTyConApp_maybe, \r
- isUnLiftedType,\r
- tidyType, tidyTypes, tidyTopType, tidyTyVar, tidyTyVars,\r
- Type\r
- )\r
-import TysWiredIn ( smallIntegerDataCon, isIntegerTy )\r
-import LiberateCase ( liberateCase )\r
-import SAT ( doStaticArgs )\r
-import Specialise ( specProgram)\r
-import UsageSPInf ( doUsageSPInf )\r
-import StrictAnal ( saBinds )\r
-import WorkWrap ( wwTopBinds )\r
-import CprAnalyse ( cprAnalyse )\r
-\r
-import Unique ( Unique, Uniquable(..),\r
- ratioTyConKey\r
- )\r
-import UniqSupply ( UniqSupply, mkSplitUniqSupply, splitUniqSupply, uniqFromSupply )\r
-import Constants ( tARGET_MIN_INT, tARGET_MAX_INT )\r
-import Util ( mapAccumL )\r
-import SrcLoc ( noSrcLoc )\r
-import Bag\r
-import Maybes\r
-import IO ( hPutStr, stderr )\r
-import Outputable\r
-\r
-import Ratio ( numerator, denominator )\r
-\end{code}\r
-\r
-%************************************************************************\r
-%* *\r
-\subsection{The driver for the simplifier}\r
-%* *\r
-%************************************************************************\r
-\r
-\begin{code}\r
-core2core :: [CoreToDo] -- Spec of what core-to-core passes to do\r
- -> [CoreBind] -- Binds in\r
- -> [ProtoCoreRule] -- Rules\r
- -> IO ([CoreBind], [ProtoCoreRule])\r
-\r
-core2core core_todos binds rules\r
- = do\r
- us <- mkSplitUniqSupply 's'\r
- let (cp_us, us1) = splitUniqSupply us\r
- (ru_us, ps_us) = splitUniqSupply us1\r
-\r
- better_rules <- simplRules ru_us rules binds\r
-\r
- let (binds1, rule_base) = prepareRuleBase binds better_rules\r
-\r
- -- Do the main business\r
- (stats, processed_binds) <- doCorePasses zeroSimplCount cp_us binds1 \r
- rule_base core_todos\r
-\r
- dumpIfSet opt_D_dump_simpl_stats\r
- "Grand total simplifier statistics"\r
- (pprSimplCount stats)\r
-\r
- -- Do the post-simplification business\r
- post_simpl_binds <- doPostSimplification ps_us processed_binds\r
-\r
- -- Return results\r
- return (post_simpl_binds, filter orphanRule better_rules)\r
- \r
-\r
-doCorePasses stats us binds irs []\r
- = return (stats, binds)\r
-\r
-doCorePasses stats us binds irs (to_do : to_dos) \r
- = do\r
- let (us1, us2) = splitUniqSupply us\r
- (stats1, binds1) <- doCorePass us1 binds irs to_do\r
- doCorePasses (stats `plusSimplCount` stats1) us2 binds1 irs to_dos\r
-\r
-doCorePass us binds rb (CoreDoSimplify sw_chkr) = _scc_ "Simplify" simplifyPgm rb sw_chkr us binds\r
-doCorePass us binds rb CoreLiberateCase = _scc_ "LiberateCase" noStats (liberateCase binds)\r
-doCorePass us binds rb CoreDoFloatInwards = _scc_ "FloatInwards" noStats (floatInwards binds)\r
-doCorePass us binds rb CoreDoFullLaziness = _scc_ "FloatOutwards" noStats (floatOutwards us binds)\r
-doCorePass us binds rb CoreDoStaticArgs = _scc_ "StaticArgs" noStats (doStaticArgs us binds)\r
-doCorePass us binds rb CoreDoStrictness = _scc_ "Stranal" noStats (saBinds binds)\r
-doCorePass us binds rb CoreDoWorkerWrapper = _scc_ "WorkWrap" noStats (wwTopBinds us binds)\r
-doCorePass us binds rb CoreDoSpecialising = _scc_ "Specialise" noStats (specProgram us binds)\r
-doCorePass us binds rb CoreDoCPResult = _scc_ "CPResult" noStats (cprAnalyse binds)\r
-doCorePass us binds rb CoreDoPrintCore = _scc_ "PrintCore" noStats (printCore binds)\r
-doCorePass us binds rb CoreDoUSPInf\r
- = _scc_ "CoreUsageSPInf" \r
- if opt_UsageSPOn then\r
- noStats (doUsageSPInf us binds)\r
- else\r
- trace "WARNING: ignoring requested -fusagesp pass; requires -fusagesp-on" $\r
- noStats (return binds)\r
-\r
-printCore binds = do dumpIfSet True "Print Core"\r
- (pprCoreBindings binds)\r
- return binds\r
-\r
-noStats thing = do { result <- thing; return (zeroSimplCount, result) }\r
-\end{code}\r
-\r
-\r
-%************************************************************************\r
-%* *\r
-\subsection{Dealing with rules}\r
-%* *\r
-%************************************************************************\r
-\r
-We must do some gentle simplifiation on the template (but not the RHS)\r
-of each rule. The case that forced me to add this was the fold/build rule,\r
-which without simplification looked like:\r
- fold k z (build (/\a. g a)) ==> ...\r
-This doesn't match unless you do eta reduction on the build argument.\r
-\r
-\begin{code}\r
-simplRules :: UniqSupply -> [ProtoCoreRule] -> [CoreBind] -> IO [ProtoCoreRule]\r
-simplRules us rules binds\r
- = do let (better_rules,_) = initSmpl sw_chkr us bind_vars black_list_all (mapSmpl simplRule rules)\r
- \r
- dumpIfSet opt_D_dump_rules\r
- "Transformation rules"\r
- (vcat (map pprProtoCoreRule better_rules))\r
-\r
- return better_rules\r
- where\r
- black_list_all v = True -- This stops all inlining\r
- sw_chkr any = SwBool False -- A bit bogus\r
-\r
- -- Boringly, we need to gather the in-scope set.\r
- -- Typically this thunk won't even be force, but the test in\r
- -- simpVar fails if it isn't right, and it might conceivably matter\r
- bind_vars = foldr (unionVarSet . mkVarSet . bindersOf) emptyVarSet binds\r
-\r
-\r
-simplRule rule@(ProtoCoreRule is_local id (Rule name bndrs args rhs))\r
- | not is_local\r
- = returnSmpl rule -- No need to fiddle with imported rules\r
- | otherwise\r
- = simplBinders bndrs $ \ bndrs' -> \r
- mapSmpl simplExpr args `thenSmpl` \ args' ->\r
- simplExpr rhs `thenSmpl` \ rhs' ->\r
- returnSmpl (ProtoCoreRule is_local id (Rule name bndrs' args' rhs'))\r
-\end{code}\r
-\r
-%************************************************************************\r
-%* *\r
-\subsection{The driver for the simplifier}\r
-%* *\r
-%************************************************************************\r
-\r
-\begin{code}\r
-simplifyPgm :: RuleBase\r
- -> (SimplifierSwitch -> SwitchResult)\r
- -> UniqSupply\r
- -> [CoreBind] -- Input\r
- -> IO (SimplCount, [CoreBind]) -- New bindings\r
-\r
-simplifyPgm (imported_rule_ids, rule_lhs_fvs) \r
- sw_chkr us binds\r
- = do {\r
- beginPass "Simplify";\r
-\r
- -- Glom all binds together in one Rec, in case any\r
- -- transformations have introduced any new dependencies\r
- let { recd_binds = [Rec (flattenBinds binds)] };\r
-\r
- (termination_msg, it_count, counts_out, binds') <- iteration us 1 zeroSimplCount recd_binds;\r
-\r
- dumpIfSet (opt_D_verbose_core2core && opt_D_dump_simpl_stats)\r
- "Simplifier statistics"\r
- (vcat [text termination_msg <+> text "after" <+> ppr it_count <+> text "iterations",\r
- text "",\r
- pprSimplCount counts_out]);\r
-\r
- endPass "Simplify" \r
- (opt_D_verbose_core2core && not opt_D_dump_simpl_iterations)\r
- binds' ;\r
-\r
- return (counts_out, binds')\r
- }\r
- where\r
- max_iterations = getSimplIntSwitch sw_chkr MaxSimplifierIterations\r
- black_list_fn = blackListed rule_lhs_fvs (intSwitchSet sw_chkr SimplInlinePhase)\r
-\r
- core_iter_dump binds | opt_D_verbose_core2core = pprCoreBindings binds\r
- | otherwise = empty\r
-\r
- iteration us iteration_no counts binds\r
- = do {\r
- -- Occurrence analysis\r
- let { tagged_binds = _scc_ "OccAnal" occurAnalyseBinds binds } ;\r
-\r
- dumpIfSet opt_D_dump_occur_anal "Occurrence analysis"\r
- (pprCoreBindings tagged_binds);\r
-\r
- -- Simplify\r
- let { (binds', counts') = initSmpl sw_chkr us1 imported_rule_ids \r
- black_list_fn \r
- (simplTopBinds tagged_binds);\r
- all_counts = counts `plusSimplCount` counts'\r
- } ;\r
-\r
- -- Stop if nothing happened; don't dump output\r
- if isZeroSimplCount counts' then\r
- return ("Simplifier reached fixed point", iteration_no, all_counts, binds')\r
- else do {\r
-\r
- -- Dump the result of this iteration\r
- dumpIfSet opt_D_dump_simpl_iterations\r
- ("Simplifier iteration " ++ show iteration_no \r
- ++ " out of " ++ show max_iterations)\r
- (pprSimplCount counts') ;\r
-\r
- if opt_D_dump_simpl_iterations then\r
- endPass ("Simplifier iteration " ++ show iteration_no ++ " result")\r
- opt_D_verbose_core2core\r
- binds'\r
- else\r
- return [] ;\r
-\r
- -- Stop if we've run out of iterations\r
- if iteration_no == max_iterations then\r
- do {\r
- if max_iterations > 2 then\r
- hPutStr stderr ("NOTE: Simplifier still going after " ++ \r
- show max_iterations ++ \r
- " iterations; bailing out.\n")\r
- else return ();\r
-\r
- return ("Simplifier baled out", iteration_no, all_counts, binds')\r
- }\r
-\r
- -- Else loop\r
- else iteration us2 (iteration_no + 1) all_counts binds'\r
- } }\r
- where\r
- (us1, us2) = splitUniqSupply us\r
-\end{code}\r
-\r
-\r
-%************************************************************************\r
-%* *\r
-\subsection{PostSimplification}\r
-%* *\r
-%************************************************************************\r
-\r
-Several tasks are performed by the post-simplification pass\r
-\r
-1. Make the representation of NoRep literals explicit, and\r
- float their bindings to the top level. We only do the floating\r
- part for NoRep lits inside a lambda (else no gain). We need to\r
- take care with let x = "foo" in e\r
- that we don't end up with a silly binding\r
- let x = y in e\r
- with a floated "foo". What a bore.\r
- \r
-4. Do eta reduction for lambda abstractions appearing in:\r
- - the RHS of case alternatives\r
- - the body of a let\r
-\r
- These will otherwise turn into local bindings during Core->STG;\r
- better to nuke them if possible. (In general the simplifier does\r
- eta expansion not eta reduction, up to this point. It does eta\r
- on the RHSs of bindings but not the RHSs of case alternatives and\r
- let bodies)\r
-\r
-\r
-------------------- NOT DONE ANY MORE ------------------------\r
-[March 98] Indirections are now elimianted by the occurrence analyser\r
-1. Eliminate indirections. The point here is to transform\r
- x_local = E\r
- x_exported = x_local\r
- ==>\r
- x_exported = E\r
-\r
-[Dec 98] [Not now done because there is no penalty in the code\r
- generator for using the former form]\r
-2. Convert\r
- case x of {...; x' -> ...x'...}\r
- ==>\r
- case x of {...; _ -> ...x... }\r
- See notes in SimplCase.lhs, near simplDefault for the reasoning here.\r
---------------------------------------------------------------\r
-\r
-Special case\r
-~~~~~~~~~~~~\r
-\r
-NOT ENABLED AT THE MOMENT (because the floated Ids are global-ish\r
-things, and we need local Ids for non-floated stuff):\r
-\r
- Don't float stuff out of a binder that's marked as a bottoming Id.\r
- Reason: it doesn't do any good, and creates more CAFs that increase\r
- the size of SRTs.\r
-\r
-eg.\r
-\r
- f = error "string"\r
-\r
-is translated to\r
-\r
- f' = unpackCString# "string"\r
- f = error f'\r
-\r
-hence f' and f become CAFs. Instead, the special case for\r
-tidyTopBinding below makes sure this comes out as\r
-\r
- f = let f' = unpackCString# "string" in error f'\r
-\r
-and we can safely ignore f as a CAF, since it can only ever be entered once.\r
-\r
-\r
-\r
-\begin{code}\r
-doPostSimplification :: UniqSupply -> [CoreBind] -> IO [CoreBind]\r
-doPostSimplification us binds_in\r
- = do\r
- beginPass "Post-simplification pass"\r
- let binds_out = initPM us (postSimplTopBinds binds_in)\r
- endPass "Post-simplification pass" opt_D_verbose_core2core binds_out\r
-\r
-postSimplTopBinds :: [CoreBind] -> PostM [CoreBind]\r
-postSimplTopBinds binds\r
- = mapPM postSimplTopBind binds `thenPM` \ binds' ->\r
- returnPM (bagToList (unionManyBags binds'))\r
-\r
-postSimplTopBind :: CoreBind -> PostM (Bag CoreBind)\r
-postSimplTopBind (NonRec bndr rhs)\r
- | isBottomingId bndr -- Don't lift out floats for bottoming Ids\r
- -- See notes above\r
- = getFloatsPM (postSimplExpr rhs) `thenPM` \ (rhs', floats) ->\r
- returnPM (unitBag (NonRec bndr (foldrBag Let rhs' floats)))\r
-\r
-postSimplTopBind bind\r
- = getFloatsPM (postSimplBind bind) `thenPM` \ (bind', floats) ->\r
- returnPM (floats `snocBag` bind')\r
-\r
-postSimplBind (NonRec bndr rhs)\r
- = postSimplExpr rhs `thenPM` \ rhs' ->\r
- returnPM (NonRec bndr rhs')\r
-\r
-postSimplBind (Rec pairs)\r
- = mapPM postSimplExpr rhss `thenPM` \ rhss' ->\r
- returnPM (Rec (bndrs `zip` rhss'))\r
- where\r
- (bndrs, rhss) = unzip pairs\r
-\end{code}\r
-\r
-\r
-Expressions\r
-~~~~~~~~~~~\r
-\begin{code}\r
-postSimplExpr (Var v) = returnPM (Var v)\r
-postSimplExpr (Type ty) = returnPM (Type ty)\r
-\r
-postSimplExpr (App fun arg)\r
- = postSimplExpr fun `thenPM` \ fun' ->\r
- postSimplExpr arg `thenPM` \ arg' ->\r
- returnPM (App fun' arg')\r
-\r
-postSimplExpr (Con (Literal lit) args)\r
- = ASSERT( null args )\r
- litToRep lit `thenPM` \ (lit_ty, lit_expr) ->\r
- getInsideLambda `thenPM` \ in_lam ->\r
- if in_lam && not (exprIsTrivial lit_expr) then\r
- -- It must have been a no-rep literal with a\r
- -- non-trivial representation; and we're inside a lambda;\r
- -- so float it to the top\r
- addTopFloat lit_ty lit_expr `thenPM` \ v ->\r
- returnPM (Var v)\r
- else\r
- returnPM lit_expr\r
-\r
-postSimplExpr (Con con args)\r
- = mapPM postSimplExpr args `thenPM` \ args' ->\r
- returnPM (Con con args')\r
-\r
-postSimplExpr (Lam bndr body)\r
- = insideLambda bndr $\r
- postSimplExpr body `thenPM` \ body' ->\r
- returnPM (Lam bndr body')\r
-\r
-postSimplExpr (Let bind body)\r
- = postSimplBind bind `thenPM` \ bind' ->\r
- postSimplExprEta body `thenPM` \ body' ->\r
- returnPM (Let bind' body')\r
-\r
-postSimplExpr (Note note body)\r
- = postSimplExprEta body `thenPM` \ body' ->\r
- returnPM (Note note body')\r
-\r
-postSimplExpr (Case scrut case_bndr alts)\r
- = postSimplExpr scrut `thenPM` \ scrut' ->\r
- mapPM ps_alt alts `thenPM` \ alts' ->\r
- returnPM (Case scrut' case_bndr alts')\r
- where\r
- ps_alt (con,bndrs,rhs) = postSimplExprEta rhs `thenPM` \ rhs' ->\r
- returnPM (con, bndrs, rhs')\r
-\r
-postSimplExprEta e = postSimplExpr e `thenPM` \ e' ->\r
- returnPM (etaCoreExpr e')\r
-\end{code}\r
-\r
-\r
-%************************************************************************\r
-%* *\r
-\subsection[coreToStg-lits]{Converting literals}\r
-%* *\r
-%************************************************************************\r
-\r
-Literals: the NoRep kind need to be de-no-rep'd.\r
-We always replace them with a simple variable, and float a suitable\r
-binding out to the top level.\r
-\r
-\begin{code}\r
-litToRep :: Literal -> PostM (Type, CoreExpr)\r
-\r
-litToRep (NoRepStr s ty)\r
- = returnPM (ty, rhs)\r
- where\r
- rhs = if (any is_NUL (_UNPK_ s))\r
-\r
- then -- Must cater for NULs in literal string\r
- mkApps (Var unpackCString2Id)\r
- [mkLit (MachStr s),\r
- mkLit (mkMachInt (toInteger (_LENGTH_ s)))]\r
-\r
- else -- No NULs in the string\r
- App (Var unpackCStringId) (mkLit (MachStr s))\r
-\r
- is_NUL c = c == '\0'\r
-\end{code}\r
-\r
-If an Integer is small enough (Haskell implementations must support\r
-Ints in the range $[-2^29+1, 2^29-1]$), wrap it up in @int2Integer@;\r
-otherwise, wrap with @addr2Integer@.\r
-\r
-\begin{code}\r
-litToRep (NoRepInteger i integer_ty)\r
- = returnPM (integer_ty, rhs)\r
- where\r
- rhs | i > tARGET_MIN_INT && -- Small enough, so start from an Int\r
- i < tARGET_MAX_INT\r
- = Con (DataCon smallIntegerDataCon) [Con (Literal (mkMachInt i)) []]\r
- \r
- | otherwise -- Big, so start from a string\r
- = App (Var addr2IntegerId) (Con (Literal (MachStr (_PK_ (show i)))) [])\r
-\r
-\r
-litToRep (NoRepRational r rational_ty)\r
- = postSimplExpr (mkLit (NoRepInteger (numerator r) integer_ty)) `thenPM` \ num_arg ->\r
- postSimplExpr (mkLit (NoRepInteger (denominator r) integer_ty)) `thenPM` \ denom_arg ->\r
- returnPM (rational_ty, mkConApp ratio_data_con [Type integer_ty, num_arg, denom_arg])\r
- where\r
- (ratio_data_con, integer_ty)\r
- = case (splitAlgTyConApp_maybe rational_ty) of\r
- Just (tycon, [i_ty], [con])\r
- -> ASSERT(isIntegerTy i_ty && getUnique tycon == ratioTyConKey)\r
- (con, i_ty)\r
-\r
- _ -> (panic "ratio_data_con", panic "integer_ty")\r
-\r
-litToRep other_lit = returnPM (literalType other_lit, mkLit other_lit)\r
-\end{code}\r
-\r
-\r
-%************************************************************************\r
-%* *\r
-\subsection{The monad}\r
-%* *\r
-%************************************************************************\r
-\r
-\begin{code}\r
-type PostM a = Bool -- True <=> inside a *value* lambda\r
- -> (UniqSupply, Bag CoreBind) -- Unique supply and Floats in \r
- -> (a, (UniqSupply, Bag CoreBind))\r
-\r
-initPM :: UniqSupply -> PostM a -> a\r
-initPM us m\r
- = case m False {- not inside lambda -} (us, emptyBag) of \r
- (result, _) -> result\r
-\r
-returnPM v in_lam usf = (v, usf)\r
-thenPM m k in_lam usf = case m in_lam usf of\r
- (r, usf') -> k r in_lam usf'\r
-\r
-mapPM f [] = returnPM []\r
-mapPM f (x:xs) = f x `thenPM` \ r ->\r
- mapPM f xs `thenPM` \ rs ->\r
- returnPM (r:rs)\r
-\r
-insideLambda :: CoreBndr -> PostM a -> PostM a\r
-insideLambda bndr m in_lam usf | isId bndr = m True usf\r
- | otherwise = m in_lam usf\r
-\r
-getInsideLambda :: PostM Bool\r
-getInsideLambda in_lam usf = (in_lam, usf)\r
-\r
-getFloatsPM :: PostM a -> PostM (a, Bag CoreBind)\r
-getFloatsPM m in_lam (us, floats)\r
- = let\r
- (a, (us', floats')) = m in_lam (us, emptyBag)\r
- in\r
- ((a, floats'), (us', floats))\r
-\r
-addTopFloat :: Type -> CoreExpr -> PostM Id\r
-addTopFloat lit_ty lit_rhs in_lam (us, floats)\r
- = let\r
- (us1, us2) = splitUniqSupply us\r
- uniq = uniqFromSupply us1\r
- lit_id = mkSysLocal SLIT("lf") uniq lit_ty\r
- in\r
- (lit_id, (us2, floats `snocBag` NonRec lit_id lit_rhs))\r
-\end{code}\r
-\r
-\r
+%
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+%
+\section[SimplCore]{Driver for simplifying @Core@ programs}
+
+\begin{code}
+module SimplCore ( core2core, simplifyExpr ) where
+
+#include "HsVersions.h"
+
+import CmdLineOpts ( CoreToDo(..), SimplifierSwitch(..),
+ SimplifierMode(..), DynFlags, DynFlag(..), dopt,
+ dopt_CoreToDo, buildCoreToDo
+ )
+import CoreSyn
+import TcIface ( loadImportedRules )
+import HscTypes ( HscEnv(..), ModGuts(..), ExternalPackageState(..),
+ ModDetails(..), HomeModInfo(..), hscEPS )
+import CSE ( cseProgram )
+import Rules ( RuleBase, ruleBaseIds, emptyRuleBase,
+ extendRuleBaseList, pprRuleBase, ruleCheckProgram )
+import Module ( moduleEnvElts )
+import PprCore ( pprCoreBindings, pprCoreExpr, pprIdRules )
+import OccurAnal ( occurAnalyseBinds, occurAnalyseGlobalExpr )
+import CoreUtils ( coreBindsSize )
+import Simplify ( simplTopBinds, simplExpr )
+import SimplUtils ( simplBinders )
+import SimplMonad
+import ErrUtils ( dumpIfSet, dumpIfSet_dyn, showPass )
+import CoreLint ( endPass )
+import VarEnv ( mkInScopeSet )
+import FloatIn ( floatInwards )
+import FloatOut ( floatOutwards )
+import Id ( idIsFrom, idSpecialisation, setIdSpecialisation )
+import VarSet
+import LiberateCase ( liberateCase )
+import SAT ( doStaticArgs )
+import Specialise ( specProgram)
+import SpecConstr ( specConstrProgram)
+import DmdAnal ( dmdAnalPgm )
+import WorkWrap ( wwTopBinds )
+#ifdef OLD_STRICTNESS
+import StrictAnal ( saBinds )
+import CprAnalyse ( cprAnalyse )
+#endif
+
+import UniqSupply ( UniqSupply, mkSplitUniqSupply, splitUniqSupply )
+import IO ( hPutStr, stderr )
+import Outputable
+import List ( partition )
+import Maybes ( orElse )
+\end{code}
+
+%************************************************************************
+%* *
+\subsection{The driver for the simplifier}
+%* *
+%************************************************************************
+
+\begin{code}
+core2core :: HscEnv
+ -> ModGuts
+ -> IO ModGuts
+
+core2core hsc_env guts
+ = do
+ let dflags = hsc_dflags hsc_env
+ core_todos
+ | Just todo <- dopt_CoreToDo dflags = todo
+ | otherwise = buildCoreToDo dflags
+
+ us <- mkSplitUniqSupply 's'
+ let (cp_us, ru_us) = splitUniqSupply us
+
+ -- COMPUTE THE RULE BASE TO USE
+ (imp_rule_base, guts') <- prepareRules hsc_env guts ru_us
+
+ -- DO THE BUSINESS
+ (stats, guts'') <- doCorePasses hsc_env cp_us
+ (zeroSimplCount dflags)
+ imp_rule_base guts' core_todos
+
+ dumpIfSet_dyn dflags Opt_D_dump_simpl_stats
+ "Grand total simplifier statistics"
+ (pprSimplCount stats)
+
+ return guts''
+
+
+simplifyExpr :: DynFlags -- includes spec of what core-to-core passes to do
+ -> CoreExpr
+ -> IO CoreExpr
+-- simplifyExpr is called by the driver to simplify an
+-- expression typed in at the interactive prompt
+simplifyExpr dflags expr
+ = do {
+ ; showPass dflags "Simplify"
+
+ ; us <- mkSplitUniqSupply 's'
+
+ ; let env = emptySimplEnv SimplGently []
+ (expr', _counts) = initSmpl dflags us (simplExprGently env expr)
+
+ ; dumpIfSet_dyn dflags Opt_D_dump_simpl "Simplified expression"
+ (pprCoreExpr expr')
+
+ ; return expr'
+ }
+
+doCorePasses :: HscEnv
+ -> UniqSupply -- uniques
+ -> SimplCount -- simplifier stats
+ -> RuleBase -- the main rule base
+ -> ModGuts -- local binds in (with rules attached)
+ -> [CoreToDo] -- which passes to do
+ -> IO (SimplCount, ModGuts)
+
+doCorePasses hsc_env us stats rb guts []
+ = return (stats, guts)
+
+doCorePasses hsc_env us stats rb guts (to_do : to_dos)
+ = do
+ let (us1, us2) = splitUniqSupply us
+ (stats1, rb1, guts1) <- doCorePass to_do hsc_env us1 rb guts
+ doCorePasses hsc_env us2 (stats `plusSimplCount` stats1) rb1 guts1 to_dos
+
+doCorePass (CoreDoSimplify mode sws) = _scc_ "Simplify" simplifyPgm mode sws
+doCorePass CoreCSE = _scc_ "CommonSubExpr" trBinds cseProgram
+doCorePass CoreLiberateCase = _scc_ "LiberateCase" trBinds liberateCase
+doCorePass CoreDoFloatInwards = _scc_ "FloatInwards" trBinds floatInwards
+doCorePass (CoreDoFloatOutwards f) = _scc_ "FloatOutwards" trBindsU (floatOutwards f)
+doCorePass CoreDoStaticArgs = _scc_ "StaticArgs" trBinds doStaticArgs
+doCorePass CoreDoStrictness = _scc_ "Stranal" trBinds dmdAnalPgm
+doCorePass CoreDoWorkerWrapper = _scc_ "WorkWrap" trBindsU wwTopBinds
+doCorePass CoreDoSpecialising = _scc_ "Specialise" trBindsU specProgram
+doCorePass CoreDoSpecConstr = _scc_ "SpecConstr" trBindsU specConstrProgram
+doCorePass CoreDoGlomBinds = trBinds glomBinds
+doCorePass CoreDoPrintCore = observe printCore
+doCorePass (CoreDoRuleCheck phase pat) = observe (ruleCheck phase pat)
+doCorePass CoreDoNothing = observe (\ _ _ -> return ())
+#ifdef OLD_STRICTNESS
+doCorePass CoreDoOldStrictness = _scc_ "OldStrictness" trBinds doOldStrictness
+#endif
+
+#ifdef OLD_STRICTNESS
+doOldStrictness dfs binds
+ = do binds1 <- saBinds dfs binds
+ binds2 <- cprAnalyse dfs binds1
+ return binds2
+#endif
+
+printCore _ binds = dumpIfSet True "Print Core" (pprCoreBindings binds)
+
+ruleCheck phase pat dflags binds = do showPass dflags "RuleCheck"
+ printDump (ruleCheckProgram phase pat binds)
+
+-- Most passes return no stats and don't change rules
+trBinds :: (DynFlags -> [CoreBind] -> IO [CoreBind])
+ -> HscEnv -> UniqSupply -> RuleBase -> ModGuts
+ -> IO (SimplCount, RuleBase, ModGuts)
+trBinds do_pass hsc_env us rb guts
+ = do { binds' <- do_pass dflags (mg_binds guts)
+ ; return (zeroSimplCount dflags, rb, guts { mg_binds = binds' }) }
+ where
+ dflags = hsc_dflags hsc_env
+
+trBindsU :: (DynFlags -> UniqSupply -> [CoreBind] -> IO [CoreBind])
+ -> HscEnv -> UniqSupply -> RuleBase -> ModGuts
+ -> IO (SimplCount, RuleBase, ModGuts)
+trBindsU do_pass hsc_env us rb guts
+ = do { binds' <- do_pass dflags us (mg_binds guts)
+ ; return (zeroSimplCount dflags, rb, guts { mg_binds = binds' }) }
+ where
+ dflags = hsc_dflags hsc_env
+
+-- Observer passes just peek; don't modify the bindings at all
+observe :: (DynFlags -> [CoreBind] -> IO a)
+ -> HscEnv -> UniqSupply -> RuleBase -> ModGuts
+ -> IO (SimplCount, RuleBase, ModGuts)
+observe do_pass hsc_env us rb guts
+ = do { binds <- do_pass dflags (mg_binds guts)
+ ; return (zeroSimplCount dflags, rb, guts) }
+ where
+ dflags = hsc_dflags hsc_env
+\end{code}
+
+
+
+%************************************************************************
+%* *
+\subsection{Dealing with rules}
+%* *
+%************************************************************************
+
+-- prepareLocalRuleBase takes the CoreBinds and rules defined in this module.
+-- It attaches those rules that are for local Ids to their binders, and
+-- returns the remainder attached to Ids in an IdSet.
+
+\begin{code}
+prepareRules :: HscEnv
+ -> ModGuts
+ -> UniqSupply
+ -> IO (RuleBase, -- Rule base for imported things, incl
+ -- (a) rules defined in this module (orphans)
+ -- (b) rules from other packages
+ -- (c) rules from other modules in home package
+ ModGuts) -- Modified fields are
+ -- (a) Bindings have rules attached,
+ -- (b) Rules are now just orphan rules
+
+prepareRules hsc_env@(HscEnv { hsc_dflags = dflags, hsc_HPT = hpt })
+ guts@(ModGuts { mg_binds = binds, mg_rules = local_rules, mg_module = this_mod })
+ us
+ = do { eps <- hscEPS hsc_env
+
+ ; let -- Simplify the local rules; boringly, we need to make an in-scope set
+ -- from the local binders, to avoid warnings from Simplify.simplVar
+ local_ids = mkInScopeSet (mkVarSet (bindersOfBinds binds))
+ env = setInScopeSet (emptySimplEnv SimplGently []) local_ids
+ (better_rules,_) = initSmpl dflags us (mapSmpl (simplRule env) local_rules)
+
+ (rules_for_locals, orphan_rules) = partition is_local_rule better_rules
+ is_local_rule (id,_) = idIsFrom this_mod id
+ -- Get the rules for locally-defined Ids out of the RuleBase
+ -- If we miss any rules for Ids defined here, then we end up
+ -- giving the local decl a new Unique (because the in-scope-set is (hackily) the
+ -- same as the non-local-rule-id set, so the Id looks as if it's in scope
+ -- and hence should be cloned), and now the binding for the class method
+ -- doesn't have the same Unique as the one in the Class and the tc-env
+ -- Example: class Foo a where
+ -- op :: a -> a
+ -- {-# RULES "op" op x = x #-}
+ --
+ -- NB we can't use isLocalId, because isLocalId isn't true of class methods.
+
+ -- NB: we assume that the imported rules dont include
+ -- rules for Ids in this module; if there is, the above bad things may happen
+
+ pkg_rule_base = eps_rule_base eps
+ hpt_rule_base = foldl add_rules pkg_rule_base (moduleEnvElts hpt)
+ imp_rule_base = extendRuleBaseList hpt_rule_base orphan_rules
+
+ -- Update the binders in the local bindings with the lcoal rules
+ -- Update the binders of top-level bindings by
+ -- attaching the rules for each locally-defined Id to that Id.
+ --
+ -- Reason
+ -- - It makes the rules easier to look up
+ -- - It means that transformation rules and specialisations for
+ -- locally defined Ids are handled uniformly
+ -- - It keeps alive things that are referred to only from a rule
+ -- (the occurrence analyser knows about rules attached to Ids)
+ -- - It makes sure that, when we apply a rule, the free vars
+ -- of the RHS are more likely to be in scope
+ -- - The imported rules are carried in the in-scope set
+ -- which is extended on each iteration by the new wave of
+ -- local binders; any rules which aren't on the binding will
+ -- thereby get dropped
+ local_rule_base = extendRuleBaseList emptyRuleBase rules_for_locals
+ binds_w_rules = updateBinders local_rule_base binds
+
+ ; dumpIfSet_dyn dflags Opt_D_dump_rules "Transformation rules"
+ (vcat [text "Local rules", pprIdRules better_rules,
+ text "",
+ text "Imported rules", pprRuleBase imp_rule_base])
+
+#ifdef DEBUG
+ ; let bad_rules = filter (idIsFrom this_mod) (varSetElems (ruleBaseIds imp_rule_base))
+ ; WARN( not (null bad_rules), ppr bad_rules ) return ()
+#endif
+ ; return (imp_rule_base, guts { mg_binds = binds_w_rules, mg_rules = orphan_rules })
+ }
+ where
+ add_rules rule_base mod_info = extendRuleBaseList rule_base (md_rules (hm_details mod_info))
+
+updateBinders :: RuleBase -> [CoreBind] -> [CoreBind]
+updateBinders rule_base binds
+ = map update_bndrs binds
+ where
+ rule_ids = ruleBaseIds rule_base
+
+ update_bndrs (NonRec b r) = NonRec (update_bndr b) r
+ update_bndrs (Rec prs) = Rec [(update_bndr b, r) | (b,r) <- prs]
+
+ update_bndr bndr = case lookupVarSet rule_ids bndr of
+ Nothing -> bndr
+ Just id -> bndr `setIdSpecialisation` idSpecialisation id
+\end{code}
+
+
+We must do some gentle simplification on the template (but not the RHS)
+of each rule. The case that forced me to add this was the fold/build rule,
+which without simplification looked like:
+ fold k z (build (/\a. g a)) ==> ...
+This doesn't match unless you do eta reduction on the build argument.
+
+\begin{code}
+simplRule env rule@(id, BuiltinRule _ _)
+ = returnSmpl rule
+simplRule env rule@(id, Rule act name bndrs args rhs)
+ = simplBinders env bndrs `thenSmpl` \ (env, bndrs') ->
+ mapSmpl (simplExprGently env) args `thenSmpl` \ args' ->
+ simplExprGently env rhs `thenSmpl` \ rhs' ->
+ returnSmpl (id, Rule act name bndrs' args' rhs')
+
+-- It's important that simplExprGently does eta reduction.
+-- For example, in a rule like:
+-- augment g (build h)
+-- we do not want to get
+-- augment (\a. g a) (build h)
+-- otherwise we don't match when given an argument like
+-- (\a. h a a)
+--
+-- The simplifier does indeed do eta reduction (it's in
+-- Simplify.completeLam) but only if -O is on.
+\end{code}
+
+\begin{code}
+simplExprGently :: SimplEnv -> CoreExpr -> SimplM CoreExpr
+-- Simplifies an expression
+-- does occurrence analysis, then simplification
+-- and repeats (twice currently) because one pass
+-- alone leaves tons of crud.
+-- Used (a) for user expressions typed in at the interactive prompt
+-- (b) the LHS and RHS of a RULE
+--
+-- The name 'Gently' suggests that the SimplifierMode is SimplGently,
+-- and in fact that is so.... but the 'Gently' in simplExprGently doesn't
+-- enforce that; it just simplifies the expression twice
+
+simplExprGently env expr
+ = simplExpr env (occurAnalyseGlobalExpr expr) `thenSmpl` \ expr1 ->
+ simplExpr env (occurAnalyseGlobalExpr expr1)
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection{Glomming}
+%* *
+%************************************************************************
+
+\begin{code}
+glomBinds :: DynFlags -> [CoreBind] -> IO [CoreBind]
+-- Glom all binds together in one Rec, in case any
+-- transformations have introduced any new dependencies
+--
+-- NB: the global invariant is this:
+-- *** the top level bindings are never cloned, and are always unique ***
+--
+-- We sort them into dependency order, but applying transformation rules may
+-- make something at the top refer to something at the bottom:
+-- f = \x -> p (q x)
+-- h = \y -> 3
+--
+-- RULE: p (q x) = h x
+--
+-- Applying this rule makes f refer to h,
+-- although it doesn't appear to in the source program.
+-- This pass lets us control where it happens.
+--
+-- NOTICE that this cannot happen for rules whose head is a locally-defined
+-- function. It only happens for rules whose head is an imported function
+-- (p in the example above). So, for example, the rule had been
+-- RULE: f (p x) = h x
+-- then the rule for f would be attached to f itself (in its IdInfo)
+-- by prepareLocalRuleBase and h would be regarded by the occurrency
+-- analyser as free in f.
+
+glomBinds dflags binds
+ = do { showPass dflags "GlomBinds" ;
+ let { recd_binds = [Rec (flattenBinds binds)] } ;
+ return recd_binds }
+ -- Not much point in printing the result...
+ -- just consumes output bandwidth
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection{The driver for the simplifier}
+%* *
+%************************************************************************
+
+\begin{code}
+simplifyPgm :: SimplifierMode
+ -> [SimplifierSwitch]
+ -> HscEnv
+ -> UniqSupply
+ -> RuleBase
+ -> ModGuts
+ -> IO (SimplCount, RuleBase, ModGuts) -- New bindings
+
+simplifyPgm mode switches hsc_env us rule_base guts
+ = do {
+ showPass dflags "Simplify";
+
+ (termination_msg, it_count, counts_out, rule_base', guts')
+ <- do_iteration us rule_base 1 (zeroSimplCount dflags) guts;
+
+ dumpIfSet (dopt Opt_D_verbose_core2core dflags
+ && dopt Opt_D_dump_simpl_stats dflags)
+ "Simplifier statistics"
+ (vcat [text termination_msg <+> text "after" <+> ppr it_count <+> text "iterations",
+ text "",
+ pprSimplCount counts_out]);
+
+ endPass dflags "Simplify" Opt_D_verbose_core2core (mg_binds guts');
+
+ return (counts_out, rule_base', guts')
+ }
+ where
+ dflags = hsc_dflags hsc_env
+ phase_info = case mode of
+ SimplGently -> "gentle"
+ SimplPhase n -> show n
+
+ simpl_env = emptySimplEnv mode switches
+ sw_chkr = getSwitchChecker simpl_env
+ max_iterations = intSwitchSet sw_chkr MaxSimplifierIterations `orElse` 2
+
+ do_iteration us rule_base iteration_no counts guts
+ -- iteration_no is the number of the iteration we are
+ -- about to begin, with '1' for the first
+ | iteration_no > max_iterations -- Stop if we've run out of iterations
+ = do {
+#ifdef DEBUG
+ if max_iterations > 2 then
+ hPutStr stderr ("NOTE: Simplifier still going after " ++
+ show max_iterations ++
+ " iterations; bailing out.\n")
+ else
+ return ();
+#endif
+ -- Subtract 1 from iteration_no to get the
+ -- number of iterations we actually completed
+ return ("Simplifier baled out", iteration_no - 1, counts, rule_base, guts)
+ }
+
+ -- Try and force thunks off the binds; significantly reduces
+ -- space usage, especially with -O. JRS, 000620.
+ | let sz = coreBindsSize (mg_binds guts) in sz == sz
+ = do {
+ -- Occurrence analysis
+ let { tagged_binds = _scc_ "OccAnal" occurAnalyseBinds (mg_binds guts) } ;
+
+ dumpIfSet_dyn dflags Opt_D_dump_occur_anal "Occurrence analysis"
+ (pprCoreBindings tagged_binds);
+
+ -- Get any new rules, and extend the rule base
+ -- (on the side this extends the package rule base in the
+ -- ExternalPackageTable, ready for the next complation
+ -- in --make mode)
+ -- We need to do this regularly, because simplification can
+ -- poke on IdInfo thunks, which in turn brings in new rules
+ -- behind the scenes. Otherwise there's a danger we'll simply
+ -- miss the rules for Ids hidden inside imported inlinings
+ new_rules <- loadImportedRules hsc_env guts ;
+ let { rule_base' = extendRuleBaseList rule_base new_rules
+ ; in_scope = mkInScopeSet (ruleBaseIds rule_base')
+ ; simpl_env' = setInScopeSet simpl_env in_scope } ;
+ -- The new rule base Ids are used to initialise
+ -- the in-scope set. That way, the simplifier will change any
+ -- occurrences of the imported id to the one in the imported_rule_ids
+ -- set, which are decorated with their rules.
+
+ -- Simplify the program
+ -- We do this with a *case* not a *let* because lazy pattern
+ -- matching bit us with bad space leak!
+ -- With a let, we ended up with
+ -- let
+ -- t = initSmpl ...
+ -- counts' = snd t
+ -- in
+ -- case t of {(_,counts') -> if counts'=0 then ... }
+ -- So the conditional didn't force counts', because the
+ -- selection got duplicated. Sigh!
+ case initSmpl dflags us1 (simplTopBinds simpl_env' tagged_binds) of {
+ (binds', counts') -> do {
+
+ let { guts' = guts { mg_binds = binds' }
+ ; all_counts = counts `plusSimplCount` counts'
+ ; herald = "Simplifier phase " ++ phase_info ++
+ ", iteration " ++ show iteration_no ++
+ " out of " ++ show max_iterations
+ } ;
+
+ -- Stop if nothing happened; don't dump output
+ if isZeroSimplCount counts' then
+ return ("Simplifier reached fixed point", iteration_no,
+ all_counts, rule_base', guts')
+ else do {
+
+ -- Dump the result of this iteration
+ dumpIfSet_dyn dflags Opt_D_dump_simpl_iterations herald
+ (pprSimplCount counts') ;
+
+ endPass dflags herald Opt_D_dump_simpl_iterations binds' ;
+
+ -- Loop
+ do_iteration us2 rule_base' (iteration_no + 1) all_counts guts'
+ } } } }
+ where
+ (us1, us2) = splitUniqSupply us
+\end{code}