-- Arity
ArityInfo,
- exactArity, unknownArity, hasArity,
- arityInfo, setArityInfo, ppArityInfo, arityLowerBound,
+ unknownArity,
+ arityInfo, setArityInfo, ppArityInfo,
-- New demand and strictness info
newStrictnessInfo, setNewStrictnessInfo, mkNewStrictnessInfo,
demandInfo, setDemandInfo,
-- Inline prags
- InlinePragInfo(..),
- inlinePragInfo, setInlinePragInfo, pprInlinePragInfo,
- isNeverInlinePrag, neverInlinePrag,
+ InlinePragInfo,
+ inlinePragInfo, setInlinePragInfo,
-- Occurrence info
OccInfo(..), isFragileOcc, isDeadOcc, isLoopBreaker,
specInfo, setSpecInfo,
-- CG info
- CgInfo(..), cgInfo, setCgInfo, cgMayHaveCafRefs, pprCgInfo,
- cgArity, cgCafInfo, vanillaCgInfo,
+ CgInfo(..), cgInfo, setCgInfo, pprCgInfo,
+ cgCafInfo, vanillaCgInfo,
CgInfoEnv, lookupCgInfo,
- setCgArity,
-- CAF info
CafInfo(..), ppCafInfo, setCafInfo, mayHaveCafRefs,
import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
InsideLam, insideLam, notInsideLam,
OneBranch, oneBranch, notOneBranch,
- Arity
+ Arity,
+ Activation(..)
)
import DataCon ( DataCon )
import ForeignCall ( ForeignCall )
import FieldLabel ( FieldLabel )
import Type ( usOnce, usMany )
import Demand hiding( Demand )
-import NewDemand ( Demand(..), Keepity(..), Deferredness(..), DmdResult(..),
- lazyDmd, topDmd,
- StrictSig, mkStrictSig,
- DmdType, mkTopDmdType
+import qualified Demand
+import NewDemand ( Demand(..), Keepity(..), DmdResult(..),
+ lazyDmd, topDmd, dmdTypeDepth, isStrictDmd,
+ StrictSig, mkStrictSig, mkTopDmdType
)
import Outputable
import Util ( seqList )
`setOccInfo`,
`setCgInfo`,
`setCafInfo`,
- `setCgArity`,
`setNewStrictnessInfo`,
`setNewDemandInfo`
-- infixl so you can say (id `set` a `set` b)
\begin{code}
mkNewStrictnessInfo :: Id -> Arity -> Demand.StrictnessInfo -> CprInfo -> StrictSig
-mkNewStrictnessInfo id arity Demand.NoStrictnessInfo cpr
- = mkStrictSig id arity $
- mkTopDmdType (replicate arity lazyDmd) (newRes False cpr)
-
mkNewStrictnessInfo id arity (Demand.StrictnessInfo ds res) cpr
- = mkStrictSig id arity $
- mkTopDmdType (take arity (map newDemand ds)) (newRes res cpr)
+ | length ds <= arity
-- Sometimes the old strictness analyser has more
-- demands than the arity justifies
+ = mk_strict_sig id arity $
+ mkTopDmdType (map newDemand ds) (newRes res cpr)
+
+mkNewStrictnessInfo id arity other cpr
+ = -- Either no strictness info, or arity is too small
+ -- In either case we can't say anything useful
+ mk_strict_sig id arity $
+ mkTopDmdType (replicate arity lazyDmd) (newRes False cpr)
+
+mk_strict_sig id arity dmd_ty
+ = WARN( arity /= dmdTypeDepth dmd_ty, ppr id <+> (ppr arity $$ ppr dmd_ty) )
+ mkStrictSig dmd_ty
newRes True _ = BotRes
newRes False ReturnsCPR = RetCPR
newDemand (WwLazy True) = Abs
newDemand (WwLazy False) = Lazy
newDemand WwStrict = Eval
-newDemand (WwUnpack unpk ds) = Seq Drop Now (map newDemand ds)
+newDemand (WwUnpack unpk ds) = Seq Drop (map newDemand ds)
newDemand WwPrim = Lazy
newDemand WwEnum = Eval
oldDemand :: NewDemand.Demand -> Demand.Demand
-oldDemand Abs = WwLazy True
-oldDemand Lazy = WwLazy False
-oldDemand Eval = WwStrict
-oldDemand (Seq _ _ ds) = WwUnpack True (map oldDemand ds)
-oldDemand (Call _) = WwStrict
+oldDemand Abs = WwLazy True
+oldDemand Lazy = WwLazy False
+oldDemand Bot = WwStrict
+oldDemand Err = WwStrict
+oldDemand Eval = WwStrict
+oldDemand (Seq _ ds) = WwUnpack True (map oldDemand ds)
+oldDemand (Call _) = WwStrict
\end{code}
inlinePragInfo :: InlinePragInfo, -- Inline pragma
occInfo :: OccInfo, -- How it occurs
- newStrictnessInfo :: Maybe StrictSig,
+ newStrictnessInfo :: Maybe StrictSig, -- Reason for Maybe: the DmdAnal phase needs to
+ -- know whether whether this is the first visit,
+ -- so it can assign botSig. Other customers want
+ -- topSig. So Nothing is good.
newDemandInfo :: Demand
}
\begin{code}
setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
-setSpecInfo info sp = PSEQ sp (info { specInfo = sp })
+setSpecInfo info sp = sp `seq` info { specInfo = sp }
setTyGenInfo info tg = tg `seq` info { tyGenInfo = tg }
setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
setOccInfo info oc = oc `seq` info { occInfo = oc }
-- Try to avoid spack leaks by seq'ing
setUnfoldingInfo info uf
- | isEvaldUnfolding uf && isStrict (demandInfo info)
+ | isEvaldUnfolding uf
-- If the unfolding is a value, the demand info may
-- go pear-shaped, so we nuke it. Example:
-- let x = (a,b) in
-- let x = (a,b) in h a b x
-- and now x is not demanded (I'm assuming h is lazy)
-- This really happens. The solution here is a bit ad hoc...
- = info { unfoldingInfo = uf, demandInfo = wwLazy }
+ = info { unfoldingInfo = uf, newDemandInfo = Lazy }
| otherwise
-- We do *not* seq on the unfolding info, For some reason, doing so
= info { unfoldingInfo = uf }
setDemandInfo info dd = info { demandInfo = dd }
-setArityInfo info ar = info { arityInfo = Just ar }
+setArityInfo info ar = info { arityInfo = ar }
setCgInfo info cg = info { cgInfo = cg }
setCprInfo info cp = info { cprInfo = cp }
setLBVarInfo info lb = info { lbvarInfo = lb }
unfoldingInfo = noUnfolding,
cprInfo = NoCPRInfo,
lbvarInfo = NoLBVarInfo,
- inlinePragInfo = NoInlinePragInfo,
+ inlinePragInfo = AlwaysActive,
occInfo = NoOccInfo,
newDemandInfo = topDmd,
newStrictnessInfo = Nothing
}
noCafNoTyGenIdInfo = vanillaIdInfo `setTyGenInfo` TyGenNever
- `setCgInfo` (CgInfo 0 NoCafRefs)
+ `setCgInfo` CgInfo NoCafRefs
-- Used for built-in type Ids in MkId.
-- Many built-in things have fixed types, so we shouldn't
-- run around generalising them
besides the code-generator need arity info!)
\begin{code}
-type ArityInfo = Maybe Arity
+type ArityInfo = Arity
-- A partial application of this Id to up to n-1 value arguments
-- does essentially no work. That is not necessarily the
-- same as saying that it has n leading lambdas, because coerces
-- an extra lambda floats up to the binding site.
seqArity :: ArityInfo -> ()
-seqArity a = arityLowerBound a `seq` ()
-
-exactArity = Just
-unknownArity = Nothing
-
-arityLowerBound :: ArityInfo -> Arity
-arityLowerBound Nothing = 0
-arityLowerBound (Just n) = n
+seqArity a = a `seq` ()
-hasArity :: ArityInfo -> Bool
-hasArity Nothing = False
-hasArity other = True
+unknownArity = 0 :: Arity
-ppArityInfo Nothing = empty
-ppArityInfo (Just arity) = hsep [ptext SLIT("Arity"), int arity]
+ppArityInfo 0 = empty
+ppArityInfo n = hsep [ptext SLIT("Arity"), int n]
\end{code}
%************************************************************************
%************************************************************************
\begin{code}
-data InlinePragInfo
- = NoInlinePragInfo
- | IMustNotBeINLINEd Bool -- True <=> came from an INLINE prag, False <=> came from a NOINLINE prag
- (Maybe Int) -- Phase number from pragma, if any
- deriving( Eq )
- -- The True, Nothing case doesn't need to be recorded
-
- -- SEE COMMENTS WITH CoreUnfold.blackListed on the
- -- exact significance of the IMustNotBeINLINEd pragma
-
-isNeverInlinePrag :: InlinePragInfo -> Bool
-isNeverInlinePrag (IMustNotBeINLINEd _ Nothing) = True
-isNeverInlinePrag other = False
-
-neverInlinePrag :: InlinePragInfo
-neverInlinePrag = IMustNotBeINLINEd True{-should be False? --SDM -} Nothing
-
-instance Outputable InlinePragInfo where
- -- This is now parsed in interface files
- ppr NoInlinePragInfo = empty
- ppr other_prag = ptext SLIT("__U") <> pprInlinePragInfo other_prag
-
-pprInlinePragInfo NoInlinePragInfo = empty
-pprInlinePragInfo (IMustNotBeINLINEd True Nothing) = empty
-pprInlinePragInfo (IMustNotBeINLINEd True (Just n)) = brackets (int n)
-pprInlinePragInfo (IMustNotBeINLINEd False Nothing) = brackets (char '!')
-pprInlinePragInfo (IMustNotBeINLINEd False (Just n)) = brackets (char '!' <> int n)
-
-instance Show InlinePragInfo where
- showsPrec p prag = showsPrecSDoc p (ppr prag)
+type InlinePragInfo = Activation
+ -- Tells when the inlining is active
+ -- When it is active the thing may be inlined, depending on how
+ -- big it is.
+ --
+ -- If there was an INLINE pragma, then as a separate matter, the
+ -- RHS will have been made to look small with a CoreSyn Inline Note
\end{code}
downstream, by the code generator.
\begin{code}
-data CgInfo = CgInfo
- !Arity -- Exact arity for calling purposes
- !CafInfo
-#ifdef DEBUG
+#ifndef DEBUG
+newtype CgInfo = CgInfo CafInfo -- We are back to only having CafRefs in CgInfo
+noCgInfo = panic "NoCgInfo!"
+#else
+data CgInfo = CgInfo CafInfo
| NoCgInfo -- In debug mode we don't want a black hole here
-- See Id.idCgInfo
-
-- noCgInfo is used for local Ids, which shouldn't need any CgInfo
noCgInfo = NoCgInfo
-#else
-noCgInfo = panic "NoCgInfo!"
#endif
-cgArity (CgInfo arity _) = arity
-cgCafInfo (CgInfo _ caf_info) = caf_info
-
-setCafInfo info caf_info =
- case cgInfo info of { CgInfo arity _ ->
- info `setCgInfo` CgInfo arity caf_info }
-
-setCgArity info arity =
- case cgInfo info of { CgInfo _ caf_info ->
- info `setCgInfo` CgInfo arity caf_info }
+cgCafInfo (CgInfo caf_info) = caf_info
-cgMayHaveCafRefs (CgInfo _ caf_info) = mayHaveCafRefs caf_info
+setCafInfo info caf_info = info `setCgInfo` CgInfo caf_info
seqCg c = c `seq` () -- fields are strict anyhow
-vanillaCgInfo = CgInfo 0 MayHaveCafRefs -- Definitely safe
+vanillaCgInfo = CgInfo MayHaveCafRefs -- Definitely safe
-- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
seqCaf c = c `seq` ()
-pprCgInfo (CgInfo arity caf_info) = ppArity arity <+> ppCafInfo caf_info
+pprCgInfo (CgInfo caf_info) = ppCafInfo caf_info
ppArity 0 = empty
ppArity n = hsep [ptext SLIT("__A"), int n]
\begin{code}
zapLamInfo :: IdInfo -> Maybe IdInfo
-zapLamInfo info@(IdInfo {occInfo = occ, demandInfo = demand})
- | is_safe_occ && not (isStrict demand)
+zapLamInfo info@(IdInfo {occInfo = occ, newDemandInfo = demand})
+ | is_safe_occ && not (isStrictDmd demand)
= Nothing
| otherwise
= Just (info {occInfo = safe_occ,
- demandInfo = wwLazy})
+ newDemandInfo = Lazy})
where
-- The "unsafe" occ info is the ones that say I'm not in a lambda
-- because that might not be true for an unsaturated lambda
\begin{code}
zapDemandInfo :: IdInfo -> Maybe IdInfo
-zapDemandInfo info@(IdInfo {demandInfo = demand})
- | not (isStrict demand) = Nothing
- | otherwise = Just (info {demandInfo = wwLazy})
+zapDemandInfo info@(IdInfo {newDemandInfo = demand})
+ | not (isStrictDmd demand) = Nothing
+ | otherwise = Just (info {newDemandInfo = Lazy})
\end{code}
projects / ghc-hetmet.git / blobdiff