\begin{code}
module IdInfo (
+ GlobalIdDetails(..), notGlobalId, -- Not abstract
+
IdInfo, -- Abstract
+ vanillaIdInfo, noCafIdInfo,
+ seqIdInfo, megaSeqIdInfo,
- noIdInfo,
+ -- Zapping
+ zapLamInfo, zapDemandInfo,
-- Arity
- ArityInfo(..),
- exactArity, atLeastArity, unknownArity,
- arityInfo, setArityInfo, ppArityInfo, arityLowerBound,
-
- -- Strictness
- StrictnessInfo(..), -- Non-abstract
- mkStrictnessInfo,
- noStrictnessInfo, strictnessInfo,
- ppStrictnessInfo, setStrictnessInfo,
- isBottomingStrictness, appIsBottom,
+ ArityInfo,
+ unknownArity,
+ arityInfo, setArityInfo, ppArityInfo,
+
+ -- New demand and strictness info
+ newStrictnessInfo, setNewStrictnessInfo,
+ newDemandInfo, setNewDemandInfo, pprNewStrictness,
+ setAllStrictnessInfo,
+
+#ifdef OLD_STRICTNESS
+ -- Strictness; imported from Demand
+ StrictnessInfo(..),
+ mkStrictnessInfo, noStrictnessInfo,
+ ppStrictnessInfo,isBottomingStrictness,
+#endif
-- Worker
- WorkerInfo, workerExists,
- mkWorkerInfo, noWorkerInfo, workerInfo, setWorkerInfo,
- ppWorkerInfo,
+ WorkerInfo(..), workerExists, wrapperArity, workerId,
+ workerInfo, setWorkerInfo, ppWorkerInfo,
-- Unfolding
- unfoldingInfo, setUnfoldingInfo,
+ unfoldingInfo, setUnfoldingInfo, setUnfoldingInfoLazily,
- -- 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(..), OccInfo(..),
- inlinePragInfo, setInlinePragInfo, notInsideLambda,
+ InlinePragInfo,
+ inlinePragInfo, setInlinePragInfo,
- -- Specialisation
- IdSpecEnv, specInfo, setSpecInfo,
+ -- Occurrence info
+ OccInfo(..), isFragileOcc, isDeadOcc, isLoopBreaker,
+ InsideLam, OneBranch, insideLam, notInsideLam, oneBranch, notOneBranch,
+ occInfo, setOccInfo,
- -- Update
- UpdateInfo, UpdateSpec,
- mkUpdateInfo, updateInfo, updateInfoMaybe, ppUpdateInfo, setUpdateInfo,
+ -- Specialisation
+ SpecInfo(..), specInfo, setSpecInfo, isEmptySpecInfo,
+ specInfoFreeVars, specInfoRules, seqSpecInfo,
-- CAF info
- CafInfo(..), cafInfo, setCafInfo, ppCafInfo,
+ CafInfo(..), cafInfo, ppCafInfo, setCafInfo, mayHaveCafRefs,
- -- Constructed Product Result Info
- CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo
+ -- Lambda-bound variable info
+ LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
) where
#include "HsVersions.h"
-import {-# SOURCE #-} CoreUnfold ( Unfolding, noUnfolding )
-import {-# SOURCE #-} CoreSyn ( CoreExpr )
-
-import Id ( Id )
-import SpecEnv ( SpecEnv, emptySpecEnv )
-import Demand ( Demand, isLazy, wwLazy, pprDemands )
+import CoreSyn
+import Class ( Class )
+import PrimOp ( PrimOp )
+import Var ( Id )
+import VarSet ( VarSet, emptyVarSet, seqVarSet )
+import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
+ InsideLam, insideLam, notInsideLam,
+ OneBranch, oneBranch, notOneBranch,
+ Arity,
+ Activation(..)
+ )
+import DataCon ( DataCon )
+import TyCon ( TyCon, FieldLabel )
+import ForeignCall ( ForeignCall )
+import NewDemand
import Outputable
-
-import Maybe ( isJust )
-
+import Maybe ( isJust )
+
+#ifdef OLD_STRICTNESS
+import Name ( Name )
+import Demand hiding( Demand, seqDemand )
+import qualified Demand
+import Util ( listLengthCmp )
+import List ( replicate )
+#endif
+
+-- infixl so you can say (id `set` a `set` b)
+infixl 1 `setSpecInfo`,
+ `setArityInfo`,
+ `setInlinePragInfo`,
+ `setUnfoldingInfo`,
+ `setWorkerInfo`,
+ `setLBVarInfo`,
+ `setOccInfo`,
+ `setCafInfo`,
+ `setNewStrictnessInfo`,
+ `setAllStrictnessInfo`,
+ `setNewDemandInfo`
+#ifdef OLD_STRICTNESS
+ , `setCprInfo`
+ , `setDemandInfo`
+ , `setStrictnessInfo`
+#endif
\end{code}
-An @IdInfo@ gives {\em optional} information about an @Id@. If
-present it never lies, but it may not be present, in which case there
-is always a conservative assumption which can be made.
-
-Two @Id@s may have different info even though they have the same
-@Unique@ (and are hence the same @Id@); for example, one might lack
-the properties attached to the other.
+%************************************************************************
+%* *
+\subsection{New strictness info}
+%* *
+%************************************************************************
-The @IdInfo@ gives information about the value, or definition, of the
-@Id@. It does {\em not} contain information about the @Id@'s usage
-(except for @DemandInfo@? ToDo).
+To be removed later
\begin{code}
-data IdInfo
- = IdInfo {
- arityInfo :: ArityInfo, -- Its arity
- demandInfo :: Demand, -- Whether or not it is definitely demanded
- specInfo :: IdSpecEnv, -- Specialisations of this function which exist
- strictnessInfo :: StrictnessInfo, -- Strictness properties
- workerInfo :: WorkerInfo, -- Pointer to Worker Function
- unfoldingInfo :: Unfolding, -- Its unfolding
- updateInfo :: UpdateInfo, -- Which args should be updated
- cafInfo :: CafInfo,
- cprInfo :: CprInfo, -- Function always constructs a product result
- inlinePragInfo :: !InlinePragInfo -- Inline pragmas
- }
+-- 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 name arity $
+ mkTopDmdType (map newDemand ds) (newRes res 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 name arity $
+ mkTopDmdType (replicate arity lazyDmd) (newRes False cpr)
+
+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 NoCPRInfo = TopRes
+
+newDemand :: Demand.Demand -> NewDemand.Demand
+newDemand (WwLazy True) = Abs
+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 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}
-Setters
\begin{code}
-setUpdateInfo ud info = info { updateInfo = ud }
-setDemandInfo dd info = info { demandInfo = dd }
-setStrictnessInfo st info = info { strictnessInfo = st }
-setWorkerInfo wk info = info { workerInfo = wk }
-setSpecInfo sp info = info { specInfo = sp }
-setArityInfo ar info = info { arityInfo = ar }
-setInlinePragInfo pr info = info { inlinePragInfo = pr }
-setUnfoldingInfo uf info = info { unfoldingInfo = uf }
-setCafInfo cf info = info { cafInfo = cf }
-setCprInfo cp info = info { cprInfo = cp }
+seqNewDemandInfo Nothing = ()
+seqNewDemandInfo (Just dmd) = seqDemand dmd
\end{code}
-\begin{code}
-noIdInfo = IdInfo {
- arityInfo = UnknownArity,
- demandInfo = wwLazy,
- specInfo = emptySpecEnv,
- strictnessInfo = NoStrictnessInfo,
- workerInfo = noWorkerInfo,
- unfoldingInfo = noUnfolding,
- updateInfo = NoUpdateInfo,
- cafInfo = MayHaveCafRefs,
- cprInfo = NoCPRInfo,
- inlinePragInfo = NoInlinePragInfo
- }
-\end{code}
-
%************************************************************************
%* *
-\subsection[arity-IdInfo]{Arity info about an @Id@}
+\subsection{GlobalIdDetails
%* *
%************************************************************************
-For locally-defined Ids, the code generator maintains its own notion
-of their arities; so it should not be asking... (but other things
-besides the code-generator need arity info!)
+This type is here (rather than in Id.lhs) mainly because there's
+an IdInfo.hi-boot, but no Id.hi-boot, and GlobalIdDetails is imported
+(recursively) by Var.lhs.
\begin{code}
-data ArityInfo
- = UnknownArity -- No idea
- | ArityExactly Int -- Arity is exactly this
- | ArityAtLeast Int -- Arity is this or greater
-
-exactArity = ArityExactly
-atLeastArity = ArityAtLeast
-unknownArity = UnknownArity
-
-arityLowerBound :: ArityInfo -> Int
-arityLowerBound UnknownArity = 0
-arityLowerBound (ArityAtLeast n) = n
-arityLowerBound (ArityExactly n) = n
-
-
-ppArityInfo UnknownArity = empty
-ppArityInfo (ArityExactly arity) = hsep [ptext SLIT("__A"), int arity]
-ppArityInfo (ArityAtLeast arity) = hsep [ptext SLIT("__AL"), int arity]
+data GlobalIdDetails
+ = VanillaGlobal -- Imported from elsewhere, a default method Id.
+
+ | RecordSelId -- The Id for a record selector
+ { sel_tycon :: TyCon
+ , sel_label :: FieldLabel
+ , sel_naughty :: Bool -- True <=> naughty
+ } -- See Note [Naughty record selectors]
+ -- with MkId.mkRecordSelectorId
+
+ | DataConWorkId DataCon -- The Id for a data constructor *worker*
+ | DataConWrapId DataCon -- The Id for a data constructor *wrapper*
+ -- [the only reasons we need to know is so that
+ -- a) to support isImplicitId
+ -- b) when desugaring a RecordCon we can get
+ -- from the Id back to the data con]
+
+ | ClassOpId Class -- An operation of a class
+
+ | PrimOpId PrimOp -- The Id for a primitive operator
+ | FCallId ForeignCall -- The Id for a foreign call
+
+ | NotGlobalId -- Used as a convenient extra return value from globalIdDetails
+
+notGlobalId = NotGlobalId
+
+instance Outputable GlobalIdDetails where
+ ppr NotGlobalId = ptext SLIT("[***NotGlobalId***]")
+ ppr VanillaGlobal = ptext SLIT("[GlobalId]")
+ ppr (DataConWorkId _) = ptext SLIT("[DataCon]")
+ ppr (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
+ ppr (ClassOpId _) = ptext SLIT("[ClassOp]")
+ ppr (PrimOpId _) = ptext SLIT("[PrimOp]")
+ ppr (FCallId _) = ptext SLIT("[ForeignCall]")
+ ppr (RecordSelId {}) = ptext SLIT("[RecSel]")
\end{code}
+
%************************************************************************
%* *
-\subsection{Inline-pragma information}
+\subsection{The main IdInfo type}
%* *
%************************************************************************
-\begin{code}
-data InlinePragInfo
- = NoInlinePragInfo
-
- | IAmASpecPragmaId -- Used for spec-pragma Ids; don't discard or inline
+An @IdInfo@ gives {\em optional} information about an @Id@. If
+present it never lies, but it may not be present, in which case there
+is always a conservative assumption which can be made.
- | IWantToBeINLINEd -- User INLINE pragma
- | IMustNotBeINLINEd -- User NOINLINE pragma
+Two @Id@s may have different info even though they have the same
+@Unique@ (and are hence the same @Id@); for example, one might lack
+the properties attached to the other.
- | IAmALoopBreaker -- Used by the occurrence analyser to mark loop-breakers
- -- in a group of recursive definitions
+The @IdInfo@ gives information about the value, or definition, of the
+@Id@. It does {\em not} contain information about the @Id@'s usage
+(except for @DemandInfo@? ToDo). (@lbvarInfo@ is also a marginal
+case. KSW 1999-04).
- | ICanSafelyBeINLINEd -- Used by the occurrence analyser to mark things
- -- that manifesly occur once, not inside SCCs,
- -- not in constructor arguments
+\begin{code}
+data IdInfo
+ = IdInfo {
+ arityInfo :: !ArityInfo, -- Its arity
+ specInfo :: SpecInfo, -- Specialisations of this function which exist
+#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
+ -- Within one module this is irrelevant; the
+ -- inlining of a worker is handled via the Unfolding
+ -- WorkerInfo is used *only* to indicate the form of
+ -- the RHS, so that interface files don't actually
+ -- need to contain the RHS; it can be derived from
+ -- the strictness info
+
+ unfoldingInfo :: Unfolding, -- Its unfolding
+ cafInfo :: CafInfo, -- CAF info
+ lbvarInfo :: LBVarInfo, -- Info about a lambda-bound variable
+ inlinePragInfo :: InlinePragInfo, -- Inline pragma
+ occInfo :: OccInfo, -- How it occurs
+
+ 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 :: Maybe Demand -- Similarly we want to know if there's no
+ -- known demand yet, for when we are looking for
+ -- CPR info
+ }
- OccInfo -- Says whether the occurrence is inside a lambda
- -- If so, must only substitute WHNFs
+seqIdInfo :: IdInfo -> ()
+seqIdInfo (IdInfo {}) = ()
- Bool -- False <=> occurs in more than one case branch
- -- If so, there's a code-duplication issue
+megaSeqIdInfo :: IdInfo -> ()
+megaSeqIdInfo info
+ = seqSpecInfo (specInfo info) `seq`
+ seqWorker (workerInfo info) `seq`
- | IAmDead -- Marks unused variables. Sometimes useful for
- -- lambda and case-bound variables.
+-- Omitting this improves runtimes a little, presumably because
+-- some unfoldings are not calculated at all
+-- seqUnfolding (unfoldingInfo info) `seq`
- | IMustBeINLINEd -- Absolutely must inline; used for PrimOps and
- -- constructors only.
+ seqNewDemandInfo (newDemandInfo info) `seq`
+ seqNewStrictnessInfo (newStrictnessInfo info) `seq`
-instance Outputable InlinePragInfo where
- ppr NoInlinePragInfo = empty
- ppr IMustBeINLINEd = ptext SLIT("__UU")
- ppr IWantToBeINLINEd = ptext SLIT("__U")
- ppr IMustNotBeINLINEd = ptext SLIT("__Unot")
- ppr IAmALoopBreaker = ptext SLIT("__Ux")
- ppr IAmDead = ptext SLIT("__Ud")
- ppr (ICanSafelyBeINLINEd InsideLam _) = ptext SLIT("__Ul")
- ppr (ICanSafelyBeINLINEd _ _) = ptext SLIT("__Us")
- ppr IAmASpecPragmaId = ptext SLIT("__US")
+#ifdef OLD_STRICTNESS
+ Demand.seqDemand (demandInfo info) `seq`
+ seqStrictnessInfo (strictnessInfo info) `seq`
+ seqCpr (cprInfo info) `seq`
+#endif
-instance Show InlinePragInfo where
- showsPrec p prag = showsPrecSDoc p (ppr prag)
+ seqCaf (cafInfo info) `seq`
+ seqLBVar (lbvarInfo info) `seq`
+ seqOccInfo (occInfo info)
\end{code}
-The @IMustNotBeDiscarded@ exists only to make Ids that are
-on the *LHS* of bindings created by SPECIALISE pragmas;
-eg: s = f Int d
-The SpecPragmaId is never itself mentioned; it
-exists solely so that the specialiser will find
-the call to f, and make specialised version of it.
-The SpecPragmaId binding is discarded by the specialiser
-when it gathers up overloaded calls.
-Meanwhile, it is not discarded as dead code.
+Setters
\begin{code}
-data OccInfo
- = StrictOcc -- Occurs syntactically strictly;
- -- i.e. in a function position or case scrutinee
-
- | LazyOcc -- Not syntactically strict (*even* that of a strict function)
- -- or in a case branch where there's more than one alternative
-
- | InsideLam -- Inside a non-linear lambda (that is, a lambda which
- -- is sure to be instantiated only once).
- -- Substituting a redex for this occurrence is
- -- dangerous because it might duplicate work.
+setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
+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
+
+setUnfoldingInfoLazily info uf -- Lazy variant to avoid looking at the
+ = -- unfolding of an imported Id unless necessary
+ info { unfoldingInfo = uf } -- (In this case the demand-zapping is redundant.)
+
+setUnfoldingInfo info uf
+ -- 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 }
+setCafInfo info caf = info { cafInfo = caf }
+
+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}
-instance Outputable OccInfo where
- ppr StrictOcc = text "s"
- ppr LazyOcc = empty
- ppr InsideLam = text "l"
+\begin{code}
+vanillaIdInfo :: IdInfo
+vanillaIdInfo
+ = IdInfo {
+ cafInfo = vanillaCafInfo,
+ arityInfo = unknownArity,
+#ifdef OLD_STRICTNESS
+ cprInfo = NoCPRInfo,
+ demandInfo = wwLazy,
+ strictnessInfo = NoStrictnessInfo,
+#endif
+ specInfo = emptySpecInfo,
+ workerInfo = NoWorker,
+ unfoldingInfo = noUnfolding,
+ lbvarInfo = NoLBVarInfo,
+ inlinePragInfo = AlwaysActive,
+ occInfo = NoOccInfo,
+ newDemandInfo = Nothing,
+ newStrictnessInfo = Nothing
+ }
-notInsideLambda :: OccInfo -> Bool
-notInsideLambda StrictOcc = True
-notInsideLambda LazyOcc = True
-notInsideLambda InsideLam = False
+noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
+ -- Used for built-in type Ids in MkId.
\end{code}
+
%************************************************************************
%* *
-\subsection[specialisation-IdInfo]{Specialisation info about an @Id@}
+\subsection[arity-IdInfo]{Arity info about an @Id@}
%* *
%************************************************************************
-A @IdSpecEnv@ holds details of an @Id@'s specialisations.
+For locally-defined Ids, the code generator maintains its own notion
+of their arities; so it should not be asking... (but other things
+besides the code-generator need arity info!)
\begin{code}
-type IdSpecEnv = SpecEnv CoreExpr
-\end{code}
-
-For example, if \tr{f}'s @SpecEnv@ contains the mapping:
-\begin{verbatim}
- [List a, b] ===> (\d -> f' a b)
-\end{verbatim}
-then when we find an application of f to matching types, we simply replace
-it by the matching RHS:
-\begin{verbatim}
- f (List Int) Bool ===> (\d -> f' Int Bool)
-\end{verbatim}
-All the stuff about how many dictionaries to discard, and what types
-to apply the specialised function to, are handled by the fact that the
-SpecEnv contains a template for the result of the specialisation.
-
-There is one more exciting case, which is dealt with in exactly the same
-way. If the specialised value is unboxed then it is lifted at its
-definition site and unlifted at its uses. For example:
-
- pi :: forall a. Num a => a
-
-might have a specialisation
+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
+ -- may get in the way.
- [Int#] ===> (case pi' of Lift pi# -> pi#)
+ -- The arity might increase later in the compilation process, if
+ -- an extra lambda floats up to the binding site.
-where pi' :: Lift Int# is the specialised version of pi.
+unknownArity = 0 :: Arity
+ppArityInfo 0 = empty
+ppArityInfo n = hsep [ptext SLIT("Arity"), int n]
+\end{code}
%************************************************************************
%* *
-\subsection[strictness-IdInfo]{Strictness info about an @Id@}
+\subsection{Inline-pragma information}
%* *
%************************************************************************
-We specify the strictness of a function by giving information about
-each of the ``wrapper's'' arguments (see the description about
-worker/wrapper-style transformations in the PJ/Launchbury paper on
-unboxed types).
-
-The list of @Demands@ specifies: (a)~the strictness properties of a
-function's arguments; and (b)~the type signature of that worker (if it
-exists); i.e. its calling convention.
-
-Note that the existence of a worker function is now denoted by the Id's
-workerInfo field.
-
\begin{code}
-data StrictnessInfo
- = NoStrictnessInfo
-
- | StrictnessInfo [Demand]
- Bool -- True <=> the function diverges regardless of its arguments
- -- Useful for "error" and other disguised variants thereof.
- -- BUT NB: f = \x y. error "urk"
- -- will have info SI [SS] True
- -- but still (f) and (f 2) are not bot; only (f 3 2) is bot
+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
+
+ -- The default InlinePragInfo is AlwaysActive, so the info serves
+ -- entirely as a way to inhibit inlining until we want it
\end{code}
+
+%************************************************************************
+%* *
+ SpecInfo
+%* *
+%************************************************************************
+
\begin{code}
-mkStrictnessInfo :: ([Demand], Bool) -> StrictnessInfo
+-- CoreRules is used only in an idSpecialisation (move to IdInfo?)
+data SpecInfo
+ = SpecInfo [CoreRule] VarSet -- Locally-defined free vars of RHSs
-mkStrictnessInfo (xs, is_bot)
- | all isLazy xs && not is_bot = NoStrictnessInfo -- Uninteresting
- | otherwise = StrictnessInfo xs is_bot
+emptySpecInfo :: SpecInfo
+emptySpecInfo = SpecInfo [] emptyVarSet
-noStrictnessInfo = NoStrictnessInfo
+isEmptySpecInfo :: SpecInfo -> Bool
+isEmptySpecInfo (SpecInfo rs _) = null rs
-isBottomingStrictness (StrictnessInfo _ bot) = bot
-isBottomingStrictness NoStrictnessInfo = False
+specInfoFreeVars :: SpecInfo -> VarSet
+specInfoFreeVars (SpecInfo _ fvs) = fvs
--- appIsBottom returns true if an application to n args would diverge
-appIsBottom (StrictnessInfo ds bot) n = bot && (n >= length ds)
-appIsBottom NoStrictnessInfo n = False
+specInfoRules :: SpecInfo -> [CoreRule]
+specInfoRules (SpecInfo rules _) = rules
-ppStrictnessInfo NoStrictnessInfo = empty
-ppStrictnessInfo (StrictnessInfo wrapper_args bot)
- = hsep [ptext SLIT("__S"), pprDemands wrapper_args bot]
+seqSpecInfo (SpecInfo rules fvs) = seqRules rules `seq` seqVarSet fvs
\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
for w/w split
(b) the strictness info might be "SSS" or something, so no w/w split.
-\begin{code}
+Sometimes the arity of a wrapper changes from the original arity from
+which it was generated, so we always emit the "original" arity into
+the interface file, as part of the worker info.
-type WorkerInfo = Maybe Id
+How can this happen? Sometimes we get
+ f = coerce t (\x y -> $wf x y)
+at the moment of w/w split; but the eta reducer turns it into
+ f = coerce t $wf
+which is perfectly fine except that the exposed arity so far as
+the code generator is concerned (zero) differs from the arity
+when we did the split (2).
-mkWorkerInfo :: Id -> WorkerInfo
-mkWorkerInfo wk_id = Just wk_id
+All this arises because we use 'arity' to mean "exactly how many
+top level lambdas are there" in interface files; but during the
+compilation of this module it means "how many things can I apply
+this to".
-noWorkerInfo = Nothing
+\begin{code}
-ppWorkerInfo Nothing = empty
-ppWorkerInfo (Just wk_id) = ppr wk_id
+data WorkerInfo = NoWorker
+ | HasWorker Id Arity
+ -- The Arity is the arity of the *wrapper* at the moment of the
+ -- w/w split. See notes above.
-workerExists :: Maybe Id -> Bool
-workerExists = isJust
-\end{code}
+seqWorker :: WorkerInfo -> ()
+seqWorker (HasWorker id a) = id `seq` a `seq` ()
+seqWorker NoWorker = ()
+ppWorkerInfo NoWorker = empty
+ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("Worker") <+> ppr wk_id
-%************************************************************************
-%* *
-\subsection[update-IdInfo]{Update-analysis info about an @Id@}
-%* *
-%************************************************************************
+workerExists :: WorkerInfo -> Bool
+workerExists NoWorker = False
+workerExists (HasWorker _ _) = True
-\begin{code}
-data UpdateInfo
- = NoUpdateInfo
- | SomeUpdateInfo UpdateSpec
- deriving (Eq, Ord)
- -- we need Eq/Ord to cross-chk update infos in interfaces
-
--- the form in which we pass update-analysis info between modules:
-type UpdateSpec = [Int]
-\end{code}
+workerId :: WorkerInfo -> Id
+workerId (HasWorker id _) = id
-\begin{code}
-mkUpdateInfo = SomeUpdateInfo
-
-updateInfoMaybe NoUpdateInfo = Nothing
-updateInfoMaybe (SomeUpdateInfo []) = Nothing
-updateInfoMaybe (SomeUpdateInfo u) = Just u
+wrapperArity :: WorkerInfo -> Arity
+wrapperArity (HasWorker _ a) = a
\end{code}
-Text instance so that the update annotations can be read in.
-
-\begin{code}
-ppUpdateInfo NoUpdateInfo = empty
-ppUpdateInfo (SomeUpdateInfo []) = empty
-ppUpdateInfo (SomeUpdateInfo spec) = (<>) (ptext SLIT("__U ")) (hcat (map int spec))
-\end{code}
%************************************************************************
%* *
-\subsection[CAF-IdInfo]{CAF-related information}
+\subsection[CG-IdInfo]{Code generator-related information}
%* *
%************************************************************************
-This information is used to build Static Reference Tables (see
-simplStg/ComputeSRT.lhs).
-
\begin{code}
+-- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
+
data CafInfo
= MayHaveCafRefs -- either:
-- (1) A function or static constructor
| NoCafRefs -- A function or static constructor
-- that refers to no CAFs.
--- LATER: not sure how easy this is...
--- | OneCafRef Id
+vanillaCafInfo = MayHaveCafRefs -- Definitely safe
+
+mayHaveCafRefs MayHaveCafRefs = True
+mayHaveCafRefs _ = False
+seqCaf c = c `seq` ()
-ppCafInfo NoCafRefs = ptext SLIT("__C")
+ppCafInfo NoCafRefs = ptext SLIT("NoCafRefs")
ppCafInfo MayHaveCafRefs = empty
\end{code}
also CPRs.
\begin{code}
+#ifdef OLD_STRICTNESS
data CprInfo
= NoCPRInfo
+ | ReturnsCPR -- Yes, this function returns a constructed product
+ -- Implicitly, this means "after the function has been applied
+ -- to all its arguments", so the worker/wrapper builder in
+ -- WwLib.mkWWcpr checks that that it is indeed saturated before
+ -- making use of the CPR info
- | CPRInfo [CprInfo]
-
--- e.g. const 5 == CPRInfo [NoCPRInfo]
--- == __M(-)
--- \x -> (5,
--- (x,
--- 5,
--- x)
--- )
--- CPRInfo [CPRInfo [NoCPRInfo],
--- CPRInfo [NoCprInfo,
--- CPRInfo [NoCPRInfo],
--- NoCPRInfo]
--- ]
--- __M((-)(-(-)-)-)
-\end{code}
+ -- We used to keep nested info about sub-components, but
+ -- we never used it so I threw it away
-\begin{code}
+seqCpr :: CprInfo -> ()
+seqCpr ReturnsCPR = ()
+seqCpr NoCPRInfo = ()
noCprInfo = NoCPRInfo
-ppCprInfo NoCPRInfo = empty
-ppCprInfo c@(CPRInfo _)
- = hsep [ptext SLIT("__M"), ppCprInfo' c]
- where
- ppCprInfo' NoCPRInfo = char '-'
- ppCprInfo' (CPRInfo args) = parens (hcat (map ppCprInfo' args))
+ppCprInfo NoCPRInfo = empty
+ppCprInfo ReturnsCPR = ptext SLIT("__M")
instance Outputable CprInfo where
ppr = ppCprInfo
instance Show CprInfo where
showsPrec p c = showsPrecSDoc p (ppr c)
+#endif
\end{code}
+%************************************************************************
+%* *
+\subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
+%* *
+%************************************************************************
+
+If the @Id@ is a lambda-bound variable then it may have lambda-bound
+var info. Sometimes we know whether the lambda binding this var is a
+``one-shot'' lambda; that is, whether it is applied at most once.
+
+This information may be useful in optimisation, as computations may
+safely be floated inside such a lambda without risk of duplicating
+work.
+
+\begin{code}
+data LBVarInfo = NoLBVarInfo
+ | IsOneShotLambda -- The lambda is applied at most once).
+
+seqLBVar l = l `seq` ()
+\end{code}
+
+\begin{code}
+hasNoLBVarInfo NoLBVarInfo = True
+hasNoLBVarInfo IsOneShotLambda = False
+
+noLBVarInfo = NoLBVarInfo
+
+pprLBVarInfo NoLBVarInfo = empty
+pprLBVarInfo IsOneShotLambda = ptext SLIT("OneShot")
+
+instance Outputable LBVarInfo where
+ ppr = pprLBVarInfo
+
+instance Show LBVarInfo where
+ showsPrec p c = showsPrecSDoc p (ppr c)
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection{Bulk operations on IdInfo}
+%* *
+%************************************************************************
+
+@zapLamInfo@ is used for lambda binders that turn out to to be
+part of an unsaturated lambda
+
+\begin{code}
+zapLamInfo :: IdInfo -> Maybe IdInfo
+zapLamInfo info@(IdInfo {occInfo = occ, newDemandInfo = demand})
+ | is_safe_occ occ && is_safe_dmd demand
+ = Nothing
+ | otherwise
+ = 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 (OneOcc in_lam _ _) = in_lam
+ is_safe_occ other = True
+
+ safe_occ = case occ of
+ OneOcc _ once int_cxt -> OneOcc insideLam once int_cxt
+ 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 = dmd})
+ | isJust dmd = Just (info {newDemandInfo = Nothing})
+ | otherwise = Nothing
+\end{code}
projects / ghc-hetmet.git / blobdiff