Level(..), tOP_LEVEL,
LevelledBind, LevelledExpr,
- incMinorLvl, ltMajLvl, ltLvl, isTopLvl, isInlineCtxt
+ incMinorLvl, ltMajLvl, ltLvl, isTopLvl
) where
#include "HsVersions.h"
import DynFlags ( FloatOutSwitches(..) )
import CoreUtils ( exprType, exprIsTrivial, mkPiTypes )
+import CoreArity ( exprBotStrictness_maybe )
import CoreFVs -- all of it
-import CoreSubst ( Subst, emptySubst, extendInScope, extendIdSubst,
- cloneIdBndr, cloneRecIdBndrs )
-import Id ( Id, idType, mkSysLocal, isOneShotLambda,
+import CoreSubst ( Subst, emptySubst, extendInScope, extendInScopeList,
+ extendIdSubst, cloneIdBndr, cloneRecIdBndrs )
+import Id ( idType, mkSysLocal, isOneShotLambda,
zapDemandIdInfo, transferPolyIdInfo,
- idSpecialisation, idWorkerInfo, setIdInfo
+ idSpecialisation, idUnfolding, setIdInfo,
+ setIdNewStrictness, setIdArity
)
import IdInfo
import Var
%************************************************************************
\begin{code}
-data Level = InlineCtxt -- A level that's used only for
- -- the context parameter ctxt_lvl
- | Level Int -- Level number of enclosing lambdas
+data Level = Level Int -- Level number of enclosing lambdas
Int -- Number of big-lambda and/or case expressions between
-- here and the nearest enclosing lambda
\end{code}
type LevelledExpr = TaggedExpr Level
type LevelledBind = TaggedBind Level
-tOP_LEVEL, iNLINE_CTXT :: Level
+tOP_LEVEL :: Level
tOP_LEVEL = Level 0 0
-iNLINE_CTXT = InlineCtxt
incMajorLvl :: Level -> Level
--- For InlineCtxt we ignore any inc's; we don't want
--- to do any floating at all; see notes above
-incMajorLvl InlineCtxt = InlineCtxt
incMajorLvl (Level major _) = Level (major + 1) 0
incMinorLvl :: Level -> Level
-incMinorLvl InlineCtxt = InlineCtxt
incMinorLvl (Level major minor) = Level major (minor+1)
maxLvl :: Level -> Level -> Level
-maxLvl InlineCtxt l2 = l2
-maxLvl l1 InlineCtxt = l1
maxLvl l1@(Level maj1 min1) l2@(Level maj2 min2)
| (maj1 > maj2) || (maj1 == maj2 && min1 > min2) = l1
| otherwise = l2
ltLvl :: Level -> Level -> Bool
-ltLvl _ InlineCtxt = False
-ltLvl InlineCtxt (Level _ _) = True
ltLvl (Level maj1 min1) (Level maj2 min2)
= (maj1 < maj2) || (maj1 == maj2 && min1 < min2)
ltMajLvl :: Level -> Level -> Bool
-- Tells if one level belongs to a difft *lambda* level to another
-ltMajLvl _ InlineCtxt = False
-ltMajLvl InlineCtxt (Level maj2 _) = 0 < maj2
ltMajLvl (Level maj1 _) (Level maj2 _) = maj1 < maj2
isTopLvl :: Level -> Bool
isTopLvl (Level 0 0) = True
isTopLvl _ = False
-isInlineCtxt :: Level -> Bool
-isInlineCtxt InlineCtxt = True
-isInlineCtxt _ = False
-
instance Outputable Level where
- ppr InlineCtxt = text "<INLINE>"
ppr (Level maj min) = hcat [ char '<', int maj, char ',', int min, char '>' ]
instance Eq Level where
- InlineCtxt == InlineCtxt = True
(Level maj1 min1) == (Level maj2 min2) = maj1 == maj2 && min1 == min2
- _ == _ = False
\end{code}
-> [LevelledBind]
setLevels float_lams binds us
- = initLvl us (do_them binds)
+ = initLvl us (do_them init_env binds)
where
- -- "do_them"'s main business is to thread the monad along
- -- It gives each top binding the same empty envt, because
- -- things unbound in the envt have level number zero implicitly
- do_them :: [CoreBind] -> LvlM [LevelledBind]
-
- do_them [] = return []
- do_them (b:bs) = do
- (lvld_bind, _) <- lvlTopBind init_env b
- lvld_binds <- do_them bs
- return (lvld_bind : lvld_binds)
-
init_env = initialEnv float_lams
+ do_them :: LevelEnv -> [CoreBind] -> LvlM [LevelledBind]
+ do_them _ [] = return []
+ do_them env (b:bs)
+ = do { (lvld_bind, env') <- lvlTopBind env b
+ ; lvld_binds <- do_them env' bs
+ ; return (lvld_bind : lvld_binds) }
+
lvlTopBind :: LevelEnv -> Bind Id -> LvlM (LevelledBind, LevelEnv)
lvlTopBind env (NonRec binder rhs)
= lvlBind TopLevel tOP_LEVEL env (AnnNonRec binder (freeVars rhs))
-- We don't do MFE on partial applications generally,
-- but we do if the function is big and hairy, like a case
-lvlExpr _ env (_, AnnNote InlineMe expr) = do
--- Don't float anything out of an InlineMe; hence the iNLINE_CTXT
- expr' <- lvlExpr iNLINE_CTXT env expr
- return (Note InlineMe expr')
-
lvlExpr ctxt_lvl env (_, AnnNote note expr) = do
expr' <- lvlExpr ctxt_lvl env expr
return (Note note expr')
@lvlMFE@ is just like @lvlExpr@, except that it might let-bind
the expression, so that it can itself be floated.
-[NOTE: unlifted MFEs]
+Note [Unlifted MFEs]
+~~~~~~~~~~~~~~~~~~~~
We don't float unlifted MFEs, which potentially loses big opportunites.
For example:
\x -> f (h y)
where h :: Int -> Int# is expensive. We'd like to float the (h y) outside
the \x, but we don't because it's unboxed. Possible solution: box it.
+Note [Bottoming floats]
+~~~~~~~~~~~~~~~~~~~~~~~
+If we see
+ f = \x. g (error "urk")
+we'd like to float the call to error, to get
+ lvl = error "urk"
+ f = \x. g lvl
+But, it's very helpful for lvl to get a strictness signature, so that,
+for example, its unfolding is not exposed in interface files (unnecessary).
+But this float-out might occur after strictness analysis. So we use the
+cheap-and-cheerful exprBotStrictness_maybe function.
+
+Note [Case MFEs]
+~~~~~~~~~~~~~~~~
+We don't float a case expression as an MFE from a strict context. Why not?
+Because in doing so we share a tiny bit of computation (the switch) but
+in exchange we build a thunk, which is bad. This case reduces allocation
+by 7% in spectral/puzzle (a rather strange benchmark) and 1.2% in real/fem.
+Doesn't change any other allocation at all.
+
\begin{code}
lvlMFE :: Bool -- True <=> strict context [body of case or let]
-> Level -- Level of innermost enclosing lambda/tylam
lvlMFE _ _ _ (_, AnnType ty)
= return (Type ty)
+-- No point in floating out an expression wrapped in a coercion or note
+-- If we do we'll transform lvl = e |> co
+-- to lvl' = e; lvl = lvl' |> co
+-- and then inline lvl. Better just to float out the payload.
+lvlMFE strict_ctxt ctxt_lvl env (_, AnnNote n e)
+ = do { e' <- lvlMFE strict_ctxt ctxt_lvl env e
+ ; return (Note n e') }
+
+lvlMFE strict_ctxt ctxt_lvl env (_, AnnCast e co)
+ = do { e' <- lvlMFE strict_ctxt ctxt_lvl env e
+ ; return (Cast e' co) }
+
+-- Note [Case MFEs]
+lvlMFE True ctxt_lvl env e@(_, AnnCase {})
+ = lvlExpr ctxt_lvl env e -- Don't share cases
lvlMFE strict_ctxt ctxt_lvl env ann_expr@(fvs, _)
- | isUnLiftedType ty -- Can't let-bind it; see [NOTE: unlifted MFEs]
- || isInlineCtxt ctxt_lvl -- Don't float out of an __inline__ context
+ | isUnLiftedType ty -- Can't let-bind it; see Note [Unlifted MFEs]
|| exprIsTrivial expr -- Never float if it's trivial
|| not good_destination
= -- Don't float it out
| otherwise -- Float it out!
= do expr' <- lvlFloatRhs abs_vars dest_lvl env ann_expr
var <- newLvlVar "lvl" abs_vars ty
- return (Let (NonRec (TB var dest_lvl) expr')
- (mkVarApps (Var var) abs_vars))
+ -- Note [Bottoming floats]
+ let var_w_str = case exprBotStrictness_maybe expr of
+ Just (arity,str) -> var `setIdArity` arity
+ `setIdNewStrictness` str
+ Nothing -> var
+ return (Let (NonRec (TB var_w_str dest_lvl) expr')
+ (mkVarApps (Var var_w_str) abs_vars))
where
expr = deAnnotate ann_expr
ty = exprType expr
-> LvlM (LevelledBind, LevelEnv)
lvlBind top_lvl ctxt_lvl env (AnnNonRec bndr rhs@(rhs_fvs,_))
- | isInlineCtxt ctxt_lvl -- Don't do anything inside InlineMe
+ | isTyVar bndr -- Don't do anything for TyVar binders
+ -- (simplifier gets rid of them pronto)
= do rhs' <- lvlExpr ctxt_lvl env rhs
return (NonRec (TB bndr ctxt_lvl) rhs', env)
\begin{code}
lvlBind top_lvl ctxt_lvl env (AnnRec pairs)
- | isInlineCtxt ctxt_lvl -- Don't do anything inside InlineMe
- = do rhss' <- mapM (lvlExpr ctxt_lvl env) rhss
- return (Rec ([TB b ctxt_lvl | b <- bndrs] `zip` rhss'), env)
-
| null abs_vars
= do (new_env, new_bndrs) <- cloneRecVars top_lvl env bndrs ctxt_lvl dest_lvl
new_rhss <- mapM (lvlExpr ctxt_lvl new_env) rhss
return (Rec ([TB b dest_lvl | b <- new_bndrs] `zip` new_rhss), new_env)
- | isSingleton pairs && count isIdVar abs_vars > 1
+ | isSingleton pairs && count isId abs_vars > 1
= do -- Special case for self recursion where there are
-- several variables carried around: build a local loop:
-- poly_f = \abs_vars. \lam_vars . letrec f = \lam_vars. rhs in f lam_vars
[] bndrs
where
go old_lvl bumped_major rev_lvld_bndrs (bndr:bndrs)
- | isIdVar bndr && -- Go to the next major level if this is a value binder,
+ | isId bndr && -- Go to the next major level if this is a value binder,
not bumped_major && -- and we havn't already gone to the next level (one jump per group)
not (isOneShotLambda bndr) -- and it isn't a one-shot lambda
= go new_lvl True (TB bndr new_lvl : rev_lvld_bndrs) bndrs
-- We may only want to do this if there are sufficiently few free
-- variables. We certainly only want to do it for values, and not for
-- constructors. So the simple thing is just to look for lambdas
-isFunction (_, AnnLam b e) | isIdVar b = True
+isFunction (_, AnnLam b e) | isId b = True
| otherwise = isFunction e
isFunction (_, AnnNote _ e) = isFunction e
isFunction _ = False
initialEnv float_lams = (float_lams, emptyVarEnv, emptySubst, emptyVarEnv)
floatLams :: LevelEnv -> Bool
-floatLams (FloatOutSw float_lams _, _, _, _) = float_lams
+floatLams (fos, _, _, _) = floatOutLambdas fos
floatConsts :: LevelEnv -> Bool
-floatConsts (FloatOutSw _ float_consts, _, _, _) = float_consts
+floatConsts (fos, _, _, _) = floatOutConstants fos
extendLvlEnv :: LevelEnv -> [TaggedBndr Level] -> LevelEnv
-- Used when *not* cloning
-- incorrectly, because the SubstEnv was still lying around. Ouch!
-- KSW 2000-07.
+extendInScopeEnv :: LevelEnv -> Var -> LevelEnv
+extendInScopeEnv (fl, le, subst, ids) v = (fl, le, extendInScope subst v, ids)
+
+extendInScopeEnvList :: LevelEnv -> [Var] -> LevelEnv
+extendInScopeEnvList (fl, le, subst, ids) vs = (fl, le, extendInScopeList subst vs, ids)
+
-- extendCaseBndrLvlEnv adds the mapping case-bndr->scrut-var if it can
-- (see point 4 of the module overview comment)
extendCaseBndrLvlEnv :: LevelEnv -> Expr (TaggedBndr Level) -> Var -> Level
Nothing -> [in_var])
max_out out_var lvl
- | isIdVar out_var = case lookupVarEnv lvl_env out_var of
+ | isId out_var = case lookupVarEnv lvl_env out_var of
Just lvl' -> maxLvl lvl' lvl
Nothing -> lvl
- | otherwise = lvl -- Ignore tyvars in *maxIdLevel*
+ | otherwise = lvl -- Ignore tyvars in *maxIdLevel*
lookupVar :: LevelEnv -> Id -> LevelledExpr
lookupVar (_, _, _, id_env) v = case lookupVarEnv id_env v of
-- We are going to lambda-abstract, so nuke any IdInfo,
-- and add the tyvars of the Id (if necessary)
- zap v | isIdVar v = WARN( workerExists (idWorkerInfo v) ||
+ zap v | isId v = WARN( isInlineRule (idUnfolding v) ||
not (isEmptySpecInfo (idSpecialisation v)),
text "absVarsOf: discarding info on" <+> ppr v )
setIdInfo v vanillaIdInfo
-- we must look in x's type
-- And similarly if x is a coercion variable.
absVarsOf id_env v
- | isIdVar v = [av2 | av1 <- lookup_avs v
+ | isId v = [av2 | av1 <- lookup_avs v
, av2 <- add_tyvars av1]
| isCoVar v = add_tyvars v
| otherwise = [v]
let new_bndrs = zipWith mk_poly_bndr bndrs uniqs
return (extendPolyLvlEnv dest_lvl env abs_vars (bndrs `zip` new_bndrs), new_bndrs)
where
- mk_poly_bndr bndr uniq = transferPolyIdInfo bndr $ -- Note [transferPolyIdInfo] in Id.lhs
+ mk_poly_bndr bndr uniq = transferPolyIdInfo bndr abs_vars $ -- Note [transferPolyIdInfo] in Id.lhs
mkSysLocal (mkFastString str) uniq poly_ty
where
str = "poly_" ++ occNameString (getOccName bndr)
cloneVar :: TopLevelFlag -> LevelEnv -> Id -> Level -> Level -> LvlM (LevelEnv, Id)
cloneVar TopLevel env v _ _
- = return (env, v) -- Don't clone top level things
+ = return (extendInScopeEnv env v, v) -- Don't clone top level things
+ -- But do extend the in-scope env, to satisfy the in-scope invariant
+
cloneVar NotTopLevel env@(_,_,subst,_) v ctxt_lvl dest_lvl
- = ASSERT( isIdVar v ) do
+ = ASSERT( isId v ) do
us <- getUniqueSupplyM
let
(subst', v1) = cloneIdBndr subst us v
cloneRecVars :: TopLevelFlag -> LevelEnv -> [Id] -> Level -> Level -> LvlM (LevelEnv, [Id])
cloneRecVars TopLevel env vs _ _
- = return (env, vs) -- Don't clone top level things
+ = return (extendInScopeEnvList env vs, vs) -- Don't clone top level things
cloneRecVars NotTopLevel env@(_,_,subst,_) vs ctxt_lvl dest_lvl
- = ASSERT( all isIdVar vs ) do
+ = ASSERT( all isId vs ) do
us <- getUniqueSupplyM
let
(subst', vs1) = cloneRecIdBndrs subst us vs