2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
5 \section[IdInfo]{@IdInfos@: Non-essential information about @Ids@}
7 (And a pretty good illustration of quite a few things wrong with
12 -- * The IdDetails type
13 IdDetails(..), pprIdDetails,
17 vanillaIdInfo, noCafIdInfo,
18 seqIdInfo, megaSeqIdInfo,
20 -- ** Zapping various forms of Info
21 zapLamInfo, zapDemandInfo, zapFragileInfo,
23 -- ** The ArityInfo type
26 arityInfo, setArityInfo, ppArityInfo,
28 -- ** Demand and strictness Info
29 strictnessInfo, setStrictnessInfo,
30 demandInfo, setDemandInfo, pprStrictness,
33 unfoldingInfo, setUnfoldingInfo, setUnfoldingInfoLazily,
35 -- ** The InlinePragInfo type
37 inlinePragInfo, setInlinePragInfo,
39 -- ** The OccInfo type
41 isDeadOcc, isLoopBreaker,
45 insideLam, notInsideLam, oneBranch, notOneBranch,
47 -- ** The SpecInfo type
50 isEmptySpecInfo, specInfoFreeVars,
51 specInfoRules, seqSpecInfo, setSpecInfoHead,
52 specInfo, setSpecInfo,
54 -- ** The CAFInfo type
56 ppCafInfo, mayHaveCafRefs,
59 -- ** The LBVarInfo type
61 noLBVarInfo, hasNoLBVarInfo,
62 lbvarInfo, setLBVarInfo,
65 TickBoxOp(..), TickBoxId,
85 -- infixl so you can say (id `set` a `set` b)
86 infixl 1 `setSpecInfo`,
97 %************************************************************************
101 %************************************************************************
104 -- | The 'IdDetails' of an 'Id' give stable, and necessary,
105 -- information about the Id.
109 -- | The 'Id' for a record selector
111 { sel_tycon :: TyCon -- ^ For a data type family, this is the /instance/ 'TyCon'
112 -- not the family 'TyCon'
113 , sel_naughty :: Bool -- True <=> a "naughty" selector which can't actually exist, for example @x@ in:
114 -- data T = forall a. MkT { x :: a }
115 } -- See Note [Naughty record selectors] in TcTyClsDecls
117 | DataConWorkId DataCon -- ^ The 'Id' is for a data constructor /worker/
118 | DataConWrapId DataCon -- ^ The 'Id' is for a data constructor /wrapper/
120 -- [the only reasons we need to know is so that
121 -- a) to support isImplicitId
122 -- b) when desugaring a RecordCon we can get
123 -- from the Id back to the data con]
125 | ClassOpId Class -- ^ The 'Id' is an superclass selector or class operation of a class
127 | PrimOpId PrimOp -- ^ The 'Id' is for a primitive operator
128 | FCallId ForeignCall -- ^ The 'Id' is for a foreign call
130 | TickBoxOpId TickBoxOp -- ^ The 'Id' is for a HPC tick box (both traditional and binary)
132 | DFunId Int Bool -- ^ A dictionary function.
133 -- Int = the number of "silent" arguments to the dfun
134 -- e.g. class D a => C a where ...
135 -- instance C a => C [a]
136 -- has is_silent = 1, because the dfun
137 -- has type dfun :: (D a, C a) => C [a]
138 -- See the DFun Superclass Invariant in TcInstDcls
140 -- Bool = True <=> the class has only one method, so may be
141 -- implemented with a newtype, so it might be bad
142 -- to be strict on this dictionary
144 instance Outputable IdDetails where
147 pprIdDetails :: IdDetails -> SDoc
148 pprIdDetails VanillaId = empty
149 pprIdDetails other = brackets (pp other)
151 pp VanillaId = panic "pprIdDetails"
152 pp (DataConWorkId _) = ptext (sLit "DataCon")
153 pp (DataConWrapId _) = ptext (sLit "DataConWrapper")
154 pp (ClassOpId {}) = ptext (sLit "ClassOp")
155 pp (PrimOpId _) = ptext (sLit "PrimOp")
156 pp (FCallId _) = ptext (sLit "ForeignCall")
157 pp (TickBoxOpId _) = ptext (sLit "TickBoxOp")
158 pp (DFunId ns nt) = ptext (sLit "DFunId")
159 <> ppWhen (ns /= 0) (brackets (int ns))
160 <> ppWhen nt (ptext (sLit "(nt)"))
161 pp (RecSelId { sel_naughty = is_naughty })
162 = brackets $ ptext (sLit "RecSel")
163 <> ppWhen is_naughty (ptext (sLit "(naughty)"))
167 %************************************************************************
169 \subsection{The main IdInfo type}
171 %************************************************************************
174 -- | An 'IdInfo' gives /optional/ information about an 'Id'. If
175 -- present it never lies, but it may not be present, in which case there
176 -- is always a conservative assumption which can be made.
178 -- Two 'Id's may have different info even though they have the same
179 -- 'Unique' (and are hence the same 'Id'); for example, one might lack
180 -- the properties attached to the other.
182 -- The 'IdInfo' gives information about the value, or definition, of the
183 -- 'Id'. It does not contain information about the 'Id''s usage,
184 -- except for 'demandInfo' and 'lbvarInfo'.
187 arityInfo :: !ArityInfo, -- ^ 'Id' arity
188 specInfo :: SpecInfo, -- ^ Specialisations of the 'Id's function which exist
189 -- See Note [Specialisations and RULES in IdInfo]
190 unfoldingInfo :: Unfolding, -- ^ The 'Id's unfolding
191 cafInfo :: CafInfo, -- ^ 'Id' CAF info
192 lbvarInfo :: LBVarInfo, -- ^ Info about a lambda-bound variable, if the 'Id' is one
193 inlinePragInfo :: InlinePragma, -- ^ Any inline pragma atached to the 'Id'
194 occInfo :: OccInfo, -- ^ How the 'Id' occurs in the program
196 strictnessInfo :: Maybe StrictSig, -- ^ Id strictness information. Reason for Maybe:
197 -- the DmdAnal phase needs to know whether
198 -- this is the first visit, so it can assign botSig.
199 -- Other customers want topSig. So @Nothing@ is good.
201 demandInfo :: Maybe Demand -- ^ Id demand information. Similarly we want to know
202 -- if there's no known demand yet, for when we are looking
206 -- | Just evaluate the 'IdInfo' to WHNF
207 seqIdInfo :: IdInfo -> ()
208 seqIdInfo (IdInfo {}) = ()
210 -- | Evaluate all the fields of the 'IdInfo' that are generally demanded by the
212 megaSeqIdInfo :: IdInfo -> ()
214 = seqSpecInfo (specInfo info) `seq`
216 -- Omitting this improves runtimes a little, presumably because
217 -- some unfoldings are not calculated at all
218 -- seqUnfolding (unfoldingInfo info) `seq`
220 seqDemandInfo (demandInfo info) `seq`
221 seqStrictnessInfo (strictnessInfo info) `seq`
223 seqCaf (cafInfo info) `seq`
224 seqLBVar (lbvarInfo info) `seq`
225 seqOccInfo (occInfo info)
227 seqStrictnessInfo :: Maybe StrictSig -> ()
228 seqStrictnessInfo Nothing = ()
229 seqStrictnessInfo (Just ty) = seqStrictSig ty
231 seqDemandInfo :: Maybe Demand -> ()
232 seqDemandInfo Nothing = ()
233 seqDemandInfo (Just dmd) = seqDemand dmd
239 setSpecInfo :: IdInfo -> SpecInfo -> IdInfo
240 setSpecInfo info sp = sp `seq` info { specInfo = sp }
241 setInlinePragInfo :: IdInfo -> InlinePragma -> IdInfo
242 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
243 setOccInfo :: IdInfo -> OccInfo -> IdInfo
244 setOccInfo info oc = oc `seq` info { occInfo = oc }
245 -- Try to avoid spack leaks by seq'ing
247 setUnfoldingInfoLazily :: IdInfo -> Unfolding -> IdInfo
248 setUnfoldingInfoLazily info uf -- Lazy variant to avoid looking at the
249 = -- unfolding of an imported Id unless necessary
250 info { unfoldingInfo = uf } -- (In this case the demand-zapping is redundant.)
252 setUnfoldingInfo :: IdInfo -> Unfolding -> IdInfo
253 setUnfoldingInfo info uf
254 = -- We don't seq the unfolding, as we generate intermediate
255 -- unfoldings which are just thrown away, so evaluating them is a
257 -- seqUnfolding uf `seq`
258 info { unfoldingInfo = uf }
260 setArityInfo :: IdInfo -> ArityInfo -> IdInfo
261 setArityInfo info ar = info { arityInfo = ar }
262 setCafInfo :: IdInfo -> CafInfo -> IdInfo
263 setCafInfo info caf = info { cafInfo = caf }
265 setLBVarInfo :: IdInfo -> LBVarInfo -> IdInfo
266 setLBVarInfo info lb = {-lb `seq`-} info { lbvarInfo = lb }
268 setDemandInfo :: IdInfo -> Maybe Demand -> IdInfo
269 setDemandInfo info dd = dd `seq` info { demandInfo = dd }
271 setStrictnessInfo :: IdInfo -> Maybe StrictSig -> IdInfo
272 setStrictnessInfo info dd = dd `seq` info { strictnessInfo = dd }
277 -- | Basic 'IdInfo' that carries no useful information whatsoever
278 vanillaIdInfo :: IdInfo
281 cafInfo = vanillaCafInfo,
282 arityInfo = unknownArity,
283 specInfo = emptySpecInfo,
284 unfoldingInfo = noUnfolding,
285 lbvarInfo = NoLBVarInfo,
286 inlinePragInfo = defaultInlinePragma,
288 demandInfo = Nothing,
289 strictnessInfo = Nothing
292 -- | More informative 'IdInfo' we can use when we know the 'Id' has no CAF references
293 noCafIdInfo :: IdInfo
294 noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
295 -- Used for built-in type Ids in MkId.
299 %************************************************************************
301 \subsection[arity-IdInfo]{Arity info about an @Id@}
303 %************************************************************************
305 For locally-defined Ids, the code generator maintains its own notion
306 of their arities; so it should not be asking... (but other things
307 besides the code-generator need arity info!)
310 -- | An 'ArityInfo' of @n@ tells us that partial application of this
311 -- 'Id' to up to @n-1@ value arguments does essentially no work.
313 -- That is not necessarily the same as saying that it has @n@ leading
314 -- lambdas, because coerces may get in the way.
316 -- The arity might increase later in the compilation process, if
317 -- an extra lambda floats up to the binding site.
318 type ArityInfo = Arity
320 -- | It is always safe to assume that an 'Id' has an arity of 0
321 unknownArity :: Arity
322 unknownArity = 0 :: Arity
324 ppArityInfo :: Int -> SDoc
325 ppArityInfo 0 = empty
326 ppArityInfo n = hsep [ptext (sLit "Arity"), int n]
329 %************************************************************************
331 \subsection{Inline-pragma information}
333 %************************************************************************
336 -- | Tells when the inlining is active.
337 -- When it is active the thing may be inlined, depending on how
340 -- If there was an @INLINE@ pragma, then as a separate matter, the
341 -- RHS will have been made to look small with a Core inline 'Note'
343 -- The default 'InlinePragInfo' is 'AlwaysActive', so the info serves
344 -- entirely as a way to inhibit inlining until we want it
345 type InlinePragInfo = InlinePragma
349 %************************************************************************
353 %************************************************************************
356 pprStrictness :: Maybe StrictSig -> SDoc
357 pprStrictness Nothing = empty
358 pprStrictness (Just sig) = ppr sig
362 %************************************************************************
366 %************************************************************************
368 Note [Specialisations and RULES in IdInfo]
369 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
370 Generally speaking, a GlobalIdshas an *empty* SpecInfo. All their
371 RULES are contained in the globally-built rule-base. In principle,
372 one could attach the to M.f the RULES for M.f that are defined in M.
373 But we don't do that for instance declarations and so we just treat
376 The EXCEPTION is PrimOpIds, which do have rules in their IdInfo. That is
377 jsut for convenience really.
379 However, LocalIds may have non-empty SpecInfo. We treat them
381 a) they might be nested, in which case a global table won't work
382 b) the RULE might mention free variables, which we use to keep things alive
384 In TidyPgm, when the LocalId becomes a GlobalId, its RULES are stripped off
385 and put in the global list.
388 -- | Records the specializations of this 'Id' that we know about
389 -- in the form of rewrite 'CoreRule's that target them
393 VarSet -- Locally-defined free vars of *both* LHS and RHS
394 -- of rules. I don't think it needs to include the
396 -- Note [Rule dependency info] in OccurAnal
398 -- | Assume that no specilizations exist: always safe
399 emptySpecInfo :: SpecInfo
400 emptySpecInfo = SpecInfo [] emptyVarSet
402 isEmptySpecInfo :: SpecInfo -> Bool
403 isEmptySpecInfo (SpecInfo rs _) = null rs
405 -- | Retrieve the locally-defined free variables of both the left and
406 -- right hand sides of the specialization rules
407 specInfoFreeVars :: SpecInfo -> VarSet
408 specInfoFreeVars (SpecInfo _ fvs) = fvs
410 specInfoRules :: SpecInfo -> [CoreRule]
411 specInfoRules (SpecInfo rules _) = rules
413 -- | Change the name of the function the rule is keyed on on all of the 'CoreRule's
414 setSpecInfoHead :: Name -> SpecInfo -> SpecInfo
415 setSpecInfoHead fn (SpecInfo rules fvs)
416 = SpecInfo (map (setRuleIdName fn) rules) fvs
418 seqSpecInfo :: SpecInfo -> ()
419 seqSpecInfo (SpecInfo rules fvs) = seqRules rules `seq` seqVarSet fvs
422 %************************************************************************
424 \subsection[CG-IdInfo]{Code generator-related information}
426 %************************************************************************
429 -- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
431 -- | Records whether an 'Id' makes Constant Applicative Form references
433 = MayHaveCafRefs -- ^ Indicates that the 'Id' is for either:
435 -- 1. A function or static constructor
436 -- that refers to one or more CAFs, or
438 -- 2. A real live CAF
440 | NoCafRefs -- ^ A function or static constructor
441 -- that refers to no CAFs.
444 -- | Assumes that the 'Id' has CAF references: definitely safe
445 vanillaCafInfo :: CafInfo
446 vanillaCafInfo = MayHaveCafRefs
448 mayHaveCafRefs :: CafInfo -> Bool
449 mayHaveCafRefs MayHaveCafRefs = True
450 mayHaveCafRefs _ = False
452 seqCaf :: CafInfo -> ()
453 seqCaf c = c `seq` ()
455 instance Outputable CafInfo where
458 ppCafInfo :: CafInfo -> SDoc
459 ppCafInfo NoCafRefs = ptext (sLit "NoCafRefs")
460 ppCafInfo MayHaveCafRefs = empty
463 %************************************************************************
465 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
467 %************************************************************************
470 -- | If the 'Id' is a lambda-bound variable then it may have lambda-bound
471 -- variable info. Sometimes we know whether the lambda binding this variable
472 -- is a \"one-shot\" lambda; that is, whether it is applied at most once.
474 -- This information may be useful in optimisation, as computations may
475 -- safely be floated inside such a lambda without risk of duplicating
477 data LBVarInfo = NoLBVarInfo -- ^ No information
478 | IsOneShotLambda -- ^ The lambda is applied at most once).
480 -- | It is always safe to assume that an 'Id' has no lambda-bound variable information
481 noLBVarInfo :: LBVarInfo
482 noLBVarInfo = NoLBVarInfo
484 hasNoLBVarInfo :: LBVarInfo -> Bool
485 hasNoLBVarInfo NoLBVarInfo = True
486 hasNoLBVarInfo IsOneShotLambda = False
488 seqLBVar :: LBVarInfo -> ()
489 seqLBVar l = l `seq` ()
491 pprLBVarInfo :: LBVarInfo -> SDoc
492 pprLBVarInfo NoLBVarInfo = empty
493 pprLBVarInfo IsOneShotLambda = ptext (sLit "OneShot")
495 instance Outputable LBVarInfo where
498 instance Show LBVarInfo where
499 showsPrec p c = showsPrecSDoc p (ppr c)
503 %************************************************************************
505 \subsection{Bulk operations on IdInfo}
507 %************************************************************************
510 -- | This is used to remove information on lambda binders that we have
511 -- setup as part of a lambda group, assuming they will be applied all at once,
512 -- but turn out to be part of an unsaturated lambda as in e.g:
514 -- > (\x1. \x2. e) arg1
515 zapLamInfo :: IdInfo -> Maybe IdInfo
516 zapLamInfo info@(IdInfo {occInfo = occ, demandInfo = demand})
517 | is_safe_occ occ && is_safe_dmd demand
520 = Just (info {occInfo = safe_occ, demandInfo = Nothing})
522 -- The "unsafe" occ info is the ones that say I'm not in a lambda
523 -- because that might not be true for an unsaturated lambda
524 is_safe_occ (OneOcc in_lam _ _) = in_lam
525 is_safe_occ _other = True
527 safe_occ = case occ of
528 OneOcc _ once int_cxt -> OneOcc insideLam once int_cxt
531 is_safe_dmd Nothing = True
532 is_safe_dmd (Just dmd) = not (isStrictDmd dmd)
536 -- | Remove demand info on the 'IdInfo' if it is present, otherwise return @Nothing@
537 zapDemandInfo :: IdInfo -> Maybe IdInfo
538 zapDemandInfo info@(IdInfo {demandInfo = dmd})
539 | isJust dmd = Just (info {demandInfo = Nothing})
540 | otherwise = Nothing
544 zapFragileInfo :: IdInfo -> Maybe IdInfo
545 -- ^ Zap info that depends on free variables
547 = Just (info `setSpecInfo` emptySpecInfo
548 `setUnfoldingInfo` noUnfolding
549 `setOccInfo` zapFragileOcc occ)
554 %************************************************************************
556 \subsection{TickBoxOp}
558 %************************************************************************
563 -- | Tick box for Hpc-style coverage
565 = TickBox Module {-# UNPACK #-} !TickBoxId
567 instance Outputable TickBoxOp where
568 ppr (TickBox mod n) = ptext (sLit "tick") <+> ppr (mod,n)