GlobalIdDetails(..), notGlobalId, -- Not abstract
IdInfo, -- Abstract
- vanillaIdInfo, noTyGenIdInfo, noCafOrTyGenIdInfo, noCafIdInfo,
+ vanillaIdInfo, noCafNoTyGenIdInfo,
seqIdInfo, megaSeqIdInfo,
-- Zapping
shortableIdInfo, copyIdInfo,
-- Arity
- ArityInfo(..),
- exactArity, atLeastArity, unknownArity, hasArity,
- arityInfo, setArityInfo, ppArityInfo, arityLowerBound,
+ ArityInfo,
+ unknownArity,
+ arityInfo, setArityInfo, ppArityInfo,
+
+ -- New demand and strictness info
+ newStrictnessInfo, setNewStrictnessInfo, mkNewStrictnessInfo,
+ newDemandInfo, setNewDemandInfo, newDemand, oldDemand,
-- Strictness; imported from Demand
StrictnessInfo(..),
demandInfo, setDemandInfo,
-- Inline prags
- InlinePragInfo(..),
- inlinePragInfo, setInlinePragInfo, pprInlinePragInfo,
- isNeverInlinePrag, neverInlinePrag,
+ InlinePragInfo,
+ inlinePragInfo, setInlinePragInfo,
-- Occurrence info
OccInfo(..), isFragileOcc, isDeadOcc, isLoopBreaker,
-- Specialisation
specInfo, setSpecInfo,
+ -- CG info
+ CgInfo(..), cgInfo, setCgInfo, pprCgInfo,
+ cgCafInfo, vanillaCgInfo,
+ CgInfoEnv, lookupCgInfo,
+
-- CAF info
- CafInfo(..), cafInfo, setCafInfo, mayHaveCafRefs, ppCafInfo,
+ CafInfo(..), ppCafInfo, setCafInfo, mayHaveCafRefs,
-- Constructed Product Result Info
CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
import CoreSyn
-import Type ( Type, usOnce )
+import Type ( Type, usOnce, eqUsage )
import PrimOp ( PrimOp )
+import NameEnv ( NameEnv, lookupNameEnv )
+import Name ( Name )
import Var ( Id )
import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
InsideLam, insideLam, notInsideLam,
OneBranch, oneBranch, notOneBranch,
- Arity
+ Arity,
+ Activation(..)
)
import DataCon ( DataCon )
+import ForeignCall ( ForeignCall )
import FieldLabel ( FieldLabel )
import Type ( usOnce, usMany )
-import Demand -- Lots of stuff
+import Demand hiding( Demand )
+import qualified Demand
+import NewDemand ( Demand(..), Keepity(..), DmdResult(..),
+ lazyDmd, topDmd, dmdTypeDepth, isStrictDmd,
+ StrictSig, mkStrictSig, mkTopDmdType
+ )
import Outputable
import Util ( seqList )
+import List ( replicate )
infixl 1 `setDemandInfo`,
`setTyGenInfo`,
`setCprInfo`,
`setWorkerInfo`,
`setLBVarInfo`,
+ `setOccInfo`,
+ `setCgInfo`,
`setCafInfo`,
- `setOccInfo`
+ `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.StrictnessInfo ds res) cpr
+ | length ds <= arity
+ -- Sometimes the old strictness analyser has more
+ -- demands than the arity justifies
+ = mk_strict_sig id arity $
+ mkTopDmdType (map newDemand ds) (newRes res cpr)
+
+mkNewStrictnessInfo id arity other cpr
+ = -- Either no strictness info, or arity is too small
+ -- In either case we can't say anything useful
+ mk_strict_sig id arity $
+ mkTopDmdType (replicate arity lazyDmd) (newRes False cpr)
+
+mk_strict_sig id arity dmd_ty
+ = WARN( arity /= dmdTypeDepth dmd_ty, ppr id <+> (ppr arity $$ ppr dmd_ty) )
+ mkStrictSig dmd_ty
+
+newRes True _ = BotRes
+newRes False ReturnsCPR = RetCPR
+newRes False NoCPRInfo = TopRes
+
+newDemand :: Demand.Demand -> NewDemand.Demand
+newDemand (WwLazy True) = Abs
+newDemand (WwLazy False) = Lazy
+newDemand WwStrict = Eval
+newDemand (WwUnpack unpk ds) = Seq Drop (map newDemand ds)
+newDemand WwPrim = Lazy
+newDemand WwEnum = Eval
+
+oldDemand :: NewDemand.Demand -> Demand.Demand
+oldDemand Abs = WwLazy True
+oldDemand Lazy = WwLazy False
+oldDemand Bot = WwStrict
+oldDemand Err = WwStrict
+oldDemand Eval = WwStrict
+oldDemand (Seq _ ds) = WwUnpack True (map oldDemand ds)
+oldDemand (Call _) = WwStrict
+\end{code}
+
+
+%************************************************************************
+%* *
\subsection{GlobalIdDetails
%* *
%************************************************************************
-- 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
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}
data IdInfo
= IdInfo {
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
- cafInfo :: CafInfo, -- whether it refers (indirectly) to any CAFs
+ 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, -- Reason for Maybe: the DmdAnal phase needs to
+ -- know whether whether this is the first visit,
+ -- so it can assign botSig. Other customers want
+ -- topSig. So Nothing is good.
+ newDemandInfo :: Demand
}
seqIdInfo :: IdInfo -> ()
-- 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 })
+setSpecInfo info sp = sp `seq` info { specInfo = sp }
setTyGenInfo info tg = tg `seq` info { tyGenInfo = tg }
setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
setOccInfo info oc = oc `seq` info { occInfo = oc }
-- Try to avoid spack leaks by seq'ing
setUnfoldingInfo info uf
- | isEvaldUnfolding uf && isStrict (demandInfo info)
+ | isEvaldUnfolding uf
-- If the unfolding is a value, the demand info may
-- go pear-shaped, so we nuke it. Example:
-- let x = (a,b) in
-- let x = (a,b) in h a b x
-- and now x is not demanded (I'm assuming h is lazy)
-- This really happens. The solution here is a bit ad hoc...
- = info { unfoldingInfo = uf, demandInfo = wwLazy }
+ = info { unfoldingInfo = uf, newDemandInfo = Lazy }
| otherwise
-- We do *not* seq on the unfolding info, For some reason, doing so
setDemandInfo info dd = info { demandInfo = dd }
setArityInfo info ar = info { arityInfo = ar }
-setCafInfo info cf = info { cafInfo = cf }
+setCgInfo info cg = info { cgInfo = cg }
setCprInfo info cp = info { cprInfo = cp }
setLBVarInfo info lb = info { lbvarInfo = lb }
+
+setNewDemandInfo info dd = info { newDemandInfo = dd }
+setNewStrictnessInfo info dd = info { newStrictnessInfo = dd }
\end{code}
vanillaIdInfo :: IdInfo
vanillaIdInfo
= IdInfo {
- cafInfo = MayHaveCafRefs, -- Safe!
- arityInfo = UnknownArity,
+ cgInfo = noCgInfo,
+ arityInfo = unknownArity,
demandInfo = wwLazy,
specInfo = emptyCoreRules,
tyGenInfo = noTyGenInfo,
unfoldingInfo = noUnfolding,
cprInfo = NoCPRInfo,
lbvarInfo = NoLBVarInfo,
- inlinePragInfo = NoInlinePragInfo,
- occInfo = NoOccInfo
+ inlinePragInfo = AlwaysActive,
+ occInfo = NoOccInfo,
+ newDemandInfo = topDmd,
+ newStrictnessInfo = Nothing
}
-noTyGenIdInfo = vanillaIdInfo `setTyGenInfo` TyGenNever
+noCafNoTyGenIdInfo = vanillaIdInfo `setTyGenInfo` TyGenNever
+ `setCgInfo` CgInfo NoCafRefs
+ -- Used for built-in type Ids in MkId.
-- Many built-in things have fixed types, so we shouldn't
-- run around generalising them
-
-noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
- -- Local things don't refer to Cafs
-
-noCafOrTyGenIdInfo = noTyGenIdInfo `setCafInfo` NoCafRefs
- -- Most also guarantee not to refer to CAFs
\end{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.
-
- | 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.
+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.
- -- 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` ()
+seqArity a = a `seq` ()
-exactArity = ArityExactly
-atLeastArity = ArityAtLeast
-unknownArity = UnknownArity
+unknownArity = 0 :: Arity
-arityLowerBound :: ArityInfo -> Arity
-arityLowerBound UnknownArity = 0
-arityLowerBound (ArityAtLeast n) = n
-arityLowerBound (ArityExactly n) = n
-
-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("__AL"), int arity]
+ppArityInfo 0 = empty
+ppArityInfo n = hsep [ptext SLIT("Arity"), int n]
\end{code}
%************************************************************************
%************************************************************************
\begin{code}
-data InlinePragInfo
- = NoInlinePragInfo
- | IMustNotBeINLINEd Bool -- True <=> came from an INLINE prag, False <=> came from a NOINLINE prag
- (Maybe Int) -- Phase number from pragma, if any
- deriving( Eq )
- -- The True, Nothing case doesn't need to be recorded
-
- -- SEE COMMENTS WITH CoreUnfold.blackListed on the
- -- exact significance of the IMustNotBeINLINEd pragma
-
-isNeverInlinePrag :: InlinePragInfo -> Bool
-isNeverInlinePrag (IMustNotBeINLINEd _ Nothing) = True
-isNeverInlinePrag other = False
-
-neverInlinePrag :: InlinePragInfo
-neverInlinePrag = IMustNotBeINLINEd True{-should be False? --SDM -} Nothing
-
-instance Outputable InlinePragInfo where
- -- This is now parsed in interface files
- ppr NoInlinePragInfo = empty
- ppr other_prag = ptext SLIT("__U") <> pprInlinePragInfo other_prag
-
-pprInlinePragInfo NoInlinePragInfo = empty
-pprInlinePragInfo (IMustNotBeINLINEd True Nothing) = empty
-pprInlinePragInfo (IMustNotBeINLINEd True (Just n)) = brackets (int n)
-pprInlinePragInfo (IMustNotBeINLINEd False Nothing) = brackets (char '!')
-pprInlinePragInfo (IMustNotBeINLINEd False (Just n)) = brackets (char '!' <> int n)
-
-instance Show InlinePragInfo where
- showsPrec p prag = showsPrecSDoc p (ppr prag)
+type InlinePragInfo = Activation
+ -- Tells when the inlining is active
+ -- When it is active the thing may be inlined, depending on how
+ -- big it is.
+ --
+ -- If there was an INLINE pragma, then as a separate matter, the
+ -- RHS will have been made to look small with a CoreSyn Inline Note
\end{code}
-- preserve specified usage annotations
| TyGenNever -- never generalise the type of this Id
-
- deriving ( Eq )
\end{code}
For TyGenUInfo, the list has one entry for each usage annotation on
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.
+ 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
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
%************************************************************************
%* *
-\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).
+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}
+#ifndef DEBUG
+newtype CgInfo = CgInfo CafInfo -- We are back to only having CafRefs in CgInfo
+noCgInfo = panic "NoCgInfo!"
+#else
+data CgInfo = CgInfo CafInfo
+ | NoCgInfo -- In debug mode we don't want a black hole here
+ -- See Id.idCgInfo
+ -- noCgInfo is used for local Ids, which shouldn't need any CgInfo
+noCgInfo = NoCgInfo
+#endif
+
+cgCafInfo (CgInfo caf_info) = caf_info
+
+setCafInfo info caf_info = info `setCgInfo` CgInfo caf_info
+
+seqCg c = c `seq` () -- fields are strict anyhow
+
+vanillaCgInfo = CgInfo MayHaveCafRefs -- Definitely safe
+
+-- 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
+mayHaveCafRefs MayHaveCafRefs = True
+mayHaveCafRefs _ = False
+seqCaf c = c `seq` ()
-mayHaveCafRefs MayHaveCafRefs = True
-mayHaveCafRefs _ = False
+pprCgInfo (CgInfo caf_info) = ppCafInfo caf_info
-seqCaf c = c `seq` ()
+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}
+
%************************************************************************
%* *
-- 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
+pprLBVarInfo (LBVarInfo u) | u `eqUsage` usOnce
= getPprStyle $ \ sty ->
if ifaceStyle sty
then empty
\begin{code}
zapLamInfo :: IdInfo -> Maybe IdInfo
-zapLamInfo info@(IdInfo {occInfo = occ, demandInfo = demand})
- | is_safe_occ && not (isStrict demand)
+zapLamInfo info@(IdInfo {occInfo = occ, newDemandInfo = demand})
+ | is_safe_occ && not (isStrictDmd demand)
= Nothing
| otherwise
= Just (info {occInfo = safe_occ,
- demandInfo = wwLazy})
+ newDemandInfo = Lazy})
where
-- The "unsafe" occ info is the ones that say I'm not in a lambda
-- because that might not be true for an unsaturated lambda
\begin{code}
zapDemandInfo :: IdInfo -> Maybe IdInfo
-zapDemandInfo info@(IdInfo {demandInfo = demand})
- | not (isStrict demand) = Nothing
- | otherwise = Just (info {demandInfo = wwLazy})
+zapDemandInfo info@(IdInfo {newDemandInfo = demand})
+ | not (isStrictDmd demand) = Nothing
+ | otherwise = Just (info {newDemandInfo = Lazy})
\end{code}
#-}
And now we get an infinite loop in the rule system
- iterate f x -> build (\cn -> iterateFB c f x
+ iterate f x -> build (\cn -> iterateFB c f x)
-> iterateFB (:) f x
-> iterate f x
projects / ghc-hetmet.git / blobdiff