GlobalIdDetails(..), notGlobalId, -- Not abstract
IdInfo, -- Abstract
- vanillaIdInfo, noCafNoTyGenIdInfo,
+ vanillaIdInfo, noCafIdInfo, hasCafIdInfo,
seqIdInfo, megaSeqIdInfo,
-- Zapping
arityInfo, setArityInfo, ppArityInfo,
-- New demand and strictness info
- newStrictnessInfo, setNewStrictnessInfo, mkNewStrictnessInfo,
- newDemandInfo, setNewDemandInfo, newDemand, oldDemand,
+ newStrictnessInfo, setNewStrictnessInfo,
+ newDemandInfo, setNewDemandInfo, pprNewStrictness,
-- Strictness; imported from Demand
StrictnessInfo(..),
mkStrictnessInfo, noStrictnessInfo,
ppStrictnessInfo,isBottomingStrictness,
- strictnessInfo, setStrictnessInfo,
-
- -- Usage generalisation
- TyGenInfo(..),
- tyGenInfo, setTyGenInfo,
- noTyGenInfo, isNoTyGenInfo, ppTyGenInfo, tyGenInfoString,
+ setAllStrictnessInfo,
-- Worker
WorkerInfo(..), workerExists, wrapperArity, workerId,
-- Unfolding
unfoldingInfo, setUnfoldingInfo,
- -- DemandInfo
+#ifdef OLD_STRICTNESS
+ -- Old DemandInfo and StrictnessInfo
demandInfo, setDemandInfo,
+ strictnessInfo, setStrictnessInfo,
+ cprInfoFromNewStrictness,
+ oldStrictnessFromNew, newStrictnessFromOld,
+ oldDemand, newDemand,
+
+ -- Constructed Product Result Info
+ CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
+#endif
-- Inline prags
InlinePragInfo,
-- CAF info
CafInfo(..), ppCafInfo, setCafInfo, mayHaveCafRefs,
- -- Constructed Product Result Info
- CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
-
-- Lambda-bound variable info
LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
) where
import DataCon ( DataCon )
import ForeignCall ( ForeignCall )
import FieldLabel ( FieldLabel )
-import Type ( usOnce, usMany )
-import Demand hiding( Demand )
+import Type ( usOnce )
+import Demand hiding( Demand, seqDemand )
import qualified Demand
-import NewDemand ( Demand(..), Keepity(..), DmdResult(..),
- lazyDmd, topDmd, dmdTypeDepth, isStrictDmd,
- StrictSig, mkStrictSig, mkTopDmdType
- )
+import NewDemand
import Outputable
-import Util ( seqList )
+import Maybe ( isJust )
+#ifdef OLD_STRICTNESS
+import Util ( listLengthCmp )
import List ( replicate )
+#endif
-infixl 1 `setDemandInfo`,
- `setTyGenInfo`,
- `setStrictnessInfo`,
- `setSpecInfo`,
+-- infixl so you can say (id `set` a `set` b)
+infixl 1 `setSpecInfo`,
`setArityInfo`,
`setInlinePragInfo`,
`setUnfoldingInfo`,
- `setCprInfo`,
`setWorkerInfo`,
`setLBVarInfo`,
`setOccInfo`,
`setCgInfo`,
`setCafInfo`,
`setNewStrictnessInfo`,
+ `setAllStrictnessInfo`,
`setNewDemandInfo`
- -- infixl so you can say (id `set` a `set` b)
+#ifdef OLD_STRICTNESS
+ , `setCprInfo`
+ , `setDemandInfo`
+ , `setStrictnessInfo`
+#endif
\end{code}
%************************************************************************
To be removed later
\begin{code}
-mkNewStrictnessInfo :: Id -> Arity -> Demand.StrictnessInfo -> CprInfo -> StrictSig
-mkNewStrictnessInfo id arity (Demand.StrictnessInfo ds res) cpr
- | length ds <= arity
+-- setAllStrictnessInfo :: IdInfo -> Maybe StrictSig -> IdInfo
+-- Set old and new strictness info
+setAllStrictnessInfo info Nothing
+ = info { newStrictnessInfo = Nothing
+#ifdef OLD_STRICTNESS
+ , strictnessInfo = NoStrictnessInfo
+ , cprInfo = NoCPRInfo
+#endif
+ }
+
+setAllStrictnessInfo info (Just sig)
+ = info { newStrictnessInfo = Just sig
+#ifdef OLD_STRICTNESS
+ , strictnessInfo = oldStrictnessFromNew sig
+ , cprInfo = cprInfoFromNewStrictness sig
+#endif
+ }
+
+seqNewStrictnessInfo Nothing = ()
+seqNewStrictnessInfo (Just ty) = seqStrictSig ty
+
+pprNewStrictness Nothing = empty
+pprNewStrictness (Just sig) = ftext FSLIT("Str:") <+> ppr sig
+
+#ifdef OLD_STRICTNESS
+oldStrictnessFromNew :: StrictSig -> Demand.StrictnessInfo
+oldStrictnessFromNew sig = mkStrictnessInfo (map oldDemand dmds, isBotRes res_info)
+ where
+ (dmds, res_info) = splitStrictSig sig
+
+cprInfoFromNewStrictness :: StrictSig -> CprInfo
+cprInfoFromNewStrictness sig = case strictSigResInfo sig of
+ RetCPR -> ReturnsCPR
+ other -> NoCPRInfo
+
+newStrictnessFromOld :: Name -> Arity -> Demand.StrictnessInfo -> CprInfo -> StrictSig
+newStrictnessFromOld name arity (Demand.StrictnessInfo ds res) cpr
+ | listLengthCmp ds arity /= GT -- length ds <= arity
-- Sometimes the old strictness analyser has more
-- demands than the arity justifies
- = mk_strict_sig id arity $
+ = mk_strict_sig name arity $
mkTopDmdType (map newDemand ds) (newRes res cpr)
-mkNewStrictnessInfo id arity other cpr
+newStrictnessFromOld name 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 $
+ mk_strict_sig name 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) )
+mk_strict_sig name arity dmd_ty
+ = WARN( arity /= dmdTypeDepth dmd_ty, ppr name <+> (ppr arity $$ ppr dmd_ty) )
mkStrictSig dmd_ty
newRes True _ = BotRes
-newRes False ReturnsCPR = RetCPR
+newRes False ReturnsCPR = retCPR
newRes False NoCPRInfo = TopRes
newDemand :: Demand.Demand -> NewDemand.Demand
newDemand (WwLazy True) = Abs
-newDemand (WwLazy False) = Lazy
-newDemand WwStrict = Eval
-newDemand (WwUnpack unpk ds) = Seq Drop (map newDemand ds)
-newDemand WwPrim = Lazy
-newDemand WwEnum = Eval
+newDemand (WwLazy False) = lazyDmd
+newDemand WwStrict = evalDmd
+newDemand (WwUnpack unpk ds) = Eval (Prod (map newDemand ds))
+newDemand WwPrim = lazyDmd
+newDemand WwEnum = evalDmd
oldDemand :: NewDemand.Demand -> Demand.Demand
-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
+oldDemand Abs = WwLazy True
+oldDemand Top = WwLazy False
+oldDemand Bot = WwStrict
+oldDemand (Box Bot) = WwStrict
+oldDemand (Box Abs) = WwLazy False
+oldDemand (Box (Eval _)) = WwStrict -- Pass box only
+oldDemand (Defer d) = WwLazy False
+oldDemand (Eval (Prod ds)) = WwUnpack True (map oldDemand ds)
+oldDemand (Eval (Poly _)) = WwStrict
+oldDemand (Call _) = WwStrict
+
+#endif /* OLD_STRICTNESS */
+\end{code}
+
+
+\begin{code}
+seqNewDemandInfo Nothing = ()
+seqNewDemandInfo (Just dmd) = seqDemand dmd
\end{code}
\begin{code}
data IdInfo
= IdInfo {
- arityInfo :: ArityInfo, -- Its arity
- demandInfo :: Demand.Demand, -- Whether or not it is definitely demanded
+ arityInfo :: !ArityInfo, -- Its arity
specInfo :: CoreRules, -- Specialisations of this function which exist
- tyGenInfo :: TyGenInfo, -- Restrictions on usage-generalisation of this Id
+#ifdef OLD_STRICTNESS
+ cprInfo :: CprInfo, -- Function always constructs a product result
+ demandInfo :: Demand.Demand, -- Whether or not it is definitely demanded
strictnessInfo :: StrictnessInfo, -- Strictness properties
+#endif
workerInfo :: WorkerInfo, -- Pointer to Worker Function
unfoldingInfo :: Unfolding, -- Its unfolding
cgInfo :: CgInfo, -- Code generator info (arity, CAF info)
- cprInfo :: CprInfo, -- Function always constructs a product result
lbvarInfo :: LBVarInfo, -- Info about a lambda-bound variable
inlinePragInfo :: InlinePragInfo, -- Inline pragma
occInfo :: OccInfo, -- How it occurs
-- know whether whether this is the first visit,
-- so it can assign botSig. Other customers want
-- topSig. So Nothing is good.
- newDemandInfo :: Demand
+
+ newDemandInfo :: Maybe Demand -- Similarly we want to know if there's no
+ -- known demand yet, for when we are looking for
+ -- CPR info
}
seqIdInfo :: IdInfo -> ()
megaSeqIdInfo :: IdInfo -> ()
megaSeqIdInfo info
- = seqArity (arityInfo info) `seq`
- seqDemand (demandInfo info) `seq`
- seqRules (specInfo info) `seq`
- seqTyGenInfo (tyGenInfo info) `seq`
- seqStrictnessInfo (strictnessInfo info) `seq`
+ = seqRules (specInfo info) `seq`
seqWorker (workerInfo info) `seq`
--- seqUnfolding (unfoldingInfo info) `seq`
-- Omitting this improves runtimes a little, presumably because
-- some unfoldings are not calculated at all
+-- seqUnfolding (unfoldingInfo info) `seq`
+
+ seqNewDemandInfo (newDemandInfo info) `seq`
+ seqNewStrictnessInfo (newStrictnessInfo info) `seq`
+
+#ifdef OLD_STRICTNESS
+ Demand.seqDemand (demandInfo info) `seq`
+ seqStrictnessInfo (strictnessInfo info) `seq`
+ seqCpr (cprInfo info) `seq`
+#endif
-- CgInfo is involved in a loop, so we have to be careful not to seq it
-- too early.
-- seqCg (cgInfo info) `seq`
- seqCpr (cprInfo info) `seq`
seqLBVar (lbvarInfo info) `seq`
seqOccInfo (occInfo info)
\end{code}
\begin{code}
setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
-setSpecInfo info sp = PSEQ sp (info { specInfo = sp })
-setTyGenInfo info tg = tg `seq` info { tyGenInfo = tg }
+setSpecInfo info sp = sp `seq` info { specInfo = sp }
setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
setOccInfo info oc = oc `seq` info { occInfo = oc }
+#ifdef OLD_STRICTNESS
setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
+#endif
-- Try to avoid spack leaks by seq'ing
setUnfoldingInfo info uf
-- 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, newDemandInfo = Lazy }
+ = info { unfoldingInfo = uf, newDemandInfo = Nothing }
| otherwise
-- We do *not* seq on the unfolding info, For some reason, doing so
-- actually increases residency significantly.
= info { unfoldingInfo = uf }
+#ifdef OLD_STRICTNESS
setDemandInfo info dd = info { demandInfo = dd }
+setCprInfo info cp = info { cprInfo = cp }
+#endif
+
setArityInfo info ar = info { arityInfo = ar }
setCgInfo info cg = info { cgInfo = cg }
-setCprInfo info cp = info { cprInfo = cp }
-setLBVarInfo info lb = info { lbvarInfo = lb }
-setNewDemandInfo info dd = info { newDemandInfo = dd }
-setNewStrictnessInfo info dd = info { newStrictnessInfo = dd }
+setLBVarInfo info lb = {-lb `seq`-} info { lbvarInfo = lb }
+
+setNewDemandInfo info dd = dd `seq` info { newDemandInfo = dd }
+setNewStrictnessInfo info dd = dd `seq` info { newStrictnessInfo = dd }
\end{code}
= IdInfo {
cgInfo = noCgInfo,
arityInfo = unknownArity,
+#ifdef OLD_STRICTNESS
+ cprInfo = NoCPRInfo,
demandInfo = wwLazy,
+ strictnessInfo = NoStrictnessInfo,
+#endif
specInfo = emptyCoreRules,
- tyGenInfo = noTyGenInfo,
workerInfo = NoWorker,
- strictnessInfo = NoStrictnessInfo,
unfoldingInfo = noUnfolding,
- cprInfo = NoCPRInfo,
lbvarInfo = NoLBVarInfo,
inlinePragInfo = AlwaysActive,
occInfo = NoOccInfo,
- newDemandInfo = topDmd,
+ newDemandInfo = Nothing,
newStrictnessInfo = Nothing
}
-noCafNoTyGenIdInfo = vanillaIdInfo `setTyGenInfo` TyGenNever
- `setCgInfo` CgInfo NoCafRefs
+hasCafIdInfo = vanillaIdInfo `setCgInfo` CgInfo MayHaveCafRefs
+noCafIdInfo = vanillaIdInfo `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
+ -- These must have a valid CgInfo set, so you can't
+ -- use vanillaIdInfo!
\end{code}
-- The arity might increase later in the compilation process, if
-- an extra lambda floats up to the binding site.
-seqArity :: ArityInfo -> ()
-seqArity a = a `seq` ()
-
unknownArity = 0 :: Arity
ppArityInfo 0 = empty
%************************************************************************
-%* *
-\subsection[TyGen-IdInfo]{Type generalisation info about an @Id@}
-%* *
-%************************************************************************
-
-Certain passes (notably usage inference) may change the type of an
-identifier, modifying all in-scope uses of that identifier
-appropriately to maintain type safety.
-
-However, some identifiers must not have their types changed in this
-way, because their types are conjured up in the front end of the
-compiler rather than being read from the interface file. Default
-methods, dictionary functions, record selectors, and others are in
-this category. (see comment at TcClassDcl.tcClassSig).
-
-To indicate this property, such identifiers are marked TyGenNever.
-
-Furthermore, if the usage inference generates a usage-specialised
-variant of a function, we must NOT re-infer a fully-generalised type
-at the next inference. This finer property is indicated by a
-TyGenUInfo on the identifier.
-
-\begin{code}
-data TyGenInfo
- = NoTyGenInfo -- no restriction on type generalisation
-
- | TyGenUInfo [Maybe Type] -- restrict generalisation of this Id to
- -- preserve specified usage annotations
-
- | TyGenNever -- never generalise the type of this Id
-\end{code}
-
-For TyGenUInfo, the list has one entry for each usage annotation on
-the type of the Id, in left-to-right pre-order (annotations come
-before the type they annotate). Nothing means no restriction; Just
-usOnce or Just usMany forces that annotation to that value. Other
-usage annotations are illegal.
-
-\begin{code}
-seqTyGenInfo :: TyGenInfo -> ()
-seqTyGenInfo NoTyGenInfo = ()
-seqTyGenInfo (TyGenUInfo us) = seqList us ()
-seqTyGenInfo TyGenNever = ()
-
-noTyGenInfo :: TyGenInfo
-noTyGenInfo = NoTyGenInfo
-
-isNoTyGenInfo :: TyGenInfo -> Bool
-isNoTyGenInfo NoTyGenInfo = True
-isNoTyGenInfo _ = False
-
--- NB: There's probably no need to write this information out to the interface file.
--- Why? Simply because imported identifiers never get their types re-inferred.
--- But it's definitely nice to see in dumps, it for debugging purposes.
-
-ppTyGenInfo :: TyGenInfo -> SDoc
-ppTyGenInfo NoTyGenInfo = empty
-ppTyGenInfo (TyGenUInfo us) = ptext SLIT("__G") <+> text (tyGenInfoString us)
-ppTyGenInfo TyGenNever = ptext SLIT("__G N")
-
-tyGenInfoString us = map go us
- where go Nothing = 'x' -- for legibility, choose
- go (Just u) | u `eqUsage` usOnce = '1' -- chars with identity
- | u `eqUsage` usMany = 'M' -- Z-encoding.
- go other = pprPanic "IdInfo.tyGenInfoString: unexpected annotation" (ppr other)
-
-instance Outputable TyGenInfo where
- ppr = ppTyGenInfo
-
-instance Show TyGenInfo where
- showsPrec p c = showsPrecSDoc p (ppr c)
-\end{code}
-
-
-%************************************************************************
%* *
\subsection[worker-IdInfo]{Worker info about an @Id@}
%* *
If this Id has a worker then we store a reference to it. Worker
functions are generated by the worker/wrapper pass. This uses
-information from the strictness and CPR analyses.
+information from strictness analysis.
There might not be a worker, even for a strict function, because:
(a) the function might be small enough to inline, so no need
-- w/w split. See comments in MkIface.ifaceId, with the 'Worker' code.
seqWorker :: WorkerInfo -> ()
-seqWorker (HasWorker id _) = id `seq` ()
+seqWorker (HasWorker id a) = id `seq` a `seq` ()
seqWorker NoWorker = ()
ppWorkerInfo NoWorker = empty
downstream, by the code generator.
\begin{code}
-#ifndef DEBUG
+#ifndef OLD_STRICTNESS
newtype CgInfo = CgInfo CafInfo -- We are back to only having CafRefs in CgInfo
noCgInfo = panic "NoCgInfo!"
#else
also CPRs.
\begin{code}
+#ifdef OLD_STRICTNESS
data CprInfo
= NoCPRInfo
| ReturnsCPR -- Yes, this function returns a constructed product
-- We used to keep nested info about sub-components, but
-- we never used it so I threw it away
-\end{code}
-\begin{code}
seqCpr :: CprInfo -> ()
seqCpr ReturnsCPR = ()
seqCpr NoCPRInfo = ()
instance Show CprInfo where
showsPrec p c = showsPrecSDoc p (ppr c)
+#endif
\end{code}
-- property of the definition, but a property of the context.
pprLBVarInfo NoLBVarInfo = empty
pprLBVarInfo (LBVarInfo u) | u `eqUsage` usOnce
- = getPprStyle $ \ sty ->
- if ifaceStyle sty
- then empty
- else ptext SLIT("OneShot")
+ = ptext SLIT("OneShot")
| otherwise
= empty
\begin{code}
zapLamInfo :: IdInfo -> Maybe IdInfo
zapLamInfo info@(IdInfo {occInfo = occ, newDemandInfo = demand})
- | is_safe_occ && not (isStrictDmd demand)
+ | is_safe_occ occ && is_safe_dmd demand
= Nothing
| otherwise
- = Just (info {occInfo = safe_occ,
- newDemandInfo = Lazy})
+ = Just (info {occInfo = safe_occ, newDemandInfo = Nothing})
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
- is_safe_occ = case occ of
- OneOcc in_lam once -> in_lam
- other -> True
+ is_safe_occ (OneOcc in_lam once) = in_lam
+ is_safe_occ other = True
safe_occ = case occ of
OneOcc _ once -> OneOcc insideLam once
other -> occ
+
+ is_safe_dmd Nothing = True
+ is_safe_dmd (Just dmd) = not (isStrictDmd dmd)
\end{code}
\begin{code}
zapDemandInfo :: IdInfo -> Maybe IdInfo
-zapDemandInfo info@(IdInfo {newDemandInfo = demand})
- | not (isStrictDmd demand) = Nothing
- | otherwise = Just (info {newDemandInfo = Lazy})
+zapDemandInfo info@(IdInfo {newDemandInfo = dmd})
+ | isJust dmd = Just (info {newDemandInfo = Nothing})
+ | otherwise = Nothing
\end{code}
copyIdInfo :: IdInfo -- f_local
-> IdInfo -- f (the exported one)
-> IdInfo -- New info for f
-copyIdInfo f_local f = f { strictnessInfo = strictnessInfo f_local,
- workerInfo = workerInfo f_local,
- cprInfo = cprInfo f_local
+copyIdInfo f_local f = f { newStrictnessInfo = newStrictnessInfo f_local,
+#ifdef OLD_STRICTNESS
+ strictnessInfo = strictnessInfo f_local,
+ cprInfo = cprInfo f_local,
+#endif
+ workerInfo = workerInfo f_local
}
\end{code}