%
-% (c) The GRASP/AQUA Project, Glasgow University, 1993-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
%
\section[IdInfo]{@IdInfos@: Non-essential information about @Ids@}
module IdInfo (
IdInfo, -- Abstract
- noIdInfo,
- ppIdInfo,
+ vanillaIdInfo, constantIdInfo, mkIdInfo, seqIdInfo, megaSeqIdInfo,
+ -- Zapping
+ zapFragileInfo, zapLamInfo, zapSpecPragInfo, shortableIdInfo, copyIdInfo,
+
+ -- Flavour
+ IdFlavour(..), flavourInfo,
+ setNoDiscardInfo, setFlavourInfo,
+ ppFlavourInfo,
+
+ -- Arity
ArityInfo(..),
- exactArity, atLeastArity, unknownArity,
- arityInfo, addArityInfo, ppArityInfo,
+ exactArity, atLeastArity, unknownArity, hasArity,
+ arityInfo, setArityInfo, ppArityInfo, arityLowerBound,
- DemandInfo,
- noDemandInfo, mkDemandInfo, demandInfo, ppDemandInfo, addDemandInfo, willBeDemanded,
+ -- Strictness; imported from Demand
+ StrictnessInfo(..),
+ mkStrictnessInfo, noStrictnessInfo,
+ ppStrictnessInfo,isBottomingStrictness,
+ strictnessInfo, setStrictnessInfo,
- StrictnessInfo(..), -- Non-abstract
- Demand(..), NewOrData, -- Non-abstract
+ -- Usage generalisation
+ TyGenInfo(..),
+ tyGenInfo, setTyGenInfo,
+ noTyGenInfo, isNoTyGenInfo, ppTyGenInfo, tyGenInfoString,
- workerExists,
- mkStrictnessInfo, mkBottomStrictnessInfo, noStrictnessInfo, bottomIsGuaranteed,
- strictnessInfo, ppStrictnessInfo, addStrictnessInfo,
+ -- Worker
+ WorkerInfo(..), workerExists, wrapperArity, workerId,
+ workerInfo, setWorkerInfo, ppWorkerInfo,
- unfoldInfo, addUnfoldInfo,
+ -- Unfolding
+ unfoldingInfo, setUnfoldingInfo,
- IdSpecEnv, specInfo, setSpecInfo,
+ -- DemandInfo
+ demandInfo, setDemandInfo,
- UpdateInfo, UpdateSpec,
- mkUpdateInfo, updateInfo, updateInfoMaybe, ppUpdateInfo, addUpdateInfo,
+ -- Inline prags
+ InlinePragInfo(..),
+ inlinePragInfo, setInlinePragInfo, pprInlinePragInfo,
+ isNeverInlinePrag, neverInlinePrag,
- ArgUsageInfo, ArgUsage(..), ArgUsageType,
- mkArgUsageInfo, argUsageInfo, addArgUsageInfo, getArgUsage,
+ -- Occurrence info
+ OccInfo(..), isFragileOcc, isDeadOcc, isLoopBreaker,
+ InsideLam, OneBranch, insideLam, notInsideLam, oneBranch, notOneBranch,
+ occInfo, setOccInfo,
- FBTypeInfo, FBType(..), FBConsum(..), FBProd(..),
- fbTypeInfo, ppFBTypeInfo, addFBTypeInfo, mkFBTypeInfo, getFBType
- ) where
+ -- Specialisation
+ specInfo, setSpecInfo,
-#include "HsVersions.h"
+ -- CAF info
+ CafInfo(..), cafInfo, setCafInfo, ppCafInfo,
+ -- Constructed Product Result Info
+ CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
-import {-# SOURCE #-} CoreUnfold ( Unfolding, noUnfolding )
-import {-# SOURCE #-} CoreSyn ( SimplifiableCoreExpr )
+ -- Lambda-bound variable info
+ LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo
+ ) where
--- for mkdependHS, CoreSyn.hi-boot refers to it:
-import BinderInfo ( BinderInfo )
+#include "HsVersions.h"
-import SpecEnv ( SpecEnv, emptySpecEnv )
-import BasicTypes ( NewOrData )
-import Demand
+import CoreSyn
+import Type ( Type, usOnce )
+import PrimOp ( PrimOp )
+import Var ( Id )
+import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
+ InsideLam, insideLam, notInsideLam,
+ OneBranch, oneBranch, notOneBranch,
+ Arity
+ )
+import DataCon ( DataCon )
+import FieldLabel ( FieldLabel )
+import Type ( usOnce, usMany )
+import Demand -- Lots of stuff
import Outputable
-
-import Char ( ord )
+import Util ( seqList )
+
+infixl 1 `setDemandInfo`,
+ `setTyGenInfo`,
+ `setStrictnessInfo`,
+ `setSpecInfo`,
+ `setArityInfo`,
+ `setInlinePragInfo`,
+ `setUnfoldingInfo`,
+ `setCprInfo`,
+ `setWorkerInfo`,
+ `setLBVarInfo`,
+ `setCafInfo`,
+ `setOccInfo`
+ -- infixl so you can say (id `set` a `set` b)
\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.
+ There is one exception: the 'flavour' is *not* optional.
+ You must not discard it.
+ It used to be in Var.lhs, but that seems unclean.
+
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.
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).
+(except for @DemandInfo@? ToDo). (@lbvarInfo@ is also a marginal
+case. KSW 1999-04).
\begin{code}
data IdInfo
- = IdInfo
- ArityInfo -- Its arity
-
- DemandInfo -- Whether or not it is definitely
- -- demanded
+ = IdInfo {
+ flavourInfo :: IdFlavour, -- NOT OPTIONAL
+ arityInfo :: ArityInfo, -- Its arity
+ demandInfo :: Demand, -- Whether or not it is definitely demanded
+ specInfo :: CoreRules, -- Specialisations of this function which exist
+ tyGenInfo :: TyGenInfo, -- Restrictions on usage-generalisation of this Id
+ strictnessInfo :: StrictnessInfo, -- Strictness properties
+ workerInfo :: WorkerInfo, -- Pointer to Worker Function
+ unfoldingInfo :: Unfolding, -- Its unfolding
+ cafInfo :: CafInfo,
+ 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
+ }
+
+seqIdInfo :: IdInfo -> ()
+seqIdInfo (IdInfo {}) = ()
+
+megaSeqIdInfo :: IdInfo -> ()
+megaSeqIdInfo info
+ = seqFlavour (flavourInfo info) `seq`
+ seqArity (arityInfo info) `seq`
+ seqDemand (demandInfo info) `seq`
+ seqRules (specInfo info) `seq`
+ seqTyGenInfo (tyGenInfo info) `seq`
+ seqStrictnessInfo (strictnessInfo 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
+
+ seqCaf (cafInfo info) `seq`
+ seqCpr (cprInfo info) `seq`
+ seqLBVar (lbvarInfo info) `seq`
+ seqOccInfo (occInfo info)
+\end{code}
- IdSpecEnv -- Specialisations of this function which exist
+Setters
- StrictnessInfo -- Strictness properties
+\begin{code}
+setFlavourInfo info fl = fl `seq` info { flavourInfo = fl }
+setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
+setSpecInfo info sp = PSEQ sp (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 }
+setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
+ -- Try to avoid spack leaks by seq'ing
+
+setUnfoldingInfo info uf
+ | isEvaldUnfolding uf && isStrict (demandInfo info)
+ -- If the unfolding is a value, the demand info may
+ -- go pear-shaped, so we nuke it. Example:
+ -- let x = (a,b) in
+ -- case x of (p,q) -> h p q x
+ -- Here x is certainly demanded. But after we've nuked
+ -- the case, we'll get just
+ -- 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 }
+
+ | otherwise
+ -- We do *not* seq on the unfolding info, For some reason, doing so
+ -- actually increases residency significantly.
+ = info { unfoldingInfo = uf }
+
+setDemandInfo info dd = info { demandInfo = dd }
+setArityInfo info ar = info { arityInfo = ar }
+setCafInfo info cf = info { cafInfo = cf }
+setCprInfo info cp = info { cprInfo = cp }
+setLBVarInfo info lb = info { lbvarInfo = lb }
+
+setNoDiscardInfo info = case flavourInfo info of
+ VanillaId -> info { flavourInfo = ExportedId }
+ other -> info
+zapSpecPragInfo info = case flavourInfo info of
+ SpecPragmaId -> info { flavourInfo = VanillaId }
+ other -> info
+\end{code}
- Unfolding -- Its unfolding; for locally-defined
- -- things, this can *only* be NoUnfolding
- UpdateInfo -- Which args should be updated
+\begin{code}
+vanillaIdInfo :: IdInfo
+vanillaIdInfo = mkIdInfo VanillaId
+
+constantIdInfo :: IdInfo
+constantIdInfo = mkIdInfo ConstantId
+
+mkIdInfo :: IdFlavour -> IdInfo
+mkIdInfo flv = IdInfo {
+ flavourInfo = flv,
+ arityInfo = UnknownArity,
+ demandInfo = wwLazy,
+ specInfo = emptyCoreRules,
+ tyGenInfo = noTyGenInfo,
+ workerInfo = NoWorker,
+ strictnessInfo = NoStrictnessInfo,
+ unfoldingInfo = noUnfolding,
+ cafInfo = MayHaveCafRefs,
+ cprInfo = NoCPRInfo,
+ lbvarInfo = NoLBVarInfo,
+ inlinePragInfo = NoInlinePragInfo,
+ occInfo = NoOccInfo
+ }
+\end{code}
- ArgUsageInfo -- how this Id uses its arguments
- FBTypeInfo -- the Foldr/Build W/W property of this function.
-\end{code}
+%************************************************************************
+%* *
+\subsection{Flavour}
+%* *
+%************************************************************************
\begin{code}
-noIdInfo = IdInfo UnknownArity UnknownDemand emptySpecEnv NoStrictnessInfo noUnfolding
- NoUpdateInfo NoArgUsageInfo NoFBTypeInfo
+data IdFlavour
+ = VanillaId -- Locally defined, not exported
+ | ExportedId -- Locally defined, exported
+ | SpecPragmaId -- Locally defined, RHS holds specialised call
+
+ | ConstantId -- Imported from elsewhere, or a dictionary function,
+ -- default method Id.
+
+ | DataConId 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) we can suppress printing a definition in the interface file
+ -- b) when typechecking a pattern we can get from the
+ -- Id back to the data con]
+ | PrimOpId PrimOp -- The Id for a primitive operator
+ | RecordSelId FieldLabel -- The Id for a record selector
+
+
+ppFlavourInfo :: IdFlavour -> SDoc
+ppFlavourInfo VanillaId = empty
+ppFlavourInfo ExportedId = ptext SLIT("[Exported]")
+ppFlavourInfo SpecPragmaId = ptext SLIT("[SpecPrag]")
+ppFlavourInfo ConstantId = ptext SLIT("[Constant]")
+ppFlavourInfo (DataConId _) = ptext SLIT("[DataCon]")
+ppFlavourInfo (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
+ppFlavourInfo (PrimOpId _) = ptext SLIT("[PrimOp]")
+ppFlavourInfo (RecordSelId _) = ptext SLIT("[RecSel]")
+
+seqFlavour :: IdFlavour -> ()
+seqFlavour f = f `seq` ()
\end{code}
-\begin{code}
-ppIdInfo :: Bool -- True <=> print specialisations, please
- -> IdInfo
- -> SDoc
-
-ppIdInfo specs_please
- (IdInfo arity demand specenv strictness unfold update arg_usage fbtype)
- = hsep [
- -- order is important!:
- ppArityInfo arity,
- ppUpdateInfo update,
-
- ppStrictnessInfo strictness,
-
- if specs_please
- then empty -- ToDo -- sty (not (isDataCon for_this_id))
- -- better_id_fn inline_env (mEnvToList specenv)
- else empty,
-
- -- DemandInfo needn't be printed since it has no effect on interfaces
- ppDemandInfo demand,
- ppFBTypeInfo fbtype
- ]
-\end{code}
+The @SpecPragmaId@ 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.
+
%************************************************************************
%* *
%* *
%************************************************************************
+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}
data ArityInfo
= UnknownArity -- No idea
- | ArityExactly Int -- Arity is exactly this
- | ArityAtLeast Int -- Arity is this or greater
-\end{code}
-\begin{code}
+ | ArityExactly Arity -- Arity is exactly this. We use this when importing a
+ -- function; it's already been compiled and we know its
+ -- arity for sure.
+
+ | ArityAtLeast 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.
+
+ -- functions in the module being compiled. Their arity
+ -- might increase later in the compilation process, if
+ -- an extra lambda floats up to the binding site.
+ deriving( Eq )
+
+seqArity :: ArityInfo -> ()
+seqArity a = arityLowerBound a `seq` ()
+
exactArity = ArityExactly
atLeastArity = ArityAtLeast
unknownArity = UnknownArity
-arityInfo (IdInfo arity _ _ _ _ _ _ _) = arity
+arityLowerBound :: ArityInfo -> Arity
+arityLowerBound UnknownArity = 0
+arityLowerBound (ArityAtLeast n) = n
+arityLowerBound (ArityExactly n) = n
-addArityInfo (IdInfo _ a b c d e f g) arity = IdInfo arity a b c d e f g
+hasArity :: ArityInfo -> Bool
+hasArity UnknownArity = False
+hasArity other = True
-ppArityInfo UnknownArity = empty
-ppArityInfo (ArityExactly arity) = hsep [ptext SLIT("_A_"), int arity]
-ppArityInfo (ArityAtLeast arity) = hsep [ptext SLIT("_A>_"), int arity]
+ppArityInfo UnknownArity = empty
+ppArityInfo (ArityExactly arity) = hsep [ptext SLIT("__A"), int arity]
+ppArityInfo (ArityAtLeast arity) = hsep [ptext SLIT("__AL"), int arity]
\end{code}
%************************************************************************
%* *
-\subsection[demand-IdInfo]{Demand info about an @Id@}
+\subsection{Inline-pragma information}
%* *
%************************************************************************
-Whether a value is certain to be demanded or not. (This is the
-information that is computed by the ``front-end'' of the strictness
-analyser.)
-
-This information is only used within a module, it is not exported
-(obviously).
-
-\begin{code}
-data DemandInfo
- = UnknownDemand
- | DemandedAsPer Demand
-\end{code}
-
\begin{code}
-noDemandInfo = UnknownDemand
-
-mkDemandInfo :: Demand -> DemandInfo
-mkDemandInfo demand = DemandedAsPer demand
-
-willBeDemanded :: DemandInfo -> Bool
-willBeDemanded (DemandedAsPer demand) = isStrict demand
-willBeDemanded _ = False
+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)
\end{code}
-\begin{code}
-demandInfo (IdInfo _ demand _ _ _ _ _ _) = demand
-
-addDemandInfo (IdInfo a _ c d e f g h) demand = IdInfo a demand c d e f g h
-
-ppDemandInfo UnknownDemand = text "{-# L #-}"
-ppDemandInfo (DemandedAsPer info) = hsep [text "{-#", text (showList [info] ""), text "#-}"]
-\end{code}
%************************************************************************
-%* *
-\subsection[specialisation-IdInfo]{Specialisation info about an @Id@}
-%* *
+%* *
+\subsection[TyGen-IdInfo]{Type generalisation info about an @Id@}
+%* *
%************************************************************************
-A @IdSpecEnv@ holds details of an @Id@'s specialisations.
+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.
-\begin{code}
-type IdSpecEnv = SpecEnv SimplifiableCoreExpr
-\end{code}
+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).
-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.
+To indicate this property, such identifiers are marked TyGenNever.
-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:
+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.
- pi :: forall a. Num a => a
+\begin{code}
+data TyGenInfo
+ = NoTyGenInfo -- no restriction on type generalisation
-might have a specialisation
+ | TyGenUInfo [Maybe Type] -- restrict generalisation of this Id to
+ -- preserve specified usage annotations
- [Int#] ===> (case pi' of Lift pi# -> pi#)
+ | TyGenNever -- never generalise the type of this Id
-where pi' :: Lift Int# is the specialised version of pi.
+ deriving ( Eq )
+\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}
-specInfo :: IdInfo -> IdSpecEnv
-specInfo (IdInfo _ _ spec _ _ _ _ _) = spec
-
-setSpecInfo (IdInfo a b _ d e f g h) spec = IdInfo a b spec d e f g h
+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 == usOnce = '1' -- chars with identity
+ | u == 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[strictness-IdInfo]{Strictness info about an @Id@}
+\subsection[worker-IdInfo]{Worker info about an @Id@}
%* *
%************************************************************************
-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; (b)~the {\em existence} of a ``worker''
-version of the function; and (c)~the type signature of that worker (if
-it exists); i.e. its calling convention.
+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.
-\begin{code}
-data StrictnessInfo
- = NoStrictnessInfo
-
- | BottomGuaranteed -- This Id guarantees never to return;
- -- it is bottom regardless of its arguments.
- -- Useful for "error" and other disguised
- -- variants thereof.
-
- | StrictnessInfo [Demand]
- Bool -- True <=> there is a worker. There might not be, 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.
-
- -- Worker's Id, if applicable, and a list of the constructors
- -- mentioned by the wrapper. This is necessary so that the
- -- renamer can slurp them in. Without this info, the renamer doesn't
- -- know which data types to slurp in concretely. Remember, for
- -- strict things we don't put the unfolding in the interface file, to save space.
- -- This constructor list allows the renamer to behave much as if the
- -- unfolding *was* in the interface file.
-\end{code}
+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}
-mkStrictnessInfo :: [Demand] -> Bool -> StrictnessInfo
-mkStrictnessInfo xs has_wrkr
- | all is_lazy xs = NoStrictnessInfo -- Uninteresting
- | otherwise = StrictnessInfo xs has_wrkr
- where
- is_lazy (WwLazy False) = True -- NB "Absent" args do *not* count!
- is_lazy _ = False -- (as they imply a worker)
+data WorkerInfo = NoWorker
+ | HasWorker Id Arity
+ -- The Arity is the arity of the *wrapper* at the moment of the
+ -- w/w split. See comments in MkIface.ifaceId, with the 'Worker' code.
-noStrictnessInfo = NoStrictnessInfo
-mkBottomStrictnessInfo = BottomGuaranteed
+seqWorker :: WorkerInfo -> ()
+seqWorker (HasWorker id _) = id `seq` ()
+seqWorker NoWorker = ()
-bottomIsGuaranteed BottomGuaranteed = True
-bottomIsGuaranteed other = False
+ppWorkerInfo NoWorker = empty
+ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("__P") <+> ppr wk_id
-strictnessInfo (IdInfo _ _ _ strict _ _ _ _) = strict
+noWorkerInfo = NoWorker
-addStrictnessInfo id_info NoStrictnessInfo = id_info
-addStrictnessInfo (IdInfo a b d _ e f g h) strict = IdInfo a b d strict e f g h
+workerExists :: WorkerInfo -> Bool
+workerExists NoWorker = False
+workerExists (HasWorker _ _) = True
-ppStrictnessInfo NoStrictnessInfo = empty
-ppStrictnessInfo BottomGuaranteed = ptext SLIT("_bot_")
+workerId :: WorkerInfo -> Id
+workerId (HasWorker id _) = id
-ppStrictnessInfo (StrictnessInfo wrapper_args wrkr_maybe)
- = hsep [ptext SLIT("_S_"), text (showList wrapper_args "")]
-\end{code}
-
-
-\begin{code}
-workerExists :: StrictnessInfo -> Bool
-workerExists (StrictnessInfo _ worker_exists) = worker_exists
-workerExists other = False
+wrapperArity :: WorkerInfo -> Arity
+wrapperArity (HasWorker _ a) = a
\end{code}
%************************************************************************
%* *
-\subsection[unfolding-IdInfo]{Unfolding info about an @Id@}
+\subsection[CAF-IdInfo]{CAF-related information}
%* *
%************************************************************************
+This information is used to build Static Reference Tables (see
+simplStg/ComputeSRT.lhs).
+
\begin{code}
-unfoldInfo (IdInfo _ _ _ _ unfolding _ _ _) = unfolding
+data CafInfo
+ = MayHaveCafRefs -- either:
+ -- (1) A function or static constructor
+ -- that refers to one or more CAFs,
+ -- (2) A real live CAF
-addUnfoldInfo (IdInfo a b d e _ f g h) uf = IdInfo a b d e uf f g h
+ | NoCafRefs -- A function or static constructor
+ -- that refers to no CAFs.
+
+-- LATER: not sure how easy this is...
+-- | OneCafRef Id
+
+
+seqCaf c = c `seq` ()
+
+ppCafInfo NoCafRefs = ptext SLIT("__C")
+ppCafInfo MayHaveCafRefs = empty
\end{code}
+
%************************************************************************
%* *
-\subsection[update-IdInfo]{Update-analysis info about an @Id@}
+\subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
%* *
%************************************************************************
-\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}
+If the @Id@ is a function then it may have CPR info. A CPR analysis
+phase detects whether:
-\begin{code}
-mkUpdateInfo = SomeUpdateInfo
+\begin{enumerate}
+\item
+The function's return value has a product type, i.e. an algebraic type
+with a single constructor. Examples of such types are tuples and boxed
+primitive values.
+\item
+The function always 'constructs' the value that it is returning. It
+must do this on every path through, and it's OK if it calls another
+function which constructs the result.
+\end{enumerate}
-updateInfoMaybe NoUpdateInfo = Nothing
-updateInfoMaybe (SomeUpdateInfo []) = Nothing
-updateInfoMaybe (SomeUpdateInfo u) = Just u
-\end{code}
+If this is the case then we store a template which tells us the
+function has the CPR property and which components of the result are
+also CPRs.
-Text instance so that the update annotations can be read in.
+\begin{code}
+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
+
+ -- We used to keep nested info about sub-components, but
+ -- we never used it so I threw it away
+\end{code}
\begin{code}
-instance Read UpdateInfo where
- readsPrec p s | null s = panic "IdInfo: empty update pragma?!"
- | otherwise = [(SomeUpdateInfo (map ok_digit s),"")]
- where
- ok_digit c | c >= '0' && c <= '2' = ord c - ord '0'
- | otherwise = panic "IdInfo: not a digit while reading update pragma"
+seqCpr :: CprInfo -> ()
+seqCpr ReturnsCPR = ()
+seqCpr NoCPRInfo = ()
-updateInfo (IdInfo _ _ _ _ _ update _ _) = update
+noCprInfo = NoCPRInfo
-addUpdateInfo id_info NoUpdateInfo = id_info
-addUpdateInfo (IdInfo a b d e f _ g h) upd_info = IdInfo a b d e f upd_info g h
+ppCprInfo NoCPRInfo = empty
+ppCprInfo ReturnsCPR = ptext SLIT("__M")
-ppUpdateInfo NoUpdateInfo = empty
-ppUpdateInfo (SomeUpdateInfo []) = empty
-ppUpdateInfo (SomeUpdateInfo spec) = (<>) (ptext SLIT("_U_ ")) (hcat (map int spec))
+instance Outputable CprInfo where
+ ppr = ppCprInfo
+
+instance Show CprInfo where
+ showsPrec p c = showsPrecSDoc p (ppr c)
\end{code}
+
%************************************************************************
%* *
-\subsection[argUsage-IdInfo]{Argument Usage info about an @Id@}
+\subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
%* *
%************************************************************************
-\begin{code}
-data ArgUsageInfo
- = NoArgUsageInfo
- | SomeArgUsageInfo ArgUsageType
- -- ??? deriving (Eq, Ord)
-
-data ArgUsage = ArgUsage Int -- number of arguments (is linear!)
- | UnknownArgUsage
-type ArgUsageType = [ArgUsage] -- c_1 -> ... -> BLOB
-\end{code}
+If the @Id@ is a lambda-bound variable then it may have lambda-bound
+var info. The usage analysis (UsageSP) detects whether the lambda
+binding this var is a ``one-shot'' lambda; that is, whether it is
+applied at most once.
-\begin{code}
-mkArgUsageInfo [] = NoArgUsageInfo
-mkArgUsageInfo au = SomeArgUsageInfo au
+This information may be useful in optimisation, as computations may
+safely be floated inside such a lambda without risk of duplicating
+work.
-getArgUsage :: ArgUsageInfo -> ArgUsageType
-getArgUsage NoArgUsageInfo = []
-getArgUsage (SomeArgUsageInfo u) = u
+\begin{code}
+data LBVarInfo
+ = NoLBVarInfo
+
+ | LBVarInfo Type -- The lambda that binds this Id has this usage
+ -- annotation (i.e., if ==usOnce, then the
+ -- lambda is applied at most once).
+ -- The annotation's kind must be `$'
+ -- HACK ALERT! placing this info here is a short-term hack,
+ -- but it minimises changes to the rest of the compiler.
+ -- Hack agreed by SLPJ/KSW 1999-04.
+
+seqLBVar l = l `seq` ()
\end{code}
\begin{code}
-argUsageInfo (IdInfo _ _ _ _ _ _ au _) = au
-
-addArgUsageInfo id_info NoArgUsageInfo = id_info
-addArgUsageInfo (IdInfo a b d e f g _ h) au_info = IdInfo a b d e f g au_info h
-
-{- UNUSED:
-ppArgUsageInfo NoArgUsageInfo = empty
-ppArgUsageInfo (SomeArgUsageInfo aut) = (<>) (ptext SLIT("_L_ ")) (ppArgUsageType aut)
--}
-
-ppArgUsage (ArgUsage n) = int n
-ppArgUsage (UnknownArgUsage) = char '-'
-
-ppArgUsageType aut = hcat
- [ char '"' ,
- hcat (punctuate comma (map ppArgUsage aut)),
- char '"' ]
+noLBVarInfo = NoLBVarInfo
+
+-- not safe to print or parse LBVarInfo because it is not really a
+-- property of the definition, but a property of the context.
+pprLBVarInfo NoLBVarInfo = empty
+pprLBVarInfo (LBVarInfo u) | u == usOnce
+ = getPprStyle $ \ sty ->
+ if ifaceStyle sty
+ then empty
+ else ptext SLIT("OneShot")
+ | otherwise
+ = empty
+
+instance Outputable LBVarInfo where
+ ppr = pprLBVarInfo
+
+instance Show LBVarInfo where
+ showsPrec p c = showsPrecSDoc p (ppr c)
\end{code}
+
%************************************************************************
%* *
-\subsection[FBType-IdInfo]{Type of an expression through Foldr/build's eyes}
+\subsection{Bulk operations on IdInfo}
%* *
%************************************************************************
-\begin{code}
-data FBTypeInfo
- = NoFBTypeInfo
- | SomeFBTypeInfo FBType
-
-data FBType = FBType [FBConsum] FBProd deriving (Eq)
-
-data FBConsum = FBGoodConsum | FBBadConsum deriving(Eq)
-data FBProd = FBGoodProd | FBBadProd deriving(Eq)
-\end{code}
+zapFragileInfo is used when cloning binders, mainly in the
+simplifier. We must forget about used-once information because that
+isn't necessarily correct in the transformed program.
+Also forget specialisations and unfoldings because they would need
+substitution to be correct. (They get pinned back on separately.)
\begin{code}
-mkFBTypeInfo = SomeFBTypeInfo
-
-getFBType :: FBTypeInfo -> Maybe FBType
-getFBType NoFBTypeInfo = Nothing
-getFBType (SomeFBTypeInfo u) = Just u
+zapFragileInfo :: IdInfo -> Maybe IdInfo
+zapFragileInfo info@(IdInfo {occInfo = occ,
+ workerInfo = wrkr,
+ specInfo = rules,
+ unfoldingInfo = unfolding})
+ | not (isFragileOcc occ)
+ -- We must forget about whether it was marked safe-to-inline,
+ -- because that isn't necessarily true in the simplified expression.
+ -- This is important because expressions may be re-simplified
+ -- We don't zap deadness or loop-breaker-ness.
+ -- The latter is important because it tells MkIface not to
+ -- spit out an inlining for the thing. The former doesn't
+ -- seem so important, but there's no harm.
+
+ && isEmptyCoreRules rules
+ -- Specialisations would need substituting. They get pinned
+ -- back on separately.
+
+ && not (workerExists wrkr)
+
+ && not (hasUnfolding unfolding)
+ -- This is very important; occasionally a let-bound binder is used
+ -- as a binder in some lambda, in which case its unfolding is utterly
+ -- bogus. Also the unfolding uses old binders so if we left it we'd
+ -- have to substitute it. Much better simply to give the Id a new
+ -- unfolding each time, which is what the simplifier does.
+ = Nothing
+
+ | otherwise
+ = Just (info {occInfo = robust_occ_info,
+ workerInfo = noWorkerInfo,
+ specInfo = emptyCoreRules,
+ unfoldingInfo = noUnfolding})
+ where
+ -- It's important to keep the loop-breaker info,
+ -- because the substitution doesn't remember it.
+ robust_occ_info = case occ of
+ OneOcc _ _ -> NoOccInfo
+ other -> occ
\end{code}
+@zapLamInfo@ is used for lambda binders that turn out to to be
+part of an unsaturated lambda
+
\begin{code}
-fbTypeInfo (IdInfo _ _ _ _ _ _ _ fb) = fb
+zapLamInfo :: IdInfo -> Maybe IdInfo
+zapLamInfo info@(IdInfo {occInfo = occ, demandInfo = demand})
+ | is_safe_occ && not (isStrict demand)
+ = Nothing
+ | otherwise
+ = Just (info {occInfo = safe_occ,
+ demandInfo = wwLazy})
+ 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
+
+ safe_occ = case occ of
+ OneOcc _ once -> OneOcc insideLam once
+ other -> occ
+\end{code}
-addFBTypeInfo id_info NoFBTypeInfo = id_info
-addFBTypeInfo (IdInfo a b d e f g h _) fb_info = IdInfo a b d e f g h fb_info
-ppFBTypeInfo NoFBTypeInfo = empty
-ppFBTypeInfo (SomeFBTypeInfo (FBType cons prod))
- = (<>) (ptext SLIT("_F_ ")) (ppFBType cons prod)
+copyIdInfo is used when shorting out a top-level binding
+ f_local = BIG
+ f = f_local
+where f is exported. We are going to swizzle it around to
+ f = BIG
+ f_local = f
+
+BUT (a) we must be careful about messing up rules
+ (b) we must ensure f's IdInfo ends up right
+
+(a) Messing up the rules
+~~~~~~~~~~~~~~~~~~~~
+The example that went bad on me was this one:
+
+ iterate :: (a -> a) -> a -> [a]
+ iterate = iterateList
+
+ iterateFB c f x = x `c` iterateFB c f (f x)
+ iterateList f x = x : iterateList f (f x)
+
+ {-# RULES
+ "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
+ "iterateFB" iterateFB (:) = iterateList
+ #-}
+
+This got shorted out to:
+
+ iterateList :: (a -> a) -> a -> [a]
+ iterateList = iterate
+
+ iterateFB c f x = x `c` iterateFB c f (f x)
+ iterate f x = x : iterate f (f x)
+
+ {-# RULES
+ "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
+ "iterateFB" iterateFB (:) = iterate
+ #-}
+
+And now we get an infinite loop in the rule system
+ iterate f x -> build (\cn -> iterateFB c f x
+ -> iterateFB (:) f x
+ -> iterate f x
+
+Tiresome solution: don't do shorting out if f has rewrite rules.
+Hence shortableIdInfo.
+
+(b) Keeping the IdInfo right
+~~~~~~~~~~~~~~~~~~~~~~~~
+We want to move strictness/worker info from f_local to f, but keep the rest.
+Hence copyIdInfo.
-ppFBType cons prod = hcat
- ([ char '"' ] ++ map ppCons cons ++ [ char '-', ppProd prod, char '"' ])
- where
- ppCons FBGoodConsum = char 'G'
- ppCons FBBadConsum = char 'B'
- ppProd FBGoodProd = char 'G'
- ppProd FBBadProd = char 'B'
+\begin{code}
+shortableIdInfo :: IdInfo -> Bool
+shortableIdInfo info = isEmptyCoreRules (specInfo info)
+
+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
+ }
\end{code}
projects / ghc-hetmet.git / blobdiff