\begin{code}
module IdInfo (
- IdInfo, -- Abstract
+ GlobalIdDetails(..), notGlobalId, -- Not abstract
- vanillaIdInfo, mkIdInfo, seqIdInfo, megaSeqIdInfo,
+ IdInfo, -- Abstract
+ vanillaIdInfo, noCafNoTyGenIdInfo,
+ seqIdInfo, megaSeqIdInfo,
-- Zapping
- zapFragileInfo, zapLamInfo, zapSpecPragInfo, copyIdInfo,
-
- -- Flavour
- IdFlavour(..), flavourInfo,
- setNoDiscardInfo,
- ppFlavourInfo,
+ zapLamInfo, zapDemandInfo,
+ shortableIdInfo, copyIdInfo,
-- Arity
- ArityInfo(..),
- exactArity, atLeastArity, unknownArity, hasArity,
+ ArityInfo,
+ exactArity, unknownArity, hasArity,
arityInfo, setArityInfo, ppArityInfo, arityLowerBound,
+ -- New demand and strictness info
+ newStrictnessInfo, setNewStrictnessInfo, mkNewStrictnessInfo,
+ newDemandInfo, setNewDemandInfo, newDemand, oldDemand,
+
-- Strictness; imported from Demand
StrictnessInfo(..),
mkStrictnessInfo, noStrictnessInfo,
ppStrictnessInfo,isBottomingStrictness,
-
strictnessInfo, setStrictnessInfo,
+ -- Usage generalisation
+ TyGenInfo(..),
+ tyGenInfo, setTyGenInfo,
+ noTyGenInfo, isNoTyGenInfo, ppTyGenInfo, tyGenInfoString,
+
-- Worker
WorkerInfo(..), workerExists, wrapperArity, workerId,
workerInfo, setWorkerInfo, ppWorkerInfo,
isNeverInlinePrag, neverInlinePrag,
-- Occurrence info
- OccInfo(..), isFragileOccInfo,
+ OccInfo(..), isFragileOcc, isDeadOcc, isLoopBreaker,
InsideLam, OneBranch, insideLam, notInsideLam, oneBranch, notOneBranch,
occInfo, setOccInfo,
-- Specialisation
specInfo, setSpecInfo,
- -- Update
- UpdateInfo, UpdateSpec,
- mkUpdateInfo, updateInfo, updateInfoMaybe, ppUpdateInfo, setUpdateInfo,
+ -- CG info
+ CgInfo(..), cgInfo, setCgInfo, cgMayHaveCafRefs, pprCgInfo,
+ cgArity, cgCafInfo, vanillaCgInfo,
+ CgInfoEnv, lookupCgInfo,
+ setCgArity,
-- CAF info
- CafInfo(..), cafInfo, setCafInfo, ppCafInfo,
+ CafInfo(..), ppCafInfo, setCafInfo, mayHaveCafRefs,
-- Constructed Product Result Info
CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
-- Lambda-bound variable info
- LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo
+ LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
) where
#include "HsVersions.h"
import CoreSyn
+import Type ( Type, usOnce, eqUsage )
import PrimOp ( PrimOp )
+import NameEnv ( NameEnv, lookupNameEnv )
+import Name ( Name )
import Var ( Id )
-import BasicTypes ( OccInfo(..), isFragileOccInfo, seqOccInfo,
+import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
InsideLam, insideLam, notInsideLam,
OneBranch, oneBranch, notOneBranch,
Arity
)
import DataCon ( DataCon )
+import ForeignCall ( ForeignCall )
import FieldLabel ( FieldLabel )
-import Demand -- Lots of stuff
+import Type ( usOnce, usMany )
+import Demand hiding( Demand )
+import NewDemand ( Demand(..), Keepity(..), Deferredness(..), DmdResult(..),
+ lazyDmd, topDmd,
+ StrictSig, mkStrictSig,
+ DmdType, mkTopDmdType
+ )
import Outputable
-import Maybe ( isJust )
+import Util ( seqList )
+import List ( replicate )
-infixl 1 `setUpdateInfo`,
- `setDemandInfo`,
+infixl 1 `setDemandInfo`,
+ `setTyGenInfo`,
`setStrictnessInfo`,
`setSpecInfo`,
`setArityInfo`,
`setUnfoldingInfo`,
`setCprInfo`,
`setWorkerInfo`,
+ `setLBVarInfo`,
+ `setOccInfo`,
+ `setCgInfo`,
`setCafInfo`,
- `setOccInfo`
+ `setCgArity`,
+ `setNewStrictnessInfo`,
+ `setNewDemandInfo`
-- infixl so you can say (id `set` a `set` b)
\end{code}
+%************************************************************************
+%* *
+\subsection{New strictness info}
+%* *
+%************************************************************************
+
+To be removed later
+
+\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)
+ -- Sometimes the old strictness analyser has more
+ -- demands than the arity justifies
+
+newRes True _ = BotRes
+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 Now (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
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection{GlobalIdDetails
+%* *
+%************************************************************************
+
+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 GlobalIdDetails
+ = VanillaGlobal -- Imported from elsewhere, a default method Id.
+
+ | RecordSelId FieldLabel -- The Id for a record selector
+ | 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
+ | 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 (DataConId _) = ptext SLIT("[DataCon]")
+ ppr (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
+ ppr (PrimOpId _) = ptext SLIT("[PrimOp]")
+ ppr (FCallId _) = ptext SLIT("[ForeignCall]")
+ ppr (RecordSelId _) = ptext SLIT("[RecSel]")
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection{The main IdInfo type}
+%* *
+%************************************************************************
+
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.
\begin{code}
data IdInfo
= IdInfo {
- flavourInfo :: IdFlavour, -- NOT OPTIONAL
arityInfo :: ArityInfo, -- Its arity
- demandInfo :: Demand, -- Whether or not it is definitely demanded
+ demandInfo :: Demand.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
- updateInfo :: UpdateInfo, -- Which args should be updated
- cafInfo :: CafInfo,
+ 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
+ occInfo :: OccInfo, -- How it occurs
+
+ newStrictnessInfo :: Maybe StrictSig,
+ newDemandInfo :: Demand
}
seqIdInfo :: IdInfo -> ()
megaSeqIdInfo :: IdInfo -> ()
megaSeqIdInfo info
- = seqFlavour (flavourInfo info) `seq`
- seqArity (arityInfo 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`
-- Omitting this improves runtimes a little, presumably because
-- some unfoldings are not calculated at all
- seqCaf (cafInfo info) `seq`
+-- 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)
\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 }
setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
setOccInfo info oc = oc `seq` info { occInfo = oc }
setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
-- actually increases residency significantly.
= info { unfoldingInfo = uf }
-setUpdateInfo info ud = info { updateInfo = ud }
setDemandInfo info dd = info { demandInfo = dd }
-setArityInfo info ar = info { arityInfo = ar }
-setCafInfo info cf = info { cafInfo = cf }
+setArityInfo info ar = info { arityInfo = Just ar }
+setCgInfo info cg = info { cgInfo = cg }
setCprInfo info cp = info { cprInfo = cp }
setLBVarInfo info lb = info { lbvarInfo = lb }
-setNoDiscardInfo info = case flavourInfo info of
- VanillaId -> info { flavourInfo = NoDiscardId }
- other -> info
-zapSpecPragInfo info = case flavourInfo info of
- SpecPragmaId -> info { flavourInfo = VanillaId }
- other -> info
+setNewDemandInfo info dd = info { newDemandInfo = dd }
+setNewStrictnessInfo info dd = info { newStrictnessInfo = dd }
\end{code}
\begin{code}
vanillaIdInfo :: IdInfo
-vanillaIdInfo = mkIdInfo VanillaId
-
-mkIdInfo :: IdFlavour -> IdInfo
-mkIdInfo flv = IdInfo {
- flavourInfo = flv,
- arityInfo = UnknownArity,
- demandInfo = wwLazy,
- specInfo = emptyCoreRules,
- workerInfo = NoWorker,
- strictnessInfo = NoStrictnessInfo,
- unfoldingInfo = noUnfolding,
- updateInfo = NoUpdateInfo,
- cafInfo = MayHaveCafRefs,
- cprInfo = NoCPRInfo,
- lbvarInfo = NoLBVarInfo,
- inlinePragInfo = NoInlinePragInfo,
- occInfo = NoOccInfo
+vanillaIdInfo
+ = IdInfo {
+ cgInfo = noCgInfo,
+ arityInfo = unknownArity,
+ demandInfo = wwLazy,
+ specInfo = emptyCoreRules,
+ tyGenInfo = noTyGenInfo,
+ workerInfo = NoWorker,
+ strictnessInfo = NoStrictnessInfo,
+ unfoldingInfo = noUnfolding,
+ cprInfo = NoCPRInfo,
+ lbvarInfo = NoLBVarInfo,
+ inlinePragInfo = NoInlinePragInfo,
+ occInfo = NoOccInfo,
+ newDemandInfo = topDmd,
+ newStrictnessInfo = Nothing
}
-\end{code}
-
-
-%************************************************************************
-%* *
-\subsection{Flavour}
-%* *
-%************************************************************************
-\begin{code}
-data IdFlavour
- = VanillaId -- Most Ids are like this
- | 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
- | SpecPragmaId -- Don't discard these
- | NoDiscardId -- Don't discard these either
-
-ppFlavourInfo :: IdFlavour -> SDoc
-ppFlavourInfo VanillaId = empty
-ppFlavourInfo (DataConId _) = ptext SLIT("[DataCon]")
-ppFlavourInfo (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
-ppFlavourInfo (PrimOpId _) = ptext SLIT("[PrimOp]")
-ppFlavourInfo (RecordSelId _) = ptext SLIT("[RecSel]")
-ppFlavourInfo SpecPragmaId = ptext SLIT("[SpecPrag]")
-ppFlavourInfo NoDiscardId = ptext SLIT("[NoDiscard]")
-
-seqFlavour :: IdFlavour -> ()
-seqFlavour f = f `seq` ()
+noCafNoTyGenIdInfo = vanillaIdInfo `setTyGenInfo` TyGenNever
+ `setCgInfo` (CgInfo 0 NoCafRefs)
+ -- Used for built-in type Ids in MkId.
+ -- Many built-in things have fixed types, so we shouldn't
+ -- run around generalising them
\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.
-
%************************************************************************
%* *
besides the code-generator need arity info!)
\begin{code}
-data ArityInfo
- = UnknownArity -- No idea
-
- | 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.
+type ArityInfo = Maybe 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.
- | ArityAtLeast Arity -- Arity is this or greater. We attach this arity to
- -- 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 )
+ -- The arity might increase later in the compilation process, if
+ -- an extra lambda floats up to the binding site.
seqArity :: ArityInfo -> ()
seqArity a = arityLowerBound a `seq` ()
-exactArity = ArityExactly
-atLeastArity = ArityAtLeast
-unknownArity = UnknownArity
+exactArity = Just
+unknownArity = Nothing
arityLowerBound :: ArityInfo -> Arity
-arityLowerBound UnknownArity = 0
-arityLowerBound (ArityAtLeast n) = n
-arityLowerBound (ArityExactly n) = n
+arityLowerBound Nothing = 0
+arityLowerBound (Just n) = n
hasArity :: ArityInfo -> Bool
-hasArity UnknownArity = False
-hasArity other = True
+hasArity Nothing = False
+hasArity other = True
-ppArityInfo UnknownArity = empty
-ppArityInfo (ArityExactly arity) = hsep [ptext SLIT("__A"), int arity]
-ppArityInfo (ArityAtLeast arity) = hsep [ptext SLIT("__AL"), int arity]
+ppArityInfo Nothing = empty
+ppArityInfo (Just arity) = hsep [ptext SLIT("Arity"), int arity]
\end{code}
%************************************************************************
-- exact significance of the IMustNotBeINLINEd pragma
isNeverInlinePrag :: InlinePragInfo -> Bool
-isNeverInlinePrag (IMustNotBeINLINEd True Nothing) = True
-isNeverInlinePrag other = False
+isNeverInlinePrag (IMustNotBeINLINEd _ Nothing) = True
+isNeverInlinePrag other = False
neverInlinePrag :: InlinePragInfo
-neverInlinePrag = IMustNotBeINLINEd True Nothing
+neverInlinePrag = IMustNotBeINLINEd True{-should be False? --SDM -} Nothing
instance Outputable InlinePragInfo where
-- This is now parsed in interface files
%************************************************************************
+%* *
+\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@}
%* *
for w/w split
(b) the strictness info might be "SSS" or something, so no w/w split.
+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.
+
+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).
+
+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".
+
\begin{code}
data WorkerInfo = NoWorker
| HasWorker Id Arity
-- The Arity is the arity of the *wrapper* at the moment of the
- -- w/w split. It had better be the same as the arity of the wrapper
- -- at the moment it is spat into the interface file.
- -- This Arity just lets us make a (hopefully redundant) sanity check
+ -- w/w split. See comments in MkIface.ifaceId, with the 'Worker' code.
seqWorker :: WorkerInfo -> ()
seqWorker (HasWorker id _) = id `seq` ()
ppWorkerInfo NoWorker = empty
ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("__P") <+> ppr wk_id
-noWorkerInfo = NoWorker
-
workerExists :: WorkerInfo -> Bool
workerExists NoWorker = False
workerExists (HasWorker _ _) = True
%************************************************************************
%* *
-\subsection[update-IdInfo]{Update-analysis info about an @Id@}
+\subsection[CG-IdInfo]{Code generator-related information}
%* *
%************************************************************************
-\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}
+CgInfo encapsulates calling-convention information produced by the code
+generator. It is pasted into the IdInfo of each emitted Id by CoreTidy,
+but only as a thunk --- the information is only actually produced further
+downstream, by the code generator.
\begin{code}
-mkUpdateInfo = SomeUpdateInfo
+data CgInfo = CgInfo
+ !Arity -- Exact arity for calling purposes
+ !CafInfo
+#ifdef DEBUG
+ | NoCgInfo -- In debug mode we don't want a black hole here
+ -- See Id.idCgInfo
-updateInfoMaybe NoUpdateInfo = Nothing
-updateInfoMaybe (SomeUpdateInfo []) = Nothing
-updateInfoMaybe (SomeUpdateInfo u) = Just u
-\end{code}
+ -- noCgInfo is used for local Ids, which shouldn't need any CgInfo
+noCgInfo = NoCgInfo
+#else
+noCgInfo = panic "NoCgInfo!"
+#endif
-Text instance so that the update annotations can be read in.
+cgArity (CgInfo arity _) = arity
+cgCafInfo (CgInfo _ caf_info) = caf_info
-\begin{code}
-ppUpdateInfo NoUpdateInfo = empty
-ppUpdateInfo (SomeUpdateInfo []) = empty
-ppUpdateInfo (SomeUpdateInfo spec) = (<>) (ptext SLIT("__UA ")) (hcat (map int spec))
- -- was "__U "; changed to avoid conflict with unfoldings. KSW 1999-07.
-\end{code}
+setCafInfo info caf_info =
+ case cgInfo info of { CgInfo arity _ ->
+ info `setCgInfo` CgInfo arity caf_info }
-%************************************************************************
-%* *
-\subsection[CAF-IdInfo]{CAF-related information}
-%* *
-%************************************************************************
+setCgArity info arity =
+ case cgInfo info of { CgInfo _ caf_info ->
+ info `setCgInfo` CgInfo arity caf_info }
-This information is used to build Static Reference Tables (see
-simplStg/ComputeSRT.lhs).
+cgMayHaveCafRefs (CgInfo _ caf_info) = mayHaveCafRefs caf_info
+
+seqCg c = c `seq` () -- fields are strict anyhow
+
+vanillaCgInfo = CgInfo 0 MayHaveCafRefs -- Definitely safe
+
+-- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
-\begin{code}
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
-
+mayHaveCafRefs MayHaveCafRefs = True
+mayHaveCafRefs _ = False
seqCaf c = c `seq` ()
+pprCgInfo (CgInfo arity caf_info) = ppArity arity <+> ppCafInfo caf_info
+
+ppArity 0 = empty
+ppArity n = hsep [ptext SLIT("__A"), int n]
+
ppCafInfo NoCafRefs = ptext SLIT("__C")
ppCafInfo MayHaveCafRefs = empty
\end{code}
+\begin{code}
+type CgInfoEnv = NameEnv CgInfo
+
+lookupCgInfo :: NameEnv CgInfo -> Name -> CgInfo
+lookupCgInfo env n = case lookupNameEnv env n of
+ Just info -> info
+ Nothing -> pprTrace "Urk! Not in CgInfo env" (ppr n) vanillaCgInfo
+\end{code}
+
%************************************************************************
%* *
data LBVarInfo
= NoLBVarInfo
- | IsOneShotLambda -- The lambda that binds this Id is applied
- -- at most once
+ | 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.
\end{code}
\begin{code}
+hasNoLBVarInfo NoLBVarInfo = True
+hasNoLBVarInfo other = False
+
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 IsOneShotLambda = getPprStyle $ \ sty ->
- if ifaceStyle sty then empty
- else ptext SLIT("OneShot")
+pprLBVarInfo (LBVarInfo u) | u `eqUsage` usOnce
+ = getPprStyle $ \ sty ->
+ if ifaceStyle sty
+ then empty
+ else ptext SLIT("OneShot")
+ | otherwise
+ = empty
instance Outputable LBVarInfo where
ppr = pprLBVarInfo
%* *
%************************************************************************
-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}
-zapFragileInfo :: IdInfo -> Maybe IdInfo
-zapFragileInfo info@(IdInfo {occInfo = occ,
- workerInfo = wrkr,
- specInfo = rules,
- unfoldingInfo = unfolding})
- | not (isFragileOccInfo 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
other -> occ
\end{code}
+\begin{code}
+zapDemandInfo :: IdInfo -> Maybe IdInfo
+zapDemandInfo info@(IdInfo {demandInfo = demand})
+ | not (isStrict demand) = Nothing
+ | otherwise = Just (info {demandInfo = wwLazy})
+\end{code}
+
copyIdInfo is used when shorting out a top-level binding
f_local = BIG
where f is exported. We are going to swizzle it around to
f = BIG
f_local = f
-but we must be careful to combine their IdInfos right.
-The fact that things can go wrong here is a bad sign, but I can't see
-how to make it 'patently right', so copyIdInfo is derived (pretty much) by trial and error
-Here 'from' is f_local, 'to' is f, and the result is attached to 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.
\begin{code}
-copyIdInfo :: IdInfo -- From
- -> IdInfo -- To
- -> IdInfo -- To, updated with stuff from From; except flavour unchanged
-copyIdInfo from to = from { flavourInfo = flavourInfo to,
- specInfo = specInfo to,
- inlinePragInfo = inlinePragInfo to
+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
}
- -- It's important to preserve the inline pragma on 'f'; e.g. consider
- -- {-# NOINLINE f #-}
- -- f = local
- --
- -- similarly, transformation rules may be attached to f
- -- and we want to preserve them.
- --
- -- On the other hand, we want the strictness info from f_local.
\end{code}
projects / ghc-hetmet.git / blobdiff