X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2FdeSugar%2FDsBinds.lhs;h=27d41476e1ce993ad58bd843ab9cd40f77f9b293;hp=8f3006d0f338295e3057b45f0fb35c3e2802dbdd;hb=d5934bbb856aa0aa620c9b2e0fa51c90a1a5a048;hpb=0065d5ab628975892cea1ec7303f968c3338cbe1 diff --git a/compiler/deSugar/DsBinds.lhs b/compiler/deSugar/DsBinds.lhs index 8f3006d..27d4147 100644 --- a/compiler/deSugar/DsBinds.lhs +++ b/compiler/deSugar/DsBinds.lhs @@ -1,7 +1,9 @@ % +% (c) The University of Glasgow 2006 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 % -\section[DsBinds]{Pattern-matching bindings (HsBinds and MonoBinds)} + +Pattern-matching bindings (HsBinds and MonoBinds) Handles @HsBinds@; those at the top level require different handling, in that the @Rec@/@NonRec@/etc structure is thrown away (whereas at @@ -15,37 +17,37 @@ module DsBinds ( dsTopLHsBinds, dsLHsBinds, decomposeRuleLhs, #include "HsVersions.h" - import {-# SOURCE #-} DsExpr( dsLExpr, dsExpr ) import {-# SOURCE #-} Match( matchWrapper ) import DsMonad -import DsGRHSs ( dsGuarded ) +import DsGRHSs import DsUtils import HsSyn -- lots of things import CoreSyn -- lots of things -import CoreUtils ( exprType, mkInlineMe, mkSCC ) - -import StaticFlags ( opt_AutoSccsOnAllToplevs, - opt_AutoSccsOnExportedToplevs ) -import OccurAnal ( occurAnalyseExpr ) -import CostCentre ( mkAutoCC, IsCafCC(..) ) -import Id ( Id, DictId, idType, idName, isExportedId, mkLocalId, setInlinePragma ) -import Rules ( addIdSpecialisations, mkLocalRule ) -import Var ( TyVar, Var, isGlobalId, setIdNotExported ) +import CoreUtils + +import TcHsSyn ( mkArbitraryType ) -- Mis-placed? +import OccurAnal +import CostCentre +import Module +import Id +import Rules +import Var ( TyVar, Var ) import VarEnv -import Type ( mkTyVarTy, substTyWith ) -import TysWiredIn ( voidTy ) +import Type +import TysWiredIn import Outputable -import SrcLoc ( Located(..) ) -import Maybes ( isJust, catMaybes, orElse ) -import Bag ( bagToList ) -import BasicTypes ( Activation(..), InlineSpec(..), isAlwaysActive, defaultInlineSpec ) -import Monad ( foldM ) -import FastString ( mkFastString ) -import List ( (\\) ) +import SrcLoc +import Maybes +import Bag +import BasicTypes hiding ( TopLevel ) +import FastString import Util ( mapSnd ) + +import Control.Monad +import Data.List \end{code} %************************************************************************ @@ -87,36 +89,58 @@ dsHsBind auto_scc rest (VarBind var expr) addDictScc var core_expr `thenDs` \ core_expr' -> returnDs ((var, core_expr') : rest) -dsHsBind auto_scc rest (FunBind { fun_id = L _ fun, fun_matches = matches, fun_co_fn = co_fn }) +dsHsBind auto_scc rest (FunBind { fun_id = L _ fun, fun_matches = matches, fun_co_fn = co_fn, fun_tick = tick }) = matchWrapper (FunRhs (idName fun)) matches `thenDs` \ (args, body) -> - dsCoercion co_fn (return (mkLams args body)) `thenDs` \ rhs -> - addAutoScc auto_scc (fun, rhs) `thenDs` \ pair -> - returnDs (pair : rest) + mkOptTickBox tick body `thenDs` \ body' -> + dsCoercion co_fn (return (mkLams args body')) `thenDs` \ rhs -> + returnDs ((fun,rhs) : rest) dsHsBind auto_scc rest (PatBind { pat_lhs = pat, pat_rhs = grhss, pat_rhs_ty = ty }) = dsGuarded grhss ty `thenDs` \ body_expr -> mkSelectorBinds pat body_expr `thenDs` \ sel_binds -> - mappM (addAutoScc auto_scc) sel_binds `thenDs` \ sel_binds -> returnDs (sel_binds ++ rest) - -- Common special case: no type or dictionary abstraction - -- For the (rare) case when there are some mixed-up - -- dictionary bindings (for which a Rec is convenient) - -- we reply on the enclosing dsBind to wrap a Rec around. +-- Note [Rules and inlining] +-- Common special case: no type or dictionary abstraction +-- This is a bit less trivial than you might suppose +-- The naive way woudl be to desguar to something like +-- f_lcl = ...f_lcl... -- The "binds" from AbsBinds +-- M.f = f_lcl -- Generated from "exports" +-- But we don't want that, because if M.f isn't exported, +-- it'll be inlined unconditionally at every call site (its rhs is +-- trivial). That would be ok unless it has RULES, which would +-- thereby be completely lost. Bad, bad, bad. +-- +-- Instead we want to generate +-- M.f = ...f_lcl... +-- f_lcl = M.f +-- Now all is cool. The RULES are attached to M.f (by SimplCore), +-- and f_lcl is rapidly inlined away. +-- +-- This does not happen in the same way to polymorphic binds, +-- because they desugar to +-- M.f = /\a. let f_lcl = ...f_lcl... in f_lcl +-- Although I'm a bit worried about whether full laziness might +-- float the f_lcl binding out and then inline M.f at its call site + dsHsBind auto_scc rest (AbsBinds [] [] exports binds) - = ds_lhs_binds (addSccs auto_scc exports) binds `thenDs` \ core_prs -> - let - core_prs' = addLocalInlines exports core_prs - exports' = [(global, Var local) | (_, global, local, _) <- exports] - in - returnDs (core_prs' ++ exports' ++ rest) + = do { core_prs <- ds_lhs_binds NoSccs binds + ; let env = mkABEnv exports + do_one (lcl_id, rhs) | Just (gbl_id, prags) <- lookupVarEnv env lcl_id + = addInlinePrags prags gbl_id $ + addAutoScc auto_scc gbl_id rhs + | otherwise = (lcl_id, rhs) + locals' = [(lcl_id, Var gbl_id) | (_, gbl_id, lcl_id, _) <- exports] + ; return (map do_one core_prs ++ locals' ++ rest) } + -- No Rec needed here (contrast the other AbsBinds cases) + -- because we can rely on the enclosing dsBind to wrap in Rec -- Another common case: one exported variable -- Non-recursive bindings come through this way dsHsBind auto_scc rest (AbsBinds all_tyvars dicts exports@[(tyvars, global, local, prags)] binds) = ASSERT( all (`elem` tyvars) all_tyvars ) - ds_lhs_binds (addSccs auto_scc exports) binds `thenDs` \ core_prs -> + ds_lhs_binds NoSccs binds `thenDs` \ core_prs -> let -- Always treat the binds as recursive, because the typechecker -- makes rather mixed-up dictionary bindings @@ -128,54 +152,63 @@ dsHsBind auto_scc rest (spec_binds, rules) = unzip (catMaybes mb_specs) global' = addIdSpecialisations global rules rhs' = mkLams tyvars $ mkLams dicts $ Let core_bind (Var local) - inl = case [inl | InlinePrag inl <- prags] of - [] -> defaultInlineSpec - (inl:_) -> inl + bind = addInlinePrags prags global' $ addAutoScc auto_scc global' rhs' in - returnDs (addInlineInfo inl global' rhs' : spec_binds ++ rest) + returnDs (bind : spec_binds ++ rest) dsHsBind auto_scc rest (AbsBinds all_tyvars dicts exports binds) - = ds_lhs_binds (addSccs auto_scc exports) binds `thenDs` \ core_prs -> - let - -- Rec because of mixed-up dictionary bindings - core_bind = Rec (addLocalInlines exports core_prs) - - tup_expr = mkTupleExpr locals - tup_ty = exprType tup_expr - poly_tup_expr = mkLams all_tyvars $ mkLams dicts $ - Let core_bind tup_expr - locals = [local | (_, _, local, _) <- exports] - local_tys = map idType locals - in - newSysLocalDs (exprType poly_tup_expr) `thenDs` \ poly_tup_id -> - let - dict_args = map Var dicts - - mk_bind ((tyvars, global, local, prags), n) -- locals !! n == local - = -- Need to make fresh locals to bind in the selector, because - -- some of the tyvars will be bound to voidTy - newSysLocalsDs (map substitute local_tys) `thenDs` \ locals' -> - newSysLocalDs (substitute tup_ty) `thenDs` \ tup_id -> - mapM (dsSpec all_tyvars dicts tyvars global local core_bind) - prags `thenDs` \ mb_specs -> - let - (spec_binds, rules) = unzip (catMaybes mb_specs) - global' = addIdSpecialisations global rules - rhs = mkLams tyvars $ mkLams dicts $ - mkTupleSelector locals' (locals' !! n) tup_id $ - mkApps (mkTyApps (Var poly_tup_id) ty_args) dict_args - in - returnDs ((global', rhs) : spec_binds) - where - mk_ty_arg all_tyvar | all_tyvar `elem` tyvars = mkTyVarTy all_tyvar - | otherwise = voidTy - ty_args = map mk_ty_arg all_tyvars - substitute = substTyWith all_tyvars ty_args - in - mappM mk_bind (exports `zip` [0..]) `thenDs` \ export_binds_s -> - -- don't scc (auto-)annotate the tuple itself. + = do { core_prs <- ds_lhs_binds NoSccs binds + ; let env = mkABEnv exports + do_one (lcl_id,rhs) | Just (gbl_id, prags) <- lookupVarEnv env lcl_id + = addInlinePrags prags lcl_id $ + addAutoScc auto_scc gbl_id rhs + | otherwise = (lcl_id,rhs) + + -- Rec because of mixed-up dictionary bindings + core_bind = Rec (map do_one core_prs) + + tup_expr = mkTupleExpr locals + tup_ty = exprType tup_expr + poly_tup_expr = mkLams all_tyvars $ mkLams dicts $ + Let core_bind tup_expr + locals = [local | (_, _, local, _) <- exports] + local_tys = map idType locals + + ; poly_tup_id <- newSysLocalDs (exprType poly_tup_expr) + + ; let dict_args = map Var dicts + + mk_bind ((tyvars, global, local, prags), n) -- locals !! n == local + = -- Need to make fresh locals to bind in the selector, because + -- some of the tyvars will be bound to 'Any' + do { locals' <- newSysLocalsDs (map substitute local_tys) + ; tup_id <- newSysLocalDs (substitute tup_ty) + ; mb_specs <- mapM (dsSpec all_tyvars dicts tyvars global local core_bind) + prags + ; let (spec_binds, rules) = unzip (catMaybes mb_specs) + global' = addIdSpecialisations global rules + rhs = mkLams tyvars $ mkLams dicts $ + mkTupleSelector locals' (locals' !! n) tup_id $ + mkApps (mkTyApps (Var poly_tup_id) ty_args) dict_args + ; returnDs ((global', rhs) : spec_binds) } + where + mk_ty_arg all_tyvar | all_tyvar `elem` tyvars = mkTyVarTy all_tyvar + | otherwise = mkArbitraryType all_tyvar + ty_args = map mk_ty_arg all_tyvars + substitute = substTyWith all_tyvars ty_args + + ; export_binds_s <- mappM mk_bind (exports `zip` [0..]) + -- don't scc (auto-)annotate the tuple itself. + + ; returnDs ((poly_tup_id, poly_tup_expr) : + (concat export_binds_s ++ rest)) } + +mkABEnv :: [([TyVar], Id, Id, [Prag])] -> VarEnv (Id, [Prag]) +-- Takes the exports of a AbsBinds, and returns a mapping +-- lcl_id -> (gbl_id, prags) +mkABEnv exports = mkVarEnv [ (lcl_id, (gbl_id, prags)) + | (_, gbl_id, lcl_id, prags) <- exports] - returnDs ((poly_tup_id, poly_tup_expr) : (concat export_binds_s ++ rest)) dsSpec :: [TyVar] -> [DictId] -> [TyVar] -> Id -> Id -- Global, local @@ -211,7 +244,7 @@ dsSpec all_tvs dicts tvs poly_id mono_id mono_bind mb_lhs = decomposeRuleLhs (bndrs ++ const_dicts) body ; case mb_lhs of - Nothing -> do { dsWarn msg; return Nothing } + Nothing -> do { warnDs msg; return Nothing } Just (bndrs', var, args) -> return (Just (addInlineInfo inl spec_id spec_rhs, rule)) where @@ -235,11 +268,11 @@ dsSpec all_tvs dicts tvs poly_id mono_id mono_bind (mkVarApps (Var spec_id) bndrs) } where - -- Bind to voidTy any of all_ptvs that aren't + -- Bind to Any any of all_ptvs that aren't -- relevant for this particular function fix_up body | null void_tvs = body | otherwise = mkTyApps (mkLams void_tvs body) - (map (const voidTy) void_tvs) + (map mkArbitraryType void_tvs) void_tvs = all_tvs \\ tvs msg = hang (ptext SLIT("Specialisation too complicated to desugar; ignored")) @@ -298,6 +331,7 @@ simpleSubst subst expr = go expr where go (Var v) = lookupVarEnv subst v `orElse` Var v + go (Cast e co) = Cast (go e) co go (Type ty) = Type ty go (Lit lit) = Lit lit go (App fun arg) = App (go fun) (go arg) @@ -308,17 +342,12 @@ simpleSubst subst expr go (Case scrut bndr ty alts) = Case (go scrut) bndr ty [(c,bs,go r) | (c,bs,r) <- alts] -addLocalInlines exports core_prs - = map add_inline core_prs - where - add_inline (bndr,rhs) | Just inl <- lookupVarEnv inline_env bndr - = addInlineInfo inl bndr rhs - | otherwise - = (bndr,rhs) - inline_env = mkVarEnv [(mono_id, prag) - | (_, _, mono_id, prags) <- exports, - InlinePrag prag <- prags] - +addInlinePrags :: [Prag] -> Id -> CoreExpr -> (Id,CoreExpr) +addInlinePrags prags bndr rhs + = case [inl | InlinePrag inl <- prags] of + [] -> (bndr, rhs) + (inl:_) -> addInlineInfo inl bndr rhs + addInlineInfo :: InlineSpec -> Id -> CoreExpr -> (Id,CoreExpr) addInlineInfo (Inline phase is_inline) bndr rhs = (attach_phase bndr phase, wrap_inline is_inline rhs) @@ -339,36 +368,20 @@ addInlineInfo (Inline phase is_inline) bndr rhs %************************************************************************ \begin{code} -data AutoScc - = TopLevel - | TopLevelAddSccs (Id -> Maybe Id) - | NoSccs - -addSccs :: AutoScc -> [(a,Id,Id,[Prag])] -> AutoScc -addSccs auto_scc@(TopLevelAddSccs _) exports = auto_scc -addSccs NoSccs exports = NoSccs -addSccs TopLevel exports - = TopLevelAddSccs (\id -> case [ exp | (_,exp,loc,_) <- exports, loc == id ] of - (exp:_) | opt_AutoSccsOnAllToplevs || - (isExportedId exp && - opt_AutoSccsOnExportedToplevs) - -> Just exp - _ -> Nothing) - -addAutoScc :: AutoScc -- if needs be, decorate toplevs? - -> (Id, CoreExpr) - -> DsM (Id, CoreExpr) - -addAutoScc (TopLevelAddSccs auto_scc_fn) pair@(bndr, core_expr) - | do_auto_scc - = getModuleDs `thenDs` \ mod -> - returnDs (bndr, mkSCC (mkAutoCC top_bndr mod NotCafCC) core_expr) - where do_auto_scc = isJust maybe_auto_scc - maybe_auto_scc = auto_scc_fn bndr - (Just top_bndr) = maybe_auto_scc - -addAutoScc _ pair - = returnDs pair +data AutoScc = NoSccs + | AddSccs Module (Id -> Bool) +-- The (Id->Bool) says which Ids to add SCCs to + +addAutoScc :: AutoScc + -> Id -- Binder + -> CoreExpr -- Rhs + -> CoreExpr -- Scc'd Rhs + +addAutoScc NoSccs _ rhs + = rhs +addAutoScc (AddSccs mod add_scc) id rhs + | add_scc id = mkSCC (mkAutoCC id mod NotCafCC) rhs + | otherwise = rhs \end{code} If profiling and dealing with a dict binding, @@ -398,20 +411,20 @@ addDictScc var rhs = returnDs rhs \begin{code} -dsCoercion :: ExprCoFn -> DsM CoreExpr -> DsM CoreExpr -dsCoercion CoHole thing_inside = thing_inside -dsCoercion (CoCompose c1 c2) thing_inside = dsCoercion c1 (dsCoercion c2 thing_inside) -dsCoercion (CoLams ids c) thing_inside = do { expr <- dsCoercion c thing_inside - ; return (mkLams ids expr) } -dsCoercion (CoTyLams tvs c) thing_inside = do { expr <- dsCoercion c thing_inside - ; return (mkLams tvs expr) } -dsCoercion (CoApps c ids) thing_inside = do { expr <- dsCoercion c thing_inside - ; return (mkVarApps expr ids) } -dsCoercion (CoTyApps c tys) thing_inside = do { expr <- dsCoercion c thing_inside - ; return (mkTyApps expr tys) } -dsCoercion (CoLet bs c) thing_inside = do { prs <- dsLHsBinds bs - ; expr <- dsCoercion c thing_inside +dsCoercion :: HsWrapper -> DsM CoreExpr -> DsM CoreExpr +dsCoercion WpHole thing_inside = thing_inside +dsCoercion (WpCompose c1 c2) thing_inside = dsCoercion c1 (dsCoercion c2 thing_inside) +dsCoercion (WpCo co) thing_inside = do { expr <- thing_inside + ; return (Cast expr co) } +dsCoercion (WpLam id) thing_inside = do { expr <- thing_inside + ; return (Lam id expr) } +dsCoercion (WpTyLam tv) thing_inside = do { expr <- thing_inside + ; return (Lam tv expr) } +dsCoercion (WpApp id) thing_inside = do { expr <- thing_inside + ; return (App expr (Var id)) } +dsCoercion (WpTyApp ty) thing_inside = do { expr <- thing_inside + ; return (App expr (Type ty)) } +dsCoercion (WpLet bs) thing_inside = do { prs <- dsLHsBinds bs + ; expr <- thing_inside ; return (Let (Rec prs) expr) } \end{code} - -