%
+% (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
#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 TcType
+import OccurAnal
+import CostCentre
+import Module
+import Id
+import Var ( TyVar )
+import Rules
import VarEnv
-import Type ( mkTyVarTy, substTyWith )
-import TysWiredIn ( voidTy )
+import Type
import Outputable
-import SrcLoc ( Located(..) )
-import Maybes ( isJust, catMaybes, orElse )
-import Bag ( bagToList )
-import BasicTypes ( Activation(..), InlineSpec(..), isAlwaysActive )
-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}
%************************************************************************
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 })
- = 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)
+dsHsBind auto_scc rest (FunBind { fun_id = L _ fun, fun_matches = matches,
+ fun_co_fn = co_fn, fun_tick = tick, fun_infix = inf })
+ = matchWrapper (FunRhs (idName fun) inf) matches `thenDs` \ (args, body) ->
+ 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)
-- Note [Rules and inlining]
-- float the f_lcl binding out and then inline M.f at its call site
dsHsBind auto_scc rest (AbsBinds [] [] exports binds)
- = do { core_prs <- ds_lhs_binds (addSccs auto_scc exports) binds
- ; let env = mkVarEnv [ (lcl_id, (gbl_id, prags))
- | (_, gbl_id, lcl_id, prags) <- exports]
+ = 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 rhs
+ = 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) }
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
(spec_binds, rules) = unzip (catMaybes mb_specs)
global' = addIdSpecialisations global rules
rhs' = mkLams tyvars $ mkLams dicts $ Let core_bind (Var local)
+ bind = addInlinePrags prags global' $ addAutoScc auto_scc global' rhs'
in
- returnDs (addInlinePrags prags 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
- add_inline (bndr,rhs) | Just prags <- lookupVarEnv inline_env bndr
- = addInlinePrags prags bndr rhs
- | otherwise = (bndr,rhs)
- inline_env = mkVarEnv [(lcl_id, prags) | (_, _, lcl_id, prags) <- exports]
-
- -- Rec because of mixed-up dictionary bindings
- core_bind = Rec (map add_inline 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, [LPrag])] -> VarEnv (Id, [LPrag])
+-- 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
- -> CoreBind -> Prag
+ -> CoreBind -> LPrag
-> DsM (Maybe ((Id,CoreExpr), -- Binding for specialised Id
CoreRule)) -- Rule for the Global Id
-- /\b.\(d:Ix b). in f Int b dInt d
-- The idea is that f occurs just once, so it'll be
-- inlined and specialised
-
-dsSpec all_tvs dicts tvs poly_id mono_id mono_bind (InlinePrag {})
+--
+-- Given SpecPrag (/\as.\ds. f es) t, we have
+-- the defn f_spec as ds = f es
+-- and the RULE f es = f_spec as ds
+--
+-- It is *possible* that 'es' does not mention all of the dictionaries 'ds'
+-- (a bit silly, because then the
+dsSpec all_tvs dicts tvs poly_id mono_id mono_bind (L _ (InlinePrag {}))
= return Nothing
dsSpec all_tvs dicts tvs poly_id mono_id mono_bind
- (SpecPrag spec_expr spec_ty const_dicts inl)
- = do { let poly_name = idName poly_id
+ (L loc (SpecPrag spec_expr spec_ty _const_dicts inl))
+ -- See Note [Const rule dicts]
+ = putSrcSpanDs loc $
+ do { let poly_name = idName poly_id
; spec_name <- newLocalName poly_name
; ds_spec_expr <- dsExpr spec_expr
- ; let (bndrs, body) = collectBinders ds_spec_expr
- mb_lhs = decomposeRuleLhs (bndrs ++ const_dicts) body
-
- ; case mb_lhs of
- Nothing -> do { warnDs msg; return Nothing }
-
- Just (bndrs', var, args) -> return (Just (addInlineInfo inl spec_id spec_rhs, rule))
+ ; let (bndrs, body) = collectBinders (occurAnalyseExpr ds_spec_expr)
+ -- The occurrence-analysis does two things
+ -- (a) identifies unused binders: Note [Unused spec binders]
+ -- (b) sorts dict bindings into NonRecs
+ -- so they can be inlined by decomposeRuleLhs
+ mb_lhs = decomposeRuleLhs body
+
+ -- Check for dead binders: Note [Unused spec binders]
+ ; case filter isDeadBinder bndrs of {
+ bs | not (null bs) -> do { warnDs (dead_msg bs); return Nothing }
+ | otherwise ->
+
+ case mb_lhs of
+ Nothing -> do { warnDs decomp_msg; return Nothing }
+
+ Just (var, args) -> return (Just (addInlineInfo inl spec_id spec_rhs, rule))
where
local_poly = setIdNotExported poly_id
-- Very important to make the 'f' non-exported,
poly_f_body = mkLams (tvs ++ dicts) $
fix_up (Let mono_bind (Var mono_id))
- -- Quantify over constant dicts on the LHS, since
- -- their value depends only on their type
- -- The ones we are interested in may even be imported
- -- e.g. GHC.Base.dEqInt
-
rule = mkLocalRule (mkFastString ("SPEC " ++ showSDoc (ppr poly_name)))
AlwaysActive poly_name
- bndrs' -- Includes constant dicts
- args
+ bndrs args
(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"))
- 2 (ppr spec_expr)
+ dead_msg bs = vcat [ sep [ptext SLIT("Useless constraint") <> plural bs
+ <+> ptext SLIT("in specialied type:"),
+ nest 2 (pprTheta (map get_pred bs))]
+ , ptext SLIT("SPECIALISE pragma ignored")]
+ get_pred b = ASSERT( isId b ) expectJust "dsSpec" (tcSplitPredTy_maybe (idType b))
+
+ decomp_msg = hang (ptext SLIT("Specialisation too complicated to desugar; ignored"))
+ 2 (ppr spec_expr)
\end{code}
+Note [Unused spec binders]
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+Consider
+ f :: a -> a
+ {-# SPECIALISE f :: Eq a => a -> a #-}
+It's true that this *is* a more specialised type, but the rule
+we get is something like this:
+ f_spec d = f
+ RULE: f = f_spec d
+Note that the rule is bogus, becuase it mentions a 'd' that is
+not bound on the LHS! But it's a silly specialisation anyway, becuase
+the constraint is unused. We could bind 'd' to (error "unused")
+but it seems better to reject the program because it's almost certainly
+a mistake. That's what the isDeadBinder call detects.
+
+Note [Const rule dicts]
+~~~~~~~~~~~~~~~~~~~~~~~
+A SpecPrag has a field for "constant dicts" in the RULE, but I think
+it's pretty useless. See the place where it's generated in TcBinds.
+TcSimplify will discharge a constraint by binding it to, say,
+GHC.Base.$f2 :: Eq Int, withour putting anything in the LIE, so this
+dict won't show up in the const-dicts field. It probably doesn't matter,
+because the rule will end up being something like
+ f Int GHC.Base.$f2 = ...
+rather than
+ forall d. f Int d = ...
+The latter is more general, but in practice I think it won't make any
+difference.
+
%************************************************************************
%* *
%************************************************************************
\begin{code}
-decomposeRuleLhs :: [Var] -> CoreExpr -> Maybe ([Var], Id, [CoreExpr])
+decomposeRuleLhs :: CoreExpr -> Maybe (Id, [CoreExpr])
-- Returns Nothing if the LHS isn't of the expected shape
--- The argument 'all_bndrs' includes the "constant dicts" of the LHS,
--- and they may be GlobalIds, which we can't forall-ify.
--- So we substitute them out instead
-decomposeRuleLhs all_bndrs lhs
- = go init_env (occurAnalyseExpr lhs) -- Occurrence analysis sorts out the dict
- -- bindings so we know if they are recursive
+decomposeRuleLhs lhs
+ = go emptyVarEnv (occurAnalyseExpr lhs) -- Occurrence analysis sorts out the dict
+ -- bindings so we know if they are recursive
where
-
- -- all_bndrs may include top-level imported dicts,
- -- imported things with a for-all.
- -- So we localise them and subtitute them out
- bndr_prs = [ (id, Var (localise id)) | id <- all_bndrs, isGlobalId id ]
- localise d = mkLocalId (idName d) (idType d)
-
- init_env = mkVarEnv bndr_prs
- all_bndrs' = map subst_bndr all_bndrs
- subst_bndr bndr = case lookupVarEnv init_env bndr of
- Just (Var bndr') -> bndr'
- Just other -> panic "decomposeRuleLhs"
- Nothing -> bndr
-
-- Substitute dicts in the LHS args, so that there
-- aren't any lets getting in the way
-- Note that we substitute the function too; we might have this as
= go (extendVarEnv env dict (simpleSubst env rhs)) body
go env body
= case collectArgs (simpleSubst env body) of
- (Var fn, args) -> Just (all_bndrs', fn, args)
+ (Var fn, args) -> Just (fn, args)
other -> Nothing
simpleSubst :: IdEnv CoreExpr -> CoreExpr -> CoreExpr
-- (a) takes no account of capture; dictionary bindings use new names
-- (b) can have a GlobalId (imported) in its domain
-- (c) Ids only; no types are substituted
-
+--
+-- (b) is the reason we can't use CoreSubst... and it's no longer relevant
+-- so really we should replace simpleSubst
simpleSubst subst expr
= go expr
where
go (Case scrut bndr ty alts) = Case (go scrut) bndr ty
[(c,bs,go r) | (c,bs,r) <- alts]
-addInlinePrags :: [Prag] -> Id -> CoreExpr -> (Id,CoreExpr)
+addInlinePrags :: [LPrag] -> Id -> CoreExpr -> (Id,CoreExpr)
addInlinePrags prags bndr rhs
- = case [inl | InlinePrag inl <- prags] of
+ = case [inl | L _ (InlinePrag inl) <- prags] of
[] -> (bndr, rhs)
(inl:_) -> addInlineInfo inl 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,
; expr <- thing_inside
; return (Let (Rec prs) expr) }
\end{code}
-
-
projects / ghc-hetmet.git / blobdiff