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 GlobalIdDetails(..), notGlobalId, -- Not abstract
15 vanillaIdInfo, noCafIdInfo,
16 seqIdInfo, megaSeqIdInfo,
19 zapLamInfo, zapDemandInfo, zapFragileInfo,
24 arityInfo, setArityInfo, ppArityInfo,
26 -- New demand and strictness info
27 newStrictnessInfo, setNewStrictnessInfo,
28 newDemandInfo, setNewDemandInfo, pprNewStrictness,
32 -- Strictness; imported from Demand
34 mkStrictnessInfo, noStrictnessInfo,
35 ppStrictnessInfo,isBottomingStrictness,
39 WorkerInfo(..), workerExists, wrapperArity, workerId,
40 workerInfo, setWorkerInfo, ppWorkerInfo,
43 unfoldingInfo, setUnfoldingInfo, setUnfoldingInfoLazily,
46 -- Old DemandInfo and StrictnessInfo
47 demandInfo, setDemandInfo,
48 strictnessInfo, setStrictnessInfo,
49 cprInfoFromNewStrictness,
50 oldStrictnessFromNew, newStrictnessFromOld,
53 -- Constructed Product Result Info
54 CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
59 inlinePragInfo, setInlinePragInfo,
62 OccInfo(..), isFragileOcc, isDeadOcc, isLoopBreaker,
63 InsideLam, OneBranch, insideLam, notInsideLam, oneBranch, notOneBranch,
67 SpecInfo(..), specInfo, setSpecInfo, isEmptySpecInfo,
68 specInfoFreeVars, specInfoRules, seqSpecInfo,
71 CafInfo(..), cafInfo, ppCafInfo, setCafInfo, mayHaveCafRefs,
73 -- Lambda-bound variable info
74 LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo,
77 TickBoxOp(..), TickBoxId,
80 #include "HsVersions.h"
100 import qualified Demand
105 -- infixl so you can say (id `set` a `set` b)
106 infixl 1 `setSpecInfo`,
114 `setNewStrictnessInfo`,
115 `setAllStrictnessInfo`,
117 #ifdef OLD_STRICTNESS
120 , `setStrictnessInfo`
124 %************************************************************************
126 \subsection{New strictness info}
128 %************************************************************************
133 -- setAllStrictnessInfo :: IdInfo -> Maybe StrictSig -> IdInfo
134 -- Set old and new strictness info
135 setAllStrictnessInfo info Nothing
136 = info { newStrictnessInfo = Nothing
137 #ifdef OLD_STRICTNESS
138 , strictnessInfo = NoStrictnessInfo
139 , cprInfo = NoCPRInfo
143 setAllStrictnessInfo info (Just sig)
144 = info { newStrictnessInfo = Just sig
145 #ifdef OLD_STRICTNESS
146 , strictnessInfo = oldStrictnessFromNew sig
147 , cprInfo = cprInfoFromNewStrictness sig
151 seqNewStrictnessInfo Nothing = ()
152 seqNewStrictnessInfo (Just ty) = seqStrictSig ty
154 pprNewStrictness Nothing = empty
155 pprNewStrictness (Just sig) = ftext FSLIT("Str:") <+> ppr sig
157 #ifdef OLD_STRICTNESS
158 oldStrictnessFromNew :: StrictSig -> Demand.StrictnessInfo
159 oldStrictnessFromNew sig = mkStrictnessInfo (map oldDemand dmds, isBotRes res_info)
161 (dmds, res_info) = splitStrictSig sig
163 cprInfoFromNewStrictness :: StrictSig -> CprInfo
164 cprInfoFromNewStrictness sig = case strictSigResInfo sig of
168 newStrictnessFromOld :: Name -> Arity -> Demand.StrictnessInfo -> CprInfo -> StrictSig
169 newStrictnessFromOld name arity (Demand.StrictnessInfo ds res) cpr
170 | listLengthCmp ds arity /= GT -- length ds <= arity
171 -- Sometimes the old strictness analyser has more
172 -- demands than the arity justifies
173 = mk_strict_sig name arity $
174 mkTopDmdType (map newDemand ds) (newRes res cpr)
176 newStrictnessFromOld name arity other cpr
177 = -- Either no strictness info, or arity is too small
178 -- In either case we can't say anything useful
179 mk_strict_sig name arity $
180 mkTopDmdType (replicate arity lazyDmd) (newRes False cpr)
182 mk_strict_sig name arity dmd_ty
183 = WARN( arity /= dmdTypeDepth dmd_ty, ppr name <+> (ppr arity $$ ppr dmd_ty) )
186 newRes True _ = BotRes
187 newRes False ReturnsCPR = retCPR
188 newRes False NoCPRInfo = TopRes
190 newDemand :: Demand.Demand -> NewDemand.Demand
191 newDemand (WwLazy True) = Abs
192 newDemand (WwLazy False) = lazyDmd
193 newDemand WwStrict = evalDmd
194 newDemand (WwUnpack unpk ds) = Eval (Prod (map newDemand ds))
195 newDemand WwPrim = lazyDmd
196 newDemand WwEnum = evalDmd
198 oldDemand :: NewDemand.Demand -> Demand.Demand
199 oldDemand Abs = WwLazy True
200 oldDemand Top = WwLazy False
201 oldDemand Bot = WwStrict
202 oldDemand (Box Bot) = WwStrict
203 oldDemand (Box Abs) = WwLazy False
204 oldDemand (Box (Eval _)) = WwStrict -- Pass box only
205 oldDemand (Defer d) = WwLazy False
206 oldDemand (Eval (Prod ds)) = WwUnpack True (map oldDemand ds)
207 oldDemand (Eval (Poly _)) = WwStrict
208 oldDemand (Call _) = WwStrict
210 #endif /* OLD_STRICTNESS */
215 seqNewDemandInfo Nothing = ()
216 seqNewDemandInfo (Just dmd) = seqDemand dmd
220 %************************************************************************
222 \subsection{GlobalIdDetails}
224 %************************************************************************
226 This type is here (rather than in Id.lhs) mainly because there's
227 an IdInfo.hi-boot, but no Id.hi-boot, and GlobalIdDetails is imported
228 (recursively) by Var.lhs.
232 = VanillaGlobal -- Imported from elsewhere, a default method Id.
234 | RecordSelId -- The Id for a record selector
236 , sel_label :: FieldLabel
237 , sel_naughty :: Bool -- True <=> naughty
238 } -- See Note [Naughty record selectors]
239 -- with MkId.mkRecordSelectorId
241 | DataConWorkId DataCon -- The Id for a data constructor *worker*
242 | DataConWrapId DataCon -- The Id for a data constructor *wrapper*
243 -- [the only reasons we need to know is so that
244 -- a) to support isImplicitId
245 -- b) when desugaring a RecordCon we can get
246 -- from the Id back to the data con]
248 | ClassOpId Class -- An operation of a class
250 | PrimOpId PrimOp -- The Id for a primitive operator
251 | FCallId ForeignCall -- The Id for a foreign call
253 | TickBoxOpId TickBoxOp -- The Id for a tick box (both traditional and binary)
255 | NotGlobalId -- Used as a convenient extra return value from globalIdDetails
257 notGlobalId = NotGlobalId
259 instance Outputable GlobalIdDetails where
260 ppr NotGlobalId = ptext SLIT("[***NotGlobalId***]")
261 ppr VanillaGlobal = ptext SLIT("[GlobalId]")
262 ppr (DataConWorkId _) = ptext SLIT("[DataCon]")
263 ppr (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
264 ppr (ClassOpId _) = ptext SLIT("[ClassOp]")
265 ppr (PrimOpId _) = ptext SLIT("[PrimOp]")
266 ppr (FCallId _) = ptext SLIT("[ForeignCall]")
267 ppr (TickBoxOpId _) = ptext SLIT("[TickBoxOp]")
268 ppr (RecordSelId {}) = ptext SLIT("[RecSel]")
272 %************************************************************************
274 \subsection{The main IdInfo type}
276 %************************************************************************
278 An @IdInfo@ gives {\em optional} information about an @Id@. If
279 present it never lies, but it may not be present, in which case there
280 is always a conservative assumption which can be made.
282 Two @Id@s may have different info even though they have the same
283 @Unique@ (and are hence the same @Id@); for example, one might lack
284 the properties attached to the other.
286 The @IdInfo@ gives information about the value, or definition, of the
287 @Id@. It does {\em not} contain information about the @Id@'s usage
288 (except for @DemandInfo@? ToDo). (@lbvarInfo@ is also a marginal
294 arityInfo :: !ArityInfo, -- Its arity
295 specInfo :: SpecInfo, -- Specialisations of this function which exist
296 #ifdef OLD_STRICTNESS
297 cprInfo :: CprInfo, -- Function always constructs a product result
298 demandInfo :: Demand.Demand, -- Whether or not it is definitely demanded
299 strictnessInfo :: StrictnessInfo, -- Strictness properties
301 workerInfo :: WorkerInfo, -- Pointer to Worker Function
302 -- Within one module this is irrelevant; the
303 -- inlining of a worker is handled via the Unfolding
304 -- WorkerInfo is used *only* to indicate the form of
305 -- the RHS, so that interface files don't actually
306 -- need to contain the RHS; it can be derived from
307 -- the strictness info
309 unfoldingInfo :: Unfolding, -- Its unfolding
310 cafInfo :: CafInfo, -- CAF info
311 lbvarInfo :: LBVarInfo, -- Info about a lambda-bound variable
312 inlinePragInfo :: InlinePragInfo, -- Inline pragma
313 occInfo :: OccInfo, -- How it occurs
315 newStrictnessInfo :: Maybe StrictSig, -- Reason for Maybe: the DmdAnal phase needs to
316 -- know whether whether this is the first visit,
317 -- so it can assign botSig. Other customers want
318 -- topSig. So Nothing is good.
320 newDemandInfo :: Maybe Demand -- Similarly we want to know if there's no
321 -- known demand yet, for when we are looking for
325 seqIdInfo :: IdInfo -> ()
326 seqIdInfo (IdInfo {}) = ()
328 megaSeqIdInfo :: IdInfo -> ()
330 = seqSpecInfo (specInfo info) `seq`
331 seqWorker (workerInfo info) `seq`
333 -- Omitting this improves runtimes a little, presumably because
334 -- some unfoldings are not calculated at all
335 -- seqUnfolding (unfoldingInfo info) `seq`
337 seqNewDemandInfo (newDemandInfo info) `seq`
338 seqNewStrictnessInfo (newStrictnessInfo info) `seq`
340 #ifdef OLD_STRICTNESS
341 Demand.seqDemand (demandInfo info) `seq`
342 seqStrictnessInfo (strictnessInfo info) `seq`
343 seqCpr (cprInfo info) `seq`
346 seqCaf (cafInfo info) `seq`
347 seqLBVar (lbvarInfo info) `seq`
348 seqOccInfo (occInfo info)
354 setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
355 setSpecInfo info sp = sp `seq` info { specInfo = sp }
356 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
357 setOccInfo info oc = oc `seq` info { occInfo = oc }
358 #ifdef OLD_STRICTNESS
359 setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
361 -- Try to avoid spack leaks by seq'ing
363 setUnfoldingInfoLazily info uf -- Lazy variant to avoid looking at the
364 = -- unfolding of an imported Id unless necessary
365 info { unfoldingInfo = uf } -- (In this case the demand-zapping is redundant.)
367 setUnfoldingInfo info uf
368 -- We do *not* seq on the unfolding info, For some reason, doing so
369 -- actually increases residency significantly.
370 = info { unfoldingInfo = uf }
372 #ifdef OLD_STRICTNESS
373 setDemandInfo info dd = info { demandInfo = dd }
374 setCprInfo info cp = info { cprInfo = cp }
377 setArityInfo info ar = info { arityInfo = ar }
378 setCafInfo info caf = info { cafInfo = caf }
380 setLBVarInfo info lb = {-lb `seq`-} info { lbvarInfo = lb }
382 setNewDemandInfo info dd = dd `seq` info { newDemandInfo = dd }
383 setNewStrictnessInfo info dd = dd `seq` info { newStrictnessInfo = dd }
388 vanillaIdInfo :: IdInfo
391 cafInfo = vanillaCafInfo,
392 arityInfo = unknownArity,
393 #ifdef OLD_STRICTNESS
396 strictnessInfo = NoStrictnessInfo,
398 specInfo = emptySpecInfo,
399 workerInfo = NoWorker,
400 unfoldingInfo = noUnfolding,
401 lbvarInfo = NoLBVarInfo,
402 inlinePragInfo = AlwaysActive,
404 newDemandInfo = Nothing,
405 newStrictnessInfo = Nothing
408 noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
409 -- Used for built-in type Ids in MkId.
413 %************************************************************************
415 \subsection[arity-IdInfo]{Arity info about an @Id@}
417 %************************************************************************
419 For locally-defined Ids, the code generator maintains its own notion
420 of their arities; so it should not be asking... (but other things
421 besides the code-generator need arity info!)
424 type ArityInfo = Arity
425 -- A partial application of this Id to up to n-1 value arguments
426 -- does essentially no work. That is not necessarily the
427 -- same as saying that it has n leading lambdas, because coerces
428 -- may get in the way.
430 -- The arity might increase later in the compilation process, if
431 -- an extra lambda floats up to the binding site.
433 unknownArity = 0 :: Arity
435 ppArityInfo 0 = empty
436 ppArityInfo n = hsep [ptext SLIT("Arity"), int n]
439 %************************************************************************
441 \subsection{Inline-pragma information}
443 %************************************************************************
446 type InlinePragInfo = Activation
447 -- Tells when the inlining is active
448 -- When it is active the thing may be inlined, depending on how
451 -- If there was an INLINE pragma, then as a separate matter, the
452 -- RHS will have been made to look small with a CoreSyn Inline Note
454 -- The default InlinePragInfo is AlwaysActive, so the info serves
455 -- entirely as a way to inhibit inlining until we want it
459 %************************************************************************
463 %************************************************************************
466 -- CoreRules is used only in an idSpecialisation (move to IdInfo?)
468 = SpecInfo [CoreRule] VarSet -- Locally-defined free vars of RHSs
470 emptySpecInfo :: SpecInfo
471 emptySpecInfo = SpecInfo [] emptyVarSet
473 isEmptySpecInfo :: SpecInfo -> Bool
474 isEmptySpecInfo (SpecInfo rs _) = null rs
476 specInfoFreeVars :: SpecInfo -> VarSet
477 specInfoFreeVars (SpecInfo _ fvs) = fvs
479 specInfoRules :: SpecInfo -> [CoreRule]
480 specInfoRules (SpecInfo rules _) = rules
482 seqSpecInfo (SpecInfo rules fvs) = seqRules rules `seq` seqVarSet fvs
486 %************************************************************************
488 \subsection[worker-IdInfo]{Worker info about an @Id@}
490 %************************************************************************
492 If this Id has a worker then we store a reference to it. Worker
493 functions are generated by the worker/wrapper pass. This uses
494 information from strictness analysis.
496 There might not be a worker, even for a strict function, because:
497 (a) the function might be small enough to inline, so no need
499 (b) the strictness info might be "SSS" or something, so no w/w split.
501 Sometimes the arity of a wrapper changes from the original arity from
502 which it was generated, so we always emit the "original" arity into
503 the interface file, as part of the worker info.
505 How can this happen? Sometimes we get
506 f = coerce t (\x y -> $wf x y)
507 at the moment of w/w split; but the eta reducer turns it into
509 which is perfectly fine except that the exposed arity so far as
510 the code generator is concerned (zero) differs from the arity
511 when we did the split (2).
513 All this arises because we use 'arity' to mean "exactly how many
514 top level lambdas are there" in interface files; but during the
515 compilation of this module it means "how many things can I apply
520 data WorkerInfo = NoWorker
522 -- The Arity is the arity of the *wrapper* at the moment of the
523 -- w/w split. See notes above.
525 seqWorker :: WorkerInfo -> ()
526 seqWorker (HasWorker id a) = id `seq` a `seq` ()
527 seqWorker NoWorker = ()
529 ppWorkerInfo NoWorker = empty
530 ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("Worker") <+> ppr wk_id
532 workerExists :: WorkerInfo -> Bool
533 workerExists NoWorker = False
534 workerExists (HasWorker _ _) = True
536 workerId :: WorkerInfo -> Id
537 workerId (HasWorker id _) = id
539 wrapperArity :: WorkerInfo -> Arity
540 wrapperArity (HasWorker _ a) = a
544 %************************************************************************
546 \subsection[CG-IdInfo]{Code generator-related information}
548 %************************************************************************
551 -- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
554 = MayHaveCafRefs -- either:
555 -- (1) A function or static constructor
556 -- that refers to one or more CAFs,
557 -- (2) A real live CAF
559 | NoCafRefs -- A function or static constructor
560 -- that refers to no CAFs.
562 vanillaCafInfo = MayHaveCafRefs -- Definitely safe
564 mayHaveCafRefs MayHaveCafRefs = True
565 mayHaveCafRefs _ = False
567 seqCaf c = c `seq` ()
569 ppCafInfo NoCafRefs = ptext SLIT("NoCafRefs")
570 ppCafInfo MayHaveCafRefs = empty
573 %************************************************************************
575 \subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
577 %************************************************************************
579 If the @Id@ is a function then it may have CPR info. A CPR analysis
580 phase detects whether:
584 The function's return value has a product type, i.e. an algebraic type
585 with a single constructor. Examples of such types are tuples and boxed
588 The function always 'constructs' the value that it is returning. It
589 must do this on every path through, and it's OK if it calls another
590 function which constructs the result.
593 If this is the case then we store a template which tells us the
594 function has the CPR property and which components of the result are
598 #ifdef OLD_STRICTNESS
601 | ReturnsCPR -- Yes, this function returns a constructed product
602 -- Implicitly, this means "after the function has been applied
603 -- to all its arguments", so the worker/wrapper builder in
604 -- WwLib.mkWWcpr checks that that it is indeed saturated before
605 -- making use of the CPR info
607 -- We used to keep nested info about sub-components, but
608 -- we never used it so I threw it away
610 seqCpr :: CprInfo -> ()
611 seqCpr ReturnsCPR = ()
612 seqCpr NoCPRInfo = ()
614 noCprInfo = NoCPRInfo
616 ppCprInfo NoCPRInfo = empty
617 ppCprInfo ReturnsCPR = ptext SLIT("__M")
619 instance Outputable CprInfo where
622 instance Show CprInfo where
623 showsPrec p c = showsPrecSDoc p (ppr c)
628 %************************************************************************
630 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
632 %************************************************************************
634 If the @Id@ is a lambda-bound variable then it may have lambda-bound
635 var info. Sometimes we know whether the lambda binding this var is a
636 ``one-shot'' lambda; that is, whether it is applied at most once.
638 This information may be useful in optimisation, as computations may
639 safely be floated inside such a lambda without risk of duplicating
643 data LBVarInfo = NoLBVarInfo
644 | IsOneShotLambda -- The lambda is applied at most once).
646 seqLBVar l = l `seq` ()
650 hasNoLBVarInfo NoLBVarInfo = True
651 hasNoLBVarInfo IsOneShotLambda = False
653 noLBVarInfo = NoLBVarInfo
655 pprLBVarInfo NoLBVarInfo = empty
656 pprLBVarInfo IsOneShotLambda = ptext SLIT("OneShot")
658 instance Outputable LBVarInfo where
661 instance Show LBVarInfo where
662 showsPrec p c = showsPrecSDoc p (ppr c)
666 %************************************************************************
668 \subsection{Bulk operations on IdInfo}
670 %************************************************************************
672 @zapLamInfo@ is used for lambda binders that turn out to to be
673 part of an unsaturated lambda
676 zapLamInfo :: IdInfo -> Maybe IdInfo
677 zapLamInfo info@(IdInfo {occInfo = occ, newDemandInfo = demand})
678 | is_safe_occ occ && is_safe_dmd demand
681 = Just (info {occInfo = safe_occ, newDemandInfo = Nothing})
683 -- The "unsafe" occ info is the ones that say I'm not in a lambda
684 -- because that might not be true for an unsaturated lambda
685 is_safe_occ (OneOcc in_lam _ _) = in_lam
686 is_safe_occ other = True
688 safe_occ = case occ of
689 OneOcc _ once int_cxt -> OneOcc insideLam once int_cxt
692 is_safe_dmd Nothing = True
693 is_safe_dmd (Just dmd) = not (isStrictDmd dmd)
697 zapDemandInfo :: IdInfo -> Maybe IdInfo
698 zapDemandInfo info@(IdInfo {newDemandInfo = dmd})
699 | isJust dmd = Just (info {newDemandInfo = Nothing})
700 | otherwise = Nothing
704 zapFragileInfo :: IdInfo -> Maybe IdInfo
705 -- Zap info that depends on free variables
706 zapFragileInfo info = Just (info `setSpecInfo` emptySpecInfo
707 `setWorkerInfo` NoWorker
708 `setUnfoldingInfo` NoUnfolding)
711 %************************************************************************
713 \subsection{TickBoxOp}
715 %************************************************************************
721 = TickBox Module !TickBoxId -- ^Tick box for Hpc-style coverage,
722 -- type = State# Void#
724 instance Outputable TickBoxOp where
725 ppr (TickBox mod n) = ptext SLIT("tick") <+> ppr (mod,n)