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
49 isEmptySpecInfo, specInfoFreeVars,
50 specInfoRules, seqSpecInfo, setSpecInfoHead,
51 specInfo, setSpecInfo,
53 -- ** The CAFInfo type
55 ppCafInfo, mayHaveCafRefs,
58 -- ** The LBVarInfo type
60 noLBVarInfo, hasNoLBVarInfo,
61 lbvarInfo, setLBVarInfo,
64 TickBoxOp(..), TickBoxId,
84 -- infixl so you can say (id `set` a `set` b)
85 infixl 1 `setSpecInfo`,
96 %************************************************************************
100 %************************************************************************
103 -- | The 'IdDetails' of an 'Id' give stable, and necessary,
104 -- information about the Id.
108 -- | The 'Id' for a record selector
110 { sel_tycon :: TyCon -- ^ For a data type family, this is the /instance/ 'TyCon'
111 -- not the family 'TyCon'
112 , sel_naughty :: Bool -- True <=> a "naughty" selector which can't actually exist, for example @x@ in:
113 -- data T = forall a. MkT { x :: a }
114 } -- See Note [Naughty record selectors] in TcTyClsDecls
116 | DataConWorkId DataCon -- ^ The 'Id' is for a data constructor /worker/
117 | DataConWrapId DataCon -- ^ The 'Id' is for a data constructor /wrapper/
119 -- [the only reasons we need to know is so that
120 -- a) to support isImplicitId
121 -- b) when desugaring a RecordCon we can get
122 -- from the Id back to the data con]
124 | ClassOpId Class -- ^ The 'Id' is an superclass selector or class operation of a class
126 | PrimOpId PrimOp -- ^ The 'Id' is for a primitive operator
127 | FCallId ForeignCall -- ^ The 'Id' is for a foreign call
129 | TickBoxOpId TickBoxOp -- ^ The 'Id' is for a HPC tick box (both traditional and binary)
131 | DFunId Int Bool -- ^ A dictionary function.
132 -- Int = the number of "silent" arguments to the dfun
133 -- e.g. class D a => C a where ...
134 -- instance C a => C [a]
135 -- has is_silent = 1, because the dfun
136 -- has type dfun :: (D a, C a) => C [a]
137 -- See the DFun Superclass Invariant in TcInstDcls
139 -- Bool = True <=> the class has only one method, so may be
140 -- implemented with a newtype, so it might be bad
141 -- to be strict on this dictionary
143 instance Outputable IdDetails where
146 pprIdDetails :: IdDetails -> SDoc
147 pprIdDetails VanillaId = empty
148 pprIdDetails other = brackets (pp other)
150 pp VanillaId = panic "pprIdDetails"
151 pp (DataConWorkId _) = ptext (sLit "DataCon")
152 pp (DataConWrapId _) = ptext (sLit "DataConWrapper")
153 pp (ClassOpId {}) = ptext (sLit "ClassOp")
154 pp (PrimOpId _) = ptext (sLit "PrimOp")
155 pp (FCallId _) = ptext (sLit "ForeignCall")
156 pp (TickBoxOpId _) = ptext (sLit "TickBoxOp")
157 pp (DFunId ns nt) = ptext (sLit "DFunId")
158 <> ppWhen (ns /= 0) (brackets (int ns))
159 <> ppWhen nt (ptext (sLit "(nt)"))
160 pp (RecSelId { sel_naughty = is_naughty })
161 = brackets $ ptext (sLit "RecSel")
162 <> ppWhen is_naughty (ptext (sLit "(naughty)"))
166 %************************************************************************
168 \subsection{The main IdInfo type}
170 %************************************************************************
173 -- | An 'IdInfo' gives /optional/ information about an 'Id'. If
174 -- present it never lies, but it may not be present, in which case there
175 -- is always a conservative assumption which can be made.
177 -- Two 'Id's may have different info even though they have the same
178 -- 'Unique' (and are hence the same 'Id'); for example, one might lack
179 -- the properties attached to the other.
181 -- The 'IdInfo' gives information about the value, or definition, of the
182 -- 'Id'. It does not contain information about the 'Id''s usage,
183 -- except for 'demandInfo' and 'lbvarInfo'.
186 arityInfo :: !ArityInfo, -- ^ 'Id' arity
187 specInfo :: SpecInfo, -- ^ Specialisations of the 'Id's function which exist
188 -- See Note [Specialisations and RULES in IdInfo]
189 unfoldingInfo :: Unfolding, -- ^ The 'Id's unfolding
190 cafInfo :: CafInfo, -- ^ 'Id' CAF info
191 lbvarInfo :: LBVarInfo, -- ^ Info about a lambda-bound variable, if the 'Id' is one
192 inlinePragInfo :: InlinePragma, -- ^ Any inline pragma atached to the 'Id'
193 occInfo :: OccInfo, -- ^ How the 'Id' occurs in the program
195 strictnessInfo :: Maybe StrictSig, -- ^ Id strictness information. Reason for Maybe:
196 -- the DmdAnal phase needs to know whether
197 -- this is the first visit, so it can assign botSig.
198 -- Other customers want topSig. So @Nothing@ is good.
200 demandInfo :: Maybe Demand -- ^ Id demand information. Similarly we want to know
201 -- if there's no known demand yet, for when we are looking
205 -- | Just evaluate the 'IdInfo' to WHNF
206 seqIdInfo :: IdInfo -> ()
207 seqIdInfo (IdInfo {}) = ()
209 -- | Evaluate all the fields of the 'IdInfo' that are generally demanded by the
211 megaSeqIdInfo :: IdInfo -> ()
213 = seqSpecInfo (specInfo info) `seq`
215 -- Omitting this improves runtimes a little, presumably because
216 -- some unfoldings are not calculated at all
217 -- seqUnfolding (unfoldingInfo info) `seq`
219 seqDemandInfo (demandInfo info) `seq`
220 seqStrictnessInfo (strictnessInfo info) `seq`
222 seqCaf (cafInfo info) `seq`
223 seqLBVar (lbvarInfo info) `seq`
224 seqOccInfo (occInfo info)
226 seqStrictnessInfo :: Maybe StrictSig -> ()
227 seqStrictnessInfo Nothing = ()
228 seqStrictnessInfo (Just ty) = seqStrictSig ty
230 seqDemandInfo :: Maybe Demand -> ()
231 seqDemandInfo Nothing = ()
232 seqDemandInfo (Just dmd) = seqDemand dmd
238 setSpecInfo :: IdInfo -> SpecInfo -> IdInfo
239 setSpecInfo info sp = sp `seq` info { specInfo = sp }
240 setInlinePragInfo :: IdInfo -> InlinePragma -> IdInfo
241 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
242 setOccInfo :: IdInfo -> OccInfo -> IdInfo
243 setOccInfo info oc = oc `seq` info { occInfo = oc }
244 -- Try to avoid spack leaks by seq'ing
246 setUnfoldingInfoLazily :: IdInfo -> Unfolding -> IdInfo
247 setUnfoldingInfoLazily info uf -- Lazy variant to avoid looking at the
248 = -- unfolding of an imported Id unless necessary
249 info { unfoldingInfo = uf } -- (In this case the demand-zapping is redundant.)
251 setUnfoldingInfo :: IdInfo -> Unfolding -> IdInfo
252 setUnfoldingInfo info uf
253 = -- We don't seq the unfolding, as we generate intermediate
254 -- unfoldings which are just thrown away, so evaluating them is a
256 -- seqUnfolding uf `seq`
257 info { unfoldingInfo = uf }
259 setArityInfo :: IdInfo -> ArityInfo -> IdInfo
260 setArityInfo info ar = info { arityInfo = ar }
261 setCafInfo :: IdInfo -> CafInfo -> IdInfo
262 setCafInfo info caf = info { cafInfo = caf }
264 setLBVarInfo :: IdInfo -> LBVarInfo -> IdInfo
265 setLBVarInfo info lb = {-lb `seq`-} info { lbvarInfo = lb }
267 setDemandInfo :: IdInfo -> Maybe Demand -> IdInfo
268 setDemandInfo info dd = dd `seq` info { demandInfo = dd }
270 setStrictnessInfo :: IdInfo -> Maybe StrictSig -> IdInfo
271 setStrictnessInfo info dd = dd `seq` info { strictnessInfo = dd }
276 -- | Basic 'IdInfo' that carries no useful information whatsoever
277 vanillaIdInfo :: IdInfo
280 cafInfo = vanillaCafInfo,
281 arityInfo = unknownArity,
282 specInfo = emptySpecInfo,
283 unfoldingInfo = noUnfolding,
284 lbvarInfo = NoLBVarInfo,
285 inlinePragInfo = defaultInlinePragma,
287 demandInfo = Nothing,
288 strictnessInfo = Nothing
291 -- | More informative 'IdInfo' we can use when we know the 'Id' has no CAF references
292 noCafIdInfo :: IdInfo
293 noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
294 -- Used for built-in type Ids in MkId.
298 %************************************************************************
300 \subsection[arity-IdInfo]{Arity info about an @Id@}
302 %************************************************************************
304 For locally-defined Ids, the code generator maintains its own notion
305 of their arities; so it should not be asking... (but other things
306 besides the code-generator need arity info!)
309 -- | An 'ArityInfo' of @n@ tells us that partial application of this
310 -- 'Id' to up to @n-1@ value arguments does essentially no work.
312 -- That is not necessarily the same as saying that it has @n@ leading
313 -- lambdas, because coerces may get in the way.
315 -- The arity might increase later in the compilation process, if
316 -- an extra lambda floats up to the binding site.
317 type ArityInfo = Arity
319 -- | It is always safe to assume that an 'Id' has an arity of 0
320 unknownArity :: Arity
321 unknownArity = 0 :: Arity
323 ppArityInfo :: Int -> SDoc
324 ppArityInfo 0 = empty
325 ppArityInfo n = hsep [ptext (sLit "Arity"), int n]
328 %************************************************************************
330 \subsection{Inline-pragma information}
332 %************************************************************************
335 -- | Tells when the inlining is active.
336 -- When it is active the thing may be inlined, depending on how
339 -- If there was an @INLINE@ pragma, then as a separate matter, the
340 -- RHS will have been made to look small with a Core inline 'Note'
342 -- The default 'InlinePragInfo' is 'AlwaysActive', so the info serves
343 -- entirely as a way to inhibit inlining until we want it
344 type InlinePragInfo = InlinePragma
348 %************************************************************************
352 %************************************************************************
355 pprStrictness :: Maybe StrictSig -> SDoc
356 pprStrictness Nothing = empty
357 pprStrictness (Just sig) = ppr sig
361 %************************************************************************
365 %************************************************************************
367 Note [Specialisations and RULES in IdInfo]
368 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
369 Generally speaking, a GlobalIdshas an *empty* SpecInfo. All their
370 RULES are contained in the globally-built rule-base. In principle,
371 one could attach the to M.f the RULES for M.f that are defined in M.
372 But we don't do that for instance declarations and so we just treat
375 The EXCEPTION is PrimOpIds, which do have rules in their IdInfo. That is
376 jsut for convenience really.
378 However, LocalIds may have non-empty SpecInfo. We treat them
380 a) they might be nested, in which case a global table won't work
381 b) the RULE might mention free variables, which we use to keep things alive
383 In TidyPgm, when the LocalId becomes a GlobalId, its RULES are stripped off
384 and put in the global list.
387 -- | Records the specializations of this 'Id' that we know about
388 -- in the form of rewrite 'CoreRule's that target them
392 VarSet -- Locally-defined free vars of *both* LHS and RHS
393 -- of rules. I don't think it needs to include the
395 -- Note [Rule dependency info] in OccurAnal
397 -- | Assume that no specilizations exist: always safe
398 emptySpecInfo :: SpecInfo
399 emptySpecInfo = SpecInfo [] emptyVarSet
401 isEmptySpecInfo :: SpecInfo -> Bool
402 isEmptySpecInfo (SpecInfo rs _) = null rs
404 -- | Retrieve the locally-defined free variables of both the left and
405 -- right hand sides of the specialization rules
406 specInfoFreeVars :: SpecInfo -> VarSet
407 specInfoFreeVars (SpecInfo _ fvs) = fvs
409 specInfoRules :: SpecInfo -> [CoreRule]
410 specInfoRules (SpecInfo rules _) = rules
412 -- | Change the name of the function the rule is keyed on on all of the 'CoreRule's
413 setSpecInfoHead :: Name -> SpecInfo -> SpecInfo
414 setSpecInfoHead fn (SpecInfo rules fvs)
415 = SpecInfo (map (setRuleIdName fn) rules) fvs
417 seqSpecInfo :: SpecInfo -> ()
418 seqSpecInfo (SpecInfo rules fvs) = seqRules rules `seq` seqVarSet fvs
421 %************************************************************************
423 \subsection[CG-IdInfo]{Code generator-related information}
425 %************************************************************************
428 -- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
430 -- | Records whether an 'Id' makes Constant Applicative Form references
432 = MayHaveCafRefs -- ^ Indicates that the 'Id' is for either:
434 -- 1. A function or static constructor
435 -- that refers to one or more CAFs, or
437 -- 2. A real live CAF
439 | NoCafRefs -- ^ A function or static constructor
440 -- that refers to no CAFs.
443 -- | Assumes that the 'Id' has CAF references: definitely safe
444 vanillaCafInfo :: CafInfo
445 vanillaCafInfo = MayHaveCafRefs
447 mayHaveCafRefs :: CafInfo -> Bool
448 mayHaveCafRefs MayHaveCafRefs = True
449 mayHaveCafRefs _ = False
451 seqCaf :: CafInfo -> ()
452 seqCaf c = c `seq` ()
454 instance Outputable CafInfo where
457 ppCafInfo :: CafInfo -> SDoc
458 ppCafInfo NoCafRefs = ptext (sLit "NoCafRefs")
459 ppCafInfo MayHaveCafRefs = empty
462 %************************************************************************
464 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
466 %************************************************************************
469 -- | If the 'Id' is a lambda-bound variable then it may have lambda-bound
470 -- variable info. Sometimes we know whether the lambda binding this variable
471 -- is a \"one-shot\" lambda; that is, whether it is applied at most once.
473 -- This information may be useful in optimisation, as computations may
474 -- safely be floated inside such a lambda without risk of duplicating
476 data LBVarInfo = NoLBVarInfo -- ^ No information
477 | IsOneShotLambda -- ^ The lambda is applied at most once).
479 -- | It is always safe to assume that an 'Id' has no lambda-bound variable information
480 noLBVarInfo :: LBVarInfo
481 noLBVarInfo = NoLBVarInfo
483 hasNoLBVarInfo :: LBVarInfo -> Bool
484 hasNoLBVarInfo NoLBVarInfo = True
485 hasNoLBVarInfo IsOneShotLambda = False
487 seqLBVar :: LBVarInfo -> ()
488 seqLBVar l = l `seq` ()
490 pprLBVarInfo :: LBVarInfo -> SDoc
491 pprLBVarInfo NoLBVarInfo = empty
492 pprLBVarInfo IsOneShotLambda = ptext (sLit "OneShot")
494 instance Outputable LBVarInfo where
497 instance Show LBVarInfo where
498 showsPrec p c = showsPrecSDoc p (ppr c)
502 %************************************************************************
504 \subsection{Bulk operations on IdInfo}
506 %************************************************************************
509 -- | This is used to remove information on lambda binders that we have
510 -- setup as part of a lambda group, assuming they will be applied all at once,
511 -- but turn out to be part of an unsaturated lambda as in e.g:
513 -- > (\x1. \x2. e) arg1
514 zapLamInfo :: IdInfo -> Maybe IdInfo
515 zapLamInfo info@(IdInfo {occInfo = occ, demandInfo = demand})
516 | is_safe_occ occ && is_safe_dmd demand
519 = Just (info {occInfo = safe_occ, demandInfo = Nothing})
521 -- The "unsafe" occ info is the ones that say I'm not in a lambda
522 -- because that might not be true for an unsaturated lambda
523 is_safe_occ (OneOcc in_lam _ _) = in_lam
524 is_safe_occ _other = True
526 safe_occ = case occ of
527 OneOcc _ once int_cxt -> OneOcc insideLam once int_cxt
530 is_safe_dmd Nothing = True
531 is_safe_dmd (Just dmd) = not (isStrictDmd dmd)
535 -- | Remove demand info on the 'IdInfo' if it is present, otherwise return @Nothing@
536 zapDemandInfo :: IdInfo -> Maybe IdInfo
537 zapDemandInfo info@(IdInfo {demandInfo = dmd})
538 | isJust dmd = Just (info {demandInfo = Nothing})
539 | otherwise = Nothing
543 zapFragileInfo :: IdInfo -> Maybe IdInfo
544 -- ^ Zap info that depends on free variables
546 = Just (info `setSpecInfo` emptySpecInfo
547 `setUnfoldingInfo` noUnfolding
548 `setOccInfo` zapFragileOcc occ)
553 %************************************************************************
555 \subsection{TickBoxOp}
557 %************************************************************************
562 -- | Tick box for Hpc-style coverage
564 = TickBox Module {-# UNPACK #-} !TickBoxId
566 instance Outputable TickBoxOp where
567 ppr (TickBox mod n) = ptext (sLit "tick") <+> ppr (mod,n)