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,
67 import CoreSyn ( CoreRule, setRuleIdName, seqRules, Unfolding, noUnfolding )
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 Bool -- ^ A dictionary function.
132 -- True <=> the class has only one method, so may be
133 -- implemented with a newtype, so it might be bad
134 -- to be strict on this dictionary
137 instance Outputable IdDetails where
140 pprIdDetails :: IdDetails -> SDoc
141 pprIdDetails VanillaId = empty
142 pprIdDetails other = brackets (pp other)
144 pp VanillaId = panic "pprIdDetails"
145 pp (DataConWorkId _) = ptext (sLit "DataCon")
146 pp (DataConWrapId _) = ptext (sLit "DataConWrapper")
147 pp (ClassOpId {}) = ptext (sLit "ClassOp")
148 pp (PrimOpId _) = ptext (sLit "PrimOp")
149 pp (FCallId _) = ptext (sLit "ForeignCall")
150 pp (TickBoxOpId _) = ptext (sLit "TickBoxOp")
151 pp (DFunId b) = ptext (sLit "DFunId") <>
152 ppWhen b (ptext (sLit "(newtype)"))
153 pp (RecSelId { sel_naughty = is_naughty })
154 = brackets $ ptext (sLit "RecSel")
155 <> ppWhen is_naughty (ptext (sLit "(naughty)"))
159 %************************************************************************
161 \subsection{The main IdInfo type}
163 %************************************************************************
166 -- | An 'IdInfo' gives /optional/ information about an 'Id'. If
167 -- present it never lies, but it may not be present, in which case there
168 -- is always a conservative assumption which can be made.
170 -- Two 'Id's may have different info even though they have the same
171 -- 'Unique' (and are hence the same 'Id'); for example, one might lack
172 -- the properties attached to the other.
174 -- The 'IdInfo' gives information about the value, or definition, of the
175 -- 'Id'. It does not contain information about the 'Id''s usage,
176 -- except for 'demandInfo' and 'lbvarInfo'.
179 arityInfo :: !ArityInfo, -- ^ 'Id' arity
180 specInfo :: SpecInfo, -- ^ Specialisations of the 'Id's function which exist
181 -- See Note [Specialisations and RULES in IdInfo]
182 unfoldingInfo :: Unfolding, -- ^ The 'Id's unfolding
183 cafInfo :: CafInfo, -- ^ 'Id' CAF info
184 lbvarInfo :: LBVarInfo, -- ^ Info about a lambda-bound variable, if the 'Id' is one
185 inlinePragInfo :: InlinePragma, -- ^ Any inline pragma atached to the 'Id'
186 occInfo :: OccInfo, -- ^ How the 'Id' occurs in the program
188 strictnessInfo :: Maybe StrictSig, -- ^ Id strictness information. Reason for Maybe:
189 -- the DmdAnal phase needs to know whether
190 -- this is the first visit, so it can assign botSig.
191 -- Other customers want topSig. So @Nothing@ is good.
193 demandInfo :: Maybe Demand -- ^ Id demand information. Similarly we want to know
194 -- if there's no known demand yet, for when we are looking
198 -- | Just evaluate the 'IdInfo' to WHNF
199 seqIdInfo :: IdInfo -> ()
200 seqIdInfo (IdInfo {}) = ()
202 -- | Evaluate all the fields of the 'IdInfo' that are generally demanded by the
204 megaSeqIdInfo :: IdInfo -> ()
206 = seqSpecInfo (specInfo info) `seq`
208 -- Omitting this improves runtimes a little, presumably because
209 -- some unfoldings are not calculated at all
210 -- seqUnfolding (unfoldingInfo info) `seq`
212 seqDemandInfo (demandInfo info) `seq`
213 seqStrictnessInfo (strictnessInfo info) `seq`
215 seqCaf (cafInfo info) `seq`
216 seqLBVar (lbvarInfo info) `seq`
217 seqOccInfo (occInfo info)
219 seqStrictnessInfo :: Maybe StrictSig -> ()
220 seqStrictnessInfo Nothing = ()
221 seqStrictnessInfo (Just ty) = seqStrictSig ty
223 seqDemandInfo :: Maybe Demand -> ()
224 seqDemandInfo Nothing = ()
225 seqDemandInfo (Just dmd) = seqDemand dmd
231 setSpecInfo :: IdInfo -> SpecInfo -> IdInfo
232 setSpecInfo info sp = sp `seq` info { specInfo = sp }
233 setInlinePragInfo :: IdInfo -> InlinePragma -> IdInfo
234 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
235 setOccInfo :: IdInfo -> OccInfo -> IdInfo
236 setOccInfo info oc = oc `seq` info { occInfo = oc }
237 -- Try to avoid spack leaks by seq'ing
239 setUnfoldingInfoLazily :: IdInfo -> Unfolding -> IdInfo
240 setUnfoldingInfoLazily info uf -- Lazy variant to avoid looking at the
241 = -- unfolding of an imported Id unless necessary
242 info { unfoldingInfo = uf } -- (In this case the demand-zapping is redundant.)
244 setUnfoldingInfo :: IdInfo -> Unfolding -> IdInfo
245 setUnfoldingInfo info uf
246 -- We do *not* seq on the unfolding info, For some reason, doing so
247 -- actually increases residency significantly.
248 = info { unfoldingInfo = uf }
250 setArityInfo :: IdInfo -> ArityInfo -> IdInfo
251 setArityInfo info ar = info { arityInfo = ar }
252 setCafInfo :: IdInfo -> CafInfo -> IdInfo
253 setCafInfo info caf = info { cafInfo = caf }
255 setLBVarInfo :: IdInfo -> LBVarInfo -> IdInfo
256 setLBVarInfo info lb = {-lb `seq`-} info { lbvarInfo = lb }
258 setDemandInfo :: IdInfo -> Maybe Demand -> IdInfo
259 setDemandInfo info dd = dd `seq` info { demandInfo = dd }
261 setStrictnessInfo :: IdInfo -> Maybe StrictSig -> IdInfo
262 setStrictnessInfo info dd = dd `seq` info { strictnessInfo = dd }
267 -- | Basic 'IdInfo' that carries no useful information whatsoever
268 vanillaIdInfo :: IdInfo
271 cafInfo = vanillaCafInfo,
272 arityInfo = unknownArity,
273 specInfo = emptySpecInfo,
274 unfoldingInfo = noUnfolding,
275 lbvarInfo = NoLBVarInfo,
276 inlinePragInfo = defaultInlinePragma,
278 demandInfo = Nothing,
279 strictnessInfo = Nothing
282 -- | More informative 'IdInfo' we can use when we know the 'Id' has no CAF references
283 noCafIdInfo :: IdInfo
284 noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
285 -- Used for built-in type Ids in MkId.
289 %************************************************************************
291 \subsection[arity-IdInfo]{Arity info about an @Id@}
293 %************************************************************************
295 For locally-defined Ids, the code generator maintains its own notion
296 of their arities; so it should not be asking... (but other things
297 besides the code-generator need arity info!)
300 -- | An 'ArityInfo' of @n@ tells us that partial application of this
301 -- 'Id' to up to @n-1@ value arguments does essentially no work.
303 -- That is not necessarily the same as saying that it has @n@ leading
304 -- lambdas, because coerces may get in the way.
306 -- The arity might increase later in the compilation process, if
307 -- an extra lambda floats up to the binding site.
308 type ArityInfo = Arity
310 -- | It is always safe to assume that an 'Id' has an arity of 0
311 unknownArity :: Arity
312 unknownArity = 0 :: Arity
314 ppArityInfo :: Int -> SDoc
315 ppArityInfo 0 = empty
316 ppArityInfo n = hsep [ptext (sLit "Arity"), int n]
319 %************************************************************************
321 \subsection{Inline-pragma information}
323 %************************************************************************
326 -- | Tells when the inlining is active.
327 -- When it is active the thing may be inlined, depending on how
330 -- If there was an @INLINE@ pragma, then as a separate matter, the
331 -- RHS will have been made to look small with a Core inline 'Note'
333 -- The default 'InlinePragInfo' is 'AlwaysActive', so the info serves
334 -- entirely as a way to inhibit inlining until we want it
335 type InlinePragInfo = InlinePragma
339 %************************************************************************
343 %************************************************************************
346 pprStrictness :: Maybe StrictSig -> SDoc
347 pprStrictness Nothing = empty
348 pprStrictness (Just sig) = ppr sig
352 %************************************************************************
356 %************************************************************************
358 Note [Specialisations and RULES in IdInfo]
359 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
360 Generally speaking, a GlobalIdshas an *empty* SpecInfo. All their
361 RULES are contained in the globally-built rule-base. In principle,
362 one could attach the to M.f the RULES for M.f that are defined in M.
363 But we don't do that for instance declarations and so we just treat
366 The EXCEPTION is PrimOpIds, which do have rules in their IdInfo. That is
367 jsut for convenience really.
369 However, LocalIds may have non-empty SpecInfo. We treat them
371 a) they might be nested, in which case a global table won't work
372 b) the RULE might mention free variables, which we use to keep things alive
374 In TidyPgm, when the LocalId becomes a GlobalId, its RULES are stripped off
375 and put in the global list.
378 -- | Records the specializations of this 'Id' that we know about
379 -- in the form of rewrite 'CoreRule's that target them
383 VarSet -- Locally-defined free vars of *both* LHS and RHS
384 -- of rules. I don't think it needs to include the
386 -- Note [Rule dependency info] in OccurAnal
388 -- | Assume that no specilizations exist: always safe
389 emptySpecInfo :: SpecInfo
390 emptySpecInfo = SpecInfo [] emptyVarSet
392 isEmptySpecInfo :: SpecInfo -> Bool
393 isEmptySpecInfo (SpecInfo rs _) = null rs
395 -- | Retrieve the locally-defined free variables of both the left and
396 -- right hand sides of the specialization rules
397 specInfoFreeVars :: SpecInfo -> VarSet
398 specInfoFreeVars (SpecInfo _ fvs) = fvs
400 specInfoRules :: SpecInfo -> [CoreRule]
401 specInfoRules (SpecInfo rules _) = rules
403 -- | Change the name of the function the rule is keyed on on all of the 'CoreRule's
404 setSpecInfoHead :: Name -> SpecInfo -> SpecInfo
405 setSpecInfoHead fn (SpecInfo rules fvs)
406 = SpecInfo (map (setRuleIdName fn) rules) fvs
408 seqSpecInfo :: SpecInfo -> ()
409 seqSpecInfo (SpecInfo rules fvs) = seqRules rules `seq` seqVarSet fvs
412 %************************************************************************
414 \subsection[CG-IdInfo]{Code generator-related information}
416 %************************************************************************
419 -- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
421 -- | Records whether an 'Id' makes Constant Applicative Form references
423 = MayHaveCafRefs -- ^ Indicates that the 'Id' is for either:
425 -- 1. A function or static constructor
426 -- that refers to one or more CAFs, or
428 -- 2. A real live CAF
430 | NoCafRefs -- ^ A function or static constructor
431 -- that refers to no CAFs.
434 -- | Assumes that the 'Id' has CAF references: definitely safe
435 vanillaCafInfo :: CafInfo
436 vanillaCafInfo = MayHaveCafRefs
438 mayHaveCafRefs :: CafInfo -> Bool
439 mayHaveCafRefs MayHaveCafRefs = True
440 mayHaveCafRefs _ = False
442 seqCaf :: CafInfo -> ()
443 seqCaf c = c `seq` ()
445 instance Outputable CafInfo where
448 ppCafInfo :: CafInfo -> SDoc
449 ppCafInfo NoCafRefs = ptext (sLit "NoCafRefs")
450 ppCafInfo MayHaveCafRefs = empty
453 %************************************************************************
455 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
457 %************************************************************************
460 -- | If the 'Id' is a lambda-bound variable then it may have lambda-bound
461 -- variable info. Sometimes we know whether the lambda binding this variable
462 -- is a \"one-shot\" lambda; that is, whether it is applied at most once.
464 -- This information may be useful in optimisation, as computations may
465 -- safely be floated inside such a lambda without risk of duplicating
467 data LBVarInfo = NoLBVarInfo -- ^ No information
468 | IsOneShotLambda -- ^ The lambda is applied at most once).
470 -- | It is always safe to assume that an 'Id' has no lambda-bound variable information
471 noLBVarInfo :: LBVarInfo
472 noLBVarInfo = NoLBVarInfo
474 hasNoLBVarInfo :: LBVarInfo -> Bool
475 hasNoLBVarInfo NoLBVarInfo = True
476 hasNoLBVarInfo IsOneShotLambda = False
478 seqLBVar :: LBVarInfo -> ()
479 seqLBVar l = l `seq` ()
481 pprLBVarInfo :: LBVarInfo -> SDoc
482 pprLBVarInfo NoLBVarInfo = empty
483 pprLBVarInfo IsOneShotLambda = ptext (sLit "OneShot")
485 instance Outputable LBVarInfo where
488 instance Show LBVarInfo where
489 showsPrec p c = showsPrecSDoc p (ppr c)
493 %************************************************************************
495 \subsection{Bulk operations on IdInfo}
497 %************************************************************************
500 -- | This is used to remove information on lambda binders that we have
501 -- setup as part of a lambda group, assuming they will be applied all at once,
502 -- but turn out to be part of an unsaturated lambda as in e.g:
504 -- > (\x1. \x2. e) arg1
505 zapLamInfo :: IdInfo -> Maybe IdInfo
506 zapLamInfo info@(IdInfo {occInfo = occ, demandInfo = demand})
507 | is_safe_occ occ && is_safe_dmd demand
510 = Just (info {occInfo = safe_occ, demandInfo = Nothing})
512 -- The "unsafe" occ info is the ones that say I'm not in a lambda
513 -- because that might not be true for an unsaturated lambda
514 is_safe_occ (OneOcc in_lam _ _) = in_lam
515 is_safe_occ _other = True
517 safe_occ = case occ of
518 OneOcc _ once int_cxt -> OneOcc insideLam once int_cxt
521 is_safe_dmd Nothing = True
522 is_safe_dmd (Just dmd) = not (isStrictDmd dmd)
526 -- | Remove demand info on the 'IdInfo' if it is present, otherwise return @Nothing@
527 zapDemandInfo :: IdInfo -> Maybe IdInfo
528 zapDemandInfo info@(IdInfo {demandInfo = dmd})
529 | isJust dmd = Just (info {demandInfo = Nothing})
530 | otherwise = Nothing
534 zapFragileInfo :: IdInfo -> Maybe IdInfo
535 -- ^ Zap info that depends on free variables
537 = Just (info `setSpecInfo` emptySpecInfo
538 `setUnfoldingInfo` noUnfolding
539 `setOccInfo` zapFragileOcc occ)
544 %************************************************************************
546 \subsection{TickBoxOp}
548 %************************************************************************
553 -- | Tick box for Hpc-style coverage
555 = TickBox Module {-# UNPACK #-} !TickBoxId
557 instance Outputable TickBoxOp where
558 ppr (TickBox mod n) = ptext (sLit "tick") <+> ppr (mod,n)