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, coVarDetails,
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 coVarDetails :: IdDetails
145 coVarDetails = VanillaId
147 instance Outputable IdDetails where
150 pprIdDetails :: IdDetails -> SDoc
151 pprIdDetails VanillaId = empty
152 pprIdDetails other = brackets (pp other)
154 pp VanillaId = panic "pprIdDetails"
155 pp (DataConWorkId _) = ptext (sLit "DataCon")
156 pp (DataConWrapId _) = ptext (sLit "DataConWrapper")
157 pp (ClassOpId {}) = ptext (sLit "ClassOp")
158 pp (PrimOpId _) = ptext (sLit "PrimOp")
159 pp (FCallId _) = ptext (sLit "ForeignCall")
160 pp (TickBoxOpId _) = ptext (sLit "TickBoxOp")
161 pp (DFunId ns nt) = ptext (sLit "DFunId")
162 <> ppWhen (ns /= 0) (brackets (int ns))
163 <> ppWhen nt (ptext (sLit "(nt)"))
164 pp (RecSelId { sel_naughty = is_naughty })
165 = brackets $ ptext (sLit "RecSel")
166 <> ppWhen is_naughty (ptext (sLit "(naughty)"))
170 %************************************************************************
172 \subsection{The main IdInfo type}
174 %************************************************************************
177 -- | An 'IdInfo' gives /optional/ information about an 'Id'. If
178 -- present it never lies, but it may not be present, in which case there
179 -- is always a conservative assumption which can be made.
181 -- Two 'Id's may have different info even though they have the same
182 -- 'Unique' (and are hence the same 'Id'); for example, one might lack
183 -- the properties attached to the other.
185 -- The 'IdInfo' gives information about the value, or definition, of the
186 -- 'Id'. It does not contain information about the 'Id''s usage,
187 -- except for 'demandInfo' and 'lbvarInfo'.
190 arityInfo :: !ArityInfo, -- ^ 'Id' arity
191 specInfo :: SpecInfo, -- ^ Specialisations of the 'Id's function which exist
192 -- See Note [Specialisations and RULES in IdInfo]
193 unfoldingInfo :: Unfolding, -- ^ The 'Id's unfolding
194 cafInfo :: CafInfo, -- ^ 'Id' CAF info
195 lbvarInfo :: LBVarInfo, -- ^ Info about a lambda-bound variable, if the 'Id' is one
196 inlinePragInfo :: InlinePragma, -- ^ Any inline pragma atached to the 'Id'
197 occInfo :: OccInfo, -- ^ How the 'Id' occurs in the program
199 strictnessInfo :: Maybe StrictSig, -- ^ Id strictness information. Reason for Maybe:
200 -- the DmdAnal phase needs to know whether
201 -- this is the first visit, so it can assign botSig.
202 -- Other customers want topSig. So @Nothing@ is good.
204 demandInfo :: Maybe Demand -- ^ Id demand information. Similarly we want to know
205 -- if there's no known demand yet, for when we are looking
209 -- | Just evaluate the 'IdInfo' to WHNF
210 seqIdInfo :: IdInfo -> ()
211 seqIdInfo (IdInfo {}) = ()
213 -- | Evaluate all the fields of the 'IdInfo' that are generally demanded by the
215 megaSeqIdInfo :: IdInfo -> ()
217 = seqSpecInfo (specInfo info) `seq`
219 -- Omitting this improves runtimes a little, presumably because
220 -- some unfoldings are not calculated at all
221 -- seqUnfolding (unfoldingInfo info) `seq`
223 seqDemandInfo (demandInfo info) `seq`
224 seqStrictnessInfo (strictnessInfo info) `seq`
226 seqCaf (cafInfo info) `seq`
227 seqLBVar (lbvarInfo info) `seq`
228 seqOccInfo (occInfo info)
230 seqStrictnessInfo :: Maybe StrictSig -> ()
231 seqStrictnessInfo Nothing = ()
232 seqStrictnessInfo (Just ty) = seqStrictSig ty
234 seqDemandInfo :: Maybe Demand -> ()
235 seqDemandInfo Nothing = ()
236 seqDemandInfo (Just dmd) = seqDemand dmd
242 setSpecInfo :: IdInfo -> SpecInfo -> IdInfo
243 setSpecInfo info sp = sp `seq` info { specInfo = sp }
244 setInlinePragInfo :: IdInfo -> InlinePragma -> IdInfo
245 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
246 setOccInfo :: IdInfo -> OccInfo -> IdInfo
247 setOccInfo info oc = oc `seq` info { occInfo = oc }
248 -- Try to avoid spack leaks by seq'ing
250 setUnfoldingInfoLazily :: IdInfo -> Unfolding -> IdInfo
251 setUnfoldingInfoLazily info uf -- Lazy variant to avoid looking at the
252 = -- unfolding of an imported Id unless necessary
253 info { unfoldingInfo = uf } -- (In this case the demand-zapping is redundant.)
255 setUnfoldingInfo :: IdInfo -> Unfolding -> IdInfo
256 setUnfoldingInfo info uf
257 = -- We don't seq the unfolding, as we generate intermediate
258 -- unfoldings which are just thrown away, so evaluating them is a
260 -- seqUnfolding uf `seq`
261 info { unfoldingInfo = uf }
263 setArityInfo :: IdInfo -> ArityInfo -> IdInfo
264 setArityInfo info ar = info { arityInfo = ar }
265 setCafInfo :: IdInfo -> CafInfo -> IdInfo
266 setCafInfo info caf = info { cafInfo = caf }
268 setLBVarInfo :: IdInfo -> LBVarInfo -> IdInfo
269 setLBVarInfo info lb = {-lb `seq`-} info { lbvarInfo = lb }
271 setDemandInfo :: IdInfo -> Maybe Demand -> IdInfo
272 setDemandInfo info dd = dd `seq` info { demandInfo = dd }
274 setStrictnessInfo :: IdInfo -> Maybe StrictSig -> IdInfo
275 setStrictnessInfo info dd = dd `seq` info { strictnessInfo = dd }
280 -- | Basic 'IdInfo' that carries no useful information whatsoever
281 vanillaIdInfo :: IdInfo
284 cafInfo = vanillaCafInfo,
285 arityInfo = unknownArity,
286 specInfo = emptySpecInfo,
287 unfoldingInfo = noUnfolding,
288 lbvarInfo = NoLBVarInfo,
289 inlinePragInfo = defaultInlinePragma,
291 demandInfo = Nothing,
292 strictnessInfo = Nothing
295 -- | More informative 'IdInfo' we can use when we know the 'Id' has no CAF references
296 noCafIdInfo :: IdInfo
297 noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
298 -- Used for built-in type Ids in MkId.
302 %************************************************************************
304 \subsection[arity-IdInfo]{Arity info about an @Id@}
306 %************************************************************************
308 For locally-defined Ids, the code generator maintains its own notion
309 of their arities; so it should not be asking... (but other things
310 besides the code-generator need arity info!)
313 -- | An 'ArityInfo' of @n@ tells us that partial application of this
314 -- 'Id' to up to @n-1@ value arguments does essentially no work.
316 -- That is not necessarily the same as saying that it has @n@ leading
317 -- lambdas, because coerces may get in the way.
319 -- The arity might increase later in the compilation process, if
320 -- an extra lambda floats up to the binding site.
321 type ArityInfo = Arity
323 -- | It is always safe to assume that an 'Id' has an arity of 0
324 unknownArity :: Arity
325 unknownArity = 0 :: Arity
327 ppArityInfo :: Int -> SDoc
328 ppArityInfo 0 = empty
329 ppArityInfo n = hsep [ptext (sLit "Arity"), int n]
332 %************************************************************************
334 \subsection{Inline-pragma information}
336 %************************************************************************
339 -- | Tells when the inlining is active.
340 -- When it is active the thing may be inlined, depending on how
343 -- If there was an @INLINE@ pragma, then as a separate matter, the
344 -- RHS will have been made to look small with a Core inline 'Note'
346 -- The default 'InlinePragInfo' is 'AlwaysActive', so the info serves
347 -- entirely as a way to inhibit inlining until we want it
348 type InlinePragInfo = InlinePragma
352 %************************************************************************
356 %************************************************************************
359 pprStrictness :: Maybe StrictSig -> SDoc
360 pprStrictness Nothing = empty
361 pprStrictness (Just sig) = ppr sig
365 %************************************************************************
369 %************************************************************************
371 Note [Specialisations and RULES in IdInfo]
372 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
373 Generally speaking, a GlobalIdshas an *empty* SpecInfo. All their
374 RULES are contained in the globally-built rule-base. In principle,
375 one could attach the to M.f the RULES for M.f that are defined in M.
376 But we don't do that for instance declarations and so we just treat
379 The EXCEPTION is PrimOpIds, which do have rules in their IdInfo. That is
380 jsut for convenience really.
382 However, LocalIds may have non-empty SpecInfo. We treat them
384 a) they might be nested, in which case a global table won't work
385 b) the RULE might mention free variables, which we use to keep things alive
387 In TidyPgm, when the LocalId becomes a GlobalId, its RULES are stripped off
388 and put in the global list.
391 -- | Records the specializations of this 'Id' that we know about
392 -- in the form of rewrite 'CoreRule's that target them
396 VarSet -- Locally-defined free vars of *both* LHS and RHS
397 -- of rules. I don't think it needs to include the
399 -- Note [Rule dependency info] in OccurAnal
401 -- | Assume that no specilizations exist: always safe
402 emptySpecInfo :: SpecInfo
403 emptySpecInfo = SpecInfo [] emptyVarSet
405 isEmptySpecInfo :: SpecInfo -> Bool
406 isEmptySpecInfo (SpecInfo rs _) = null rs
408 -- | Retrieve the locally-defined free variables of both the left and
409 -- right hand sides of the specialization rules
410 specInfoFreeVars :: SpecInfo -> VarSet
411 specInfoFreeVars (SpecInfo _ fvs) = fvs
413 specInfoRules :: SpecInfo -> [CoreRule]
414 specInfoRules (SpecInfo rules _) = rules
416 -- | Change the name of the function the rule is keyed on on all of the 'CoreRule's
417 setSpecInfoHead :: Name -> SpecInfo -> SpecInfo
418 setSpecInfoHead fn (SpecInfo rules fvs)
419 = SpecInfo (map (setRuleIdName fn) rules) fvs
421 seqSpecInfo :: SpecInfo -> ()
422 seqSpecInfo (SpecInfo rules fvs) = seqRules rules `seq` seqVarSet fvs
425 %************************************************************************
427 \subsection[CG-IdInfo]{Code generator-related information}
429 %************************************************************************
432 -- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
434 -- | Records whether an 'Id' makes Constant Applicative Form references
436 = MayHaveCafRefs -- ^ Indicates that the 'Id' is for either:
438 -- 1. A function or static constructor
439 -- that refers to one or more CAFs, or
441 -- 2. A real live CAF
443 | NoCafRefs -- ^ A function or static constructor
444 -- that refers to no CAFs.
447 -- | Assumes that the 'Id' has CAF references: definitely safe
448 vanillaCafInfo :: CafInfo
449 vanillaCafInfo = MayHaveCafRefs
451 mayHaveCafRefs :: CafInfo -> Bool
452 mayHaveCafRefs MayHaveCafRefs = True
453 mayHaveCafRefs _ = False
455 seqCaf :: CafInfo -> ()
456 seqCaf c = c `seq` ()
458 instance Outputable CafInfo where
461 ppCafInfo :: CafInfo -> SDoc
462 ppCafInfo NoCafRefs = ptext (sLit "NoCafRefs")
463 ppCafInfo MayHaveCafRefs = empty
466 %************************************************************************
468 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
470 %************************************************************************
473 -- | If the 'Id' is a lambda-bound variable then it may have lambda-bound
474 -- variable info. Sometimes we know whether the lambda binding this variable
475 -- is a \"one-shot\" lambda; that is, whether it is applied at most once.
477 -- This information may be useful in optimisation, as computations may
478 -- safely be floated inside such a lambda without risk of duplicating
480 data LBVarInfo = NoLBVarInfo -- ^ No information
481 | IsOneShotLambda -- ^ The lambda is applied at most once).
483 -- | It is always safe to assume that an 'Id' has no lambda-bound variable information
484 noLBVarInfo :: LBVarInfo
485 noLBVarInfo = NoLBVarInfo
487 hasNoLBVarInfo :: LBVarInfo -> Bool
488 hasNoLBVarInfo NoLBVarInfo = True
489 hasNoLBVarInfo IsOneShotLambda = False
491 seqLBVar :: LBVarInfo -> ()
492 seqLBVar l = l `seq` ()
494 pprLBVarInfo :: LBVarInfo -> SDoc
495 pprLBVarInfo NoLBVarInfo = empty
496 pprLBVarInfo IsOneShotLambda = ptext (sLit "OneShot")
498 instance Outputable LBVarInfo where
501 instance Show LBVarInfo where
502 showsPrec p c = showsPrecSDoc p (ppr c)
506 %************************************************************************
508 \subsection{Bulk operations on IdInfo}
510 %************************************************************************
513 -- | This is used to remove information on lambda binders that we have
514 -- setup as part of a lambda group, assuming they will be applied all at once,
515 -- but turn out to be part of an unsaturated lambda as in e.g:
517 -- > (\x1. \x2. e) arg1
518 zapLamInfo :: IdInfo -> Maybe IdInfo
519 zapLamInfo info@(IdInfo {occInfo = occ, demandInfo = demand})
520 | is_safe_occ occ && is_safe_dmd demand
523 = Just (info {occInfo = safe_occ, demandInfo = Nothing})
525 -- The "unsafe" occ info is the ones that say I'm not in a lambda
526 -- because that might not be true for an unsaturated lambda
527 is_safe_occ (OneOcc in_lam _ _) = in_lam
528 is_safe_occ _other = True
530 safe_occ = case occ of
531 OneOcc _ once int_cxt -> OneOcc insideLam once int_cxt
534 is_safe_dmd Nothing = True
535 is_safe_dmd (Just dmd) = not (isStrictDmd dmd)
539 -- | Remove demand info on the 'IdInfo' if it is present, otherwise return @Nothing@
540 zapDemandInfo :: IdInfo -> Maybe IdInfo
541 zapDemandInfo info@(IdInfo {demandInfo = dmd})
542 | isJust dmd = Just (info {demandInfo = Nothing})
543 | otherwise = Nothing
547 zapFragileInfo :: IdInfo -> Maybe IdInfo
548 -- ^ Zap info that depends on free variables
550 = Just (info `setSpecInfo` emptySpecInfo
551 `setUnfoldingInfo` noUnfolding
552 `setOccInfo` zapFragileOcc occ)
557 %************************************************************************
559 \subsection{TickBoxOp}
561 %************************************************************************
566 -- | Tick box for Hpc-style coverage
568 = TickBox Module {-# UNPACK #-} !TickBoxId
570 instance Outputable TickBoxOp where
571 ppr (TickBox mod n) = ptext (sLit "tick") <+> ppr (mod,n)