2 % (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
4 \section[IdInfo]{@IdInfos@: Non-essential information about @Ids@}
6 (And a pretty good illustration of quite a few things wrong with
13 vanillaIdInfo, mkIdInfo, seqIdInfo, megaSeqIdInfo,
16 IdFlavour(..), flavourInfo,
17 setNoDiscardInfo, zapSpecPragInfo, copyIdInfo,
22 exactArity, atLeastArity, unknownArity, hasArity,
23 arityInfo, setArityInfo, ppArityInfo, arityLowerBound,
26 StrictnessInfo(..), -- Non-abstract
28 noStrictnessInfo, strictnessInfo,
29 ppStrictnessInfo, setStrictnessInfo,
30 isBottomingStrictness, appIsBottom,
33 WorkerInfo, workerExists,
34 workerInfo, setWorkerInfo, ppWorkerInfo,
37 unfoldingInfo, setUnfoldingInfo,
40 demandInfo, setDemandInfo,
43 InlinePragInfo(..), OccInfo(..),
44 inlinePragInfo, setInlinePragInfo, notInsideLambda,
47 specInfo, setSpecInfo,
50 UpdateInfo, UpdateSpec,
51 mkUpdateInfo, updateInfo, updateInfoMaybe, ppUpdateInfo, setUpdateInfo,
54 CafInfo(..), cafInfo, setCafInfo, ppCafInfo,
56 -- Constructed Product Result Info
57 CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
60 zapLamIdInfo, zapFragileIdInfo, zapIdInfoForStg,
62 -- Lambda-bound variable info
63 LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo
66 #include "HsVersions.h"
69 import {-# SOURCE #-} CoreUnfold ( Unfolding, noUnfolding, hasUnfolding, seqUnfolding )
70 import {-# SOURCE #-} CoreSyn ( CoreExpr, CoreRules, emptyCoreRules, isEmptyCoreRules, seqRules )
71 import {-# SOURCE #-} Const ( Con )
74 import FieldLabel ( FieldLabel )
75 import Demand ( Demand, isStrict, isLazy, wwLazy, pprDemands, seqDemand, seqDemands )
76 import Type ( UsageAnn )
78 import Maybe ( isJust )
80 infixl 1 `setUpdateInfo`,
90 -- infixl so you can say (id `set` a `set` b)
93 An @IdInfo@ gives {\em optional} information about an @Id@. If
94 present it never lies, but it may not be present, in which case there
95 is always a conservative assumption which can be made.
97 There is one exception: the 'flavour' is *not* optional.
98 You must not discard it.
99 It used to be in Var.lhs, but that seems unclean.
101 Two @Id@s may have different info even though they have the same
102 @Unique@ (and are hence the same @Id@); for example, one might lack
103 the properties attached to the other.
105 The @IdInfo@ gives information about the value, or definition, of the
106 @Id@. It does {\em not} contain information about the @Id@'s usage
107 (except for @DemandInfo@? ToDo). (@lbvarInfo@ is also a marginal
113 flavourInfo :: IdFlavour, -- NOT OPTIONAL
114 arityInfo :: ArityInfo, -- Its arity
115 demandInfo :: Demand, -- Whether or not it is definitely demanded
116 specInfo :: CoreRules, -- Specialisations of this function which exist
117 strictnessInfo :: StrictnessInfo, -- Strictness properties
118 workerInfo :: WorkerInfo, -- Pointer to Worker Function
119 unfoldingInfo :: Unfolding, -- Its unfolding
120 updateInfo :: UpdateInfo, -- Which args should be updated
122 cprInfo :: CprInfo, -- Function always constructs a product result
123 lbvarInfo :: LBVarInfo, -- Info about a lambda-bound variable
124 inlinePragInfo :: InlinePragInfo -- Inline pragmas
127 seqIdInfo :: IdInfo -> ()
128 seqIdInfo (IdInfo {}) = ()
130 megaSeqIdInfo :: IdInfo -> ()
132 = seqFlavour (flavourInfo info) `seq`
133 seqArity (arityInfo info) `seq`
134 seqDemand (demandInfo info) `seq`
135 seqRules (specInfo info) `seq`
136 seqStrictness (strictnessInfo info) `seq`
137 seqWorker (workerInfo info) `seq`
139 -- seqUnfolding (unfoldingInfo info) `seq`
140 -- Omitting this improves runtimes a little, presumably because
141 -- some unfoldings are not calculated at all
143 seqCaf (cafInfo info) `seq`
144 seqCpr (cprInfo info) `seq`
145 seqLBVar (lbvarInfo info) `seq`
146 seqInlinePrag (inlinePragInfo info)
152 setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
153 setSpecInfo info sp = PSEQ sp (info { specInfo = sp })
154 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
155 setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
156 -- Try to avoid spack leaks by seq'ing
158 setUnfoldingInfo info uf = info { unfoldingInfo = uf }
159 -- We do *not* seq on the unfolding info, For some reason, doing so
160 -- actually increases residency significantly.
162 setUpdateInfo info ud = info { updateInfo = ud }
163 setDemandInfo info dd = info { demandInfo = dd }
164 setArityInfo info ar = info { arityInfo = ar }
165 setCafInfo info cf = info { cafInfo = cf }
166 setCprInfo info cp = info { cprInfo = cp }
167 setLBVarInfo info lb = info { lbvarInfo = lb }
169 setNoDiscardInfo info = case flavourInfo info of
170 VanillaId -> info { flavourInfo = NoDiscardId }
172 zapSpecPragInfo info = case flavourInfo info of
173 SpecPragmaId -> info { flavourInfo = VanillaId }
176 copyIdInfo :: IdInfo -- From
178 -> IdInfo -- To, updated with stuff from From; except flavour unchanged
179 -- copyIdInfo is used when shorting out a top-level binding
182 -- where f is exported. We are going to swizzle it around to
185 -- but we must be careful to combine their IdInfos right.
186 -- The fact that things can go wrong here is a bad sign, but I can't see
187 -- how to make it 'patently right', so copyIdInfo is derived (pretty much) by trial and error
189 -- Here 'from' is f_local, 'to' is f, and the result is attached to f
191 copyIdInfo from to = from { flavourInfo = flavourInfo to,
192 specInfo = specInfo to,
193 inlinePragInfo = inlinePragInfo to
195 -- It's important to preserve the inline pragma on 'f'; e.g. consider
196 -- {-# NOINLINE f #-}
199 -- similarly, transformation rules may be attached to f
200 -- and we want to preserve them.
202 -- On the other hand, we want the strictness info from f_local.
207 vanillaIdInfo :: IdInfo
208 vanillaIdInfo = mkIdInfo VanillaId
210 mkIdInfo :: IdFlavour -> IdInfo
211 mkIdInfo flv = IdInfo {
213 arityInfo = UnknownArity,
215 specInfo = emptyCoreRules,
216 workerInfo = Nothing,
217 strictnessInfo = NoStrictnessInfo,
218 unfoldingInfo = noUnfolding,
219 updateInfo = NoUpdateInfo,
220 cafInfo = MayHaveCafRefs,
222 lbvarInfo = NoLBVarInfo,
223 inlinePragInfo = NoInlinePragInfo
228 %************************************************************************
232 %************************************************************************
236 = VanillaId -- Most Ids are like this
237 | ConstantId Con -- The Id for a constant (data constructor or primop)
238 | RecordSelId FieldLabel -- The Id for a record selector
239 | SpecPragmaId -- Don't discard these
240 | NoDiscardId -- Don't discard these either
242 ppFlavourInfo :: IdFlavour -> SDoc
243 ppFlavourInfo VanillaId = empty
244 ppFlavourInfo (ConstantId _) = ptext SLIT("[Constr]")
245 ppFlavourInfo (RecordSelId _) = ptext SLIT("[RecSel]")
246 ppFlavourInfo SpecPragmaId = ptext SLIT("[SpecPrag]")
247 ppFlavourInfo NoDiscardId = ptext SLIT("[NoDiscard]")
249 seqFlavour :: IdFlavour -> ()
250 seqFlavour f = f `seq` ()
253 The @SpecPragmaId@ exists only to make Ids that are
254 on the *LHS* of bindings created by SPECIALISE pragmas;
256 The SpecPragmaId is never itself mentioned; it
257 exists solely so that the specialiser will find
258 the call to f, and make specialised version of it.
259 The SpecPragmaId binding is discarded by the specialiser
260 when it gathers up overloaded calls.
261 Meanwhile, it is not discarded as dead code.
264 %************************************************************************
266 \subsection[arity-IdInfo]{Arity info about an @Id@}
268 %************************************************************************
270 For locally-defined Ids, the code generator maintains its own notion
271 of their arities; so it should not be asking... (but other things
272 besides the code-generator need arity info!)
276 = UnknownArity -- No idea
278 | ArityExactly Int -- Arity is exactly this. We use this when importing a
279 -- function; it's already been compiled and we know its
282 | ArityAtLeast Int -- Arity is this or greater. We attach this arity to
283 -- functions in the module being compiled. Their arity
284 -- might increase later in the compilation process, if
285 -- an extra lambda floats up to the binding site.
287 seqArity :: ArityInfo -> ()
288 seqArity a = arityLowerBound a `seq` ()
290 exactArity = ArityExactly
291 atLeastArity = ArityAtLeast
292 unknownArity = UnknownArity
294 arityLowerBound :: ArityInfo -> Int
295 arityLowerBound UnknownArity = 0
296 arityLowerBound (ArityAtLeast n) = n
297 arityLowerBound (ArityExactly n) = n
299 hasArity :: ArityInfo -> Bool
300 hasArity UnknownArity = False
301 hasArity other = True
303 ppArityInfo UnknownArity = empty
304 ppArityInfo (ArityExactly arity) = hsep [ptext SLIT("__A"), int arity]
305 ppArityInfo (ArityAtLeast arity) = hsep [ptext SLIT("__AL"), int arity]
308 %************************************************************************
310 \subsection{Inline-pragma information}
312 %************************************************************************
318 | IMustNotBeINLINEd -- User NOINLINE pragma
320 | IAmALoopBreaker -- Used by the occurrence analyser to mark loop-breakers
321 -- in a group of recursive definitions
323 | ICanSafelyBeINLINEd -- Used by the occurrence analyser to mark things
324 -- that manifesly occur once, not inside SCCs,
325 -- not in constructor arguments
327 OccInfo -- Says whether the occurrence is inside a lambda
328 -- If so, must only substitute WHNFs
330 Bool -- False <=> occurs in more than one case branch
331 -- If so, there's a code-duplication issue
333 | IAmDead -- Marks unused variables. Sometimes useful for
334 -- lambda and case-bound variables.
336 | IMustBeINLINEd -- Absolutely must inline; used for PrimOps and
337 -- constructors only.
339 seqInlinePrag :: InlinePragInfo -> ()
340 seqInlinePrag (ICanSafelyBeINLINEd occ alts)
341 = occ `seq` alts `seq` ()
345 instance Outputable InlinePragInfo where
346 -- only used for debugging; never parsed. KSW 1999-07
347 ppr NoInlinePragInfo = empty
348 ppr IMustBeINLINEd = ptext SLIT("__UU")
349 ppr IMustNotBeINLINEd = ptext SLIT("__Unot")
350 ppr IAmALoopBreaker = ptext SLIT("__Ux")
351 ppr IAmDead = ptext SLIT("__Ud")
352 ppr (ICanSafelyBeINLINEd InsideLam _) = ptext SLIT("__Ul")
353 ppr (ICanSafelyBeINLINEd NotInsideLam True) = ptext SLIT("__Us")
354 ppr (ICanSafelyBeINLINEd NotInsideLam False) = ptext SLIT("__Us*")
356 instance Show InlinePragInfo where
357 showsPrec p prag = showsPrecSDoc p (ppr prag)
364 | InsideLam -- Inside a non-linear lambda (that is, a lambda which
365 -- is sure to be instantiated only once).
366 -- Substituting a redex for this occurrence is
367 -- dangerous because it might duplicate work.
369 instance Outputable OccInfo where
370 ppr NotInsideLam = empty
371 ppr InsideLam = text "l"
374 notInsideLambda :: OccInfo -> Bool
375 notInsideLambda NotInsideLam = True
376 notInsideLambda InsideLam = False
379 %************************************************************************
381 \subsection[strictness-IdInfo]{Strictness info about an @Id@}
383 %************************************************************************
385 We specify the strictness of a function by giving information about
386 each of the ``wrapper's'' arguments (see the description about
387 worker/wrapper-style transformations in the PJ/Launchbury paper on
390 The list of @Demands@ specifies: (a)~the strictness properties of a
391 function's arguments; and (b)~the type signature of that worker (if it
392 exists); i.e. its calling convention.
394 Note that the existence of a worker function is now denoted by the Id's
401 | StrictnessInfo [Demand]
402 Bool -- True <=> the function diverges regardless of its arguments
403 -- Useful for "error" and other disguised variants thereof.
404 -- BUT NB: f = \x y. error "urk"
405 -- will have info SI [SS] True
406 -- but still (f) and (f 2) are not bot; only (f 3 2) is bot
408 seqStrictness :: StrictnessInfo -> ()
409 seqStrictness (StrictnessInfo ds b) = b `seq` seqDemands ds
410 seqStrictness other = ()
414 mkStrictnessInfo :: ([Demand], Bool) -> StrictnessInfo
416 mkStrictnessInfo (xs, is_bot)
417 | all isLazy xs && not is_bot = NoStrictnessInfo -- Uninteresting
418 | otherwise = StrictnessInfo xs is_bot
420 noStrictnessInfo = NoStrictnessInfo
422 isBottomingStrictness (StrictnessInfo _ bot) = bot
423 isBottomingStrictness NoStrictnessInfo = False
425 -- appIsBottom returns true if an application to n args would diverge
426 appIsBottom (StrictnessInfo ds bot) n = bot && (n >= length ds)
427 appIsBottom NoStrictnessInfo n = False
429 ppStrictnessInfo NoStrictnessInfo = empty
430 ppStrictnessInfo (StrictnessInfo wrapper_args bot)
431 = hsep [ptext SLIT("__S"), pprDemands wrapper_args bot]
434 %************************************************************************
436 \subsection[worker-IdInfo]{Worker info about an @Id@}
438 %************************************************************************
440 If this Id has a worker then we store a reference to it. Worker
441 functions are generated by the worker/wrapper pass. This uses
442 information from the strictness and CPR analyses.
444 There might not be a worker, even for a strict function, because:
445 (a) the function might be small enough to inline, so no need
447 (b) the strictness info might be "SSS" or something, so no w/w split.
451 type WorkerInfo = Maybe Id
454 mkWorkerInfo :: Id -> WorkerInfo
455 mkWorkerInfo wk_id = Just wk_id
458 seqWorker :: WorkerInfo -> ()
459 seqWorker (Just id) = id `seq` ()
460 seqWorker Nothing = ()
462 ppWorkerInfo Nothing = empty
463 ppWorkerInfo (Just wk_id) = ptext SLIT("__P") <+> ppr wk_id
465 noWorkerInfo = Nothing
467 workerExists :: WorkerInfo -> Bool
468 workerExists = isJust
472 %************************************************************************
474 \subsection[update-IdInfo]{Update-analysis info about an @Id@}
476 %************************************************************************
481 | SomeUpdateInfo UpdateSpec
483 -- we need Eq/Ord to cross-chk update infos in interfaces
485 -- the form in which we pass update-analysis info between modules:
486 type UpdateSpec = [Int]
490 mkUpdateInfo = SomeUpdateInfo
492 updateInfoMaybe NoUpdateInfo = Nothing
493 updateInfoMaybe (SomeUpdateInfo []) = Nothing
494 updateInfoMaybe (SomeUpdateInfo u) = Just u
497 Text instance so that the update annotations can be read in.
500 ppUpdateInfo NoUpdateInfo = empty
501 ppUpdateInfo (SomeUpdateInfo []) = empty
502 ppUpdateInfo (SomeUpdateInfo spec) = (<>) (ptext SLIT("__UA ")) (hcat (map int spec))
503 -- was "__U "; changed to avoid conflict with unfoldings. KSW 1999-07.
506 %************************************************************************
508 \subsection[CAF-IdInfo]{CAF-related information}
510 %************************************************************************
512 This information is used to build Static Reference Tables (see
513 simplStg/ComputeSRT.lhs).
517 = MayHaveCafRefs -- either:
518 -- (1) A function or static constructor
519 -- that refers to one or more CAFs,
520 -- (2) A real live CAF
522 | NoCafRefs -- A function or static constructor
523 -- that refers to no CAFs.
525 -- LATER: not sure how easy this is...
529 seqCaf c = c `seq` ()
531 ppCafInfo NoCafRefs = ptext SLIT("__C")
532 ppCafInfo MayHaveCafRefs = empty
536 %************************************************************************
538 \subsection[CAF-IdInfo]{CAF-related information}
540 %************************************************************************
542 zapFragileIdInfo is used when cloning binders, mainly in the
543 simplifier. We must forget about used-once information because that
544 isn't necessarily correct in the transformed program.
545 Also forget specialisations and unfoldings because they would need
546 substitution to be correct. (They get pinned back on separately.)
549 zapFragileIdInfo :: IdInfo -> Maybe IdInfo
550 zapFragileIdInfo info@(IdInfo {inlinePragInfo = inline_prag,
553 unfoldingInfo = unfolding})
554 | not is_fragile_inline_prag
555 -- We must forget about whether it was marked safe-to-inline,
556 -- because that isn't necessarily true in the simplified expression.
557 -- This is important because expressions may be re-simplified
559 && isEmptyCoreRules rules
560 -- Specialisations would need substituting. They get pinned
561 -- back on separately.
563 && not (workerExists wrkr)
565 && not (hasUnfolding unfolding)
566 -- This is very important; occasionally a let-bound binder is used
567 -- as a binder in some lambda, in which case its unfolding is utterly
568 -- bogus. Also the unfolding uses old binders so if we left it we'd
569 -- have to substitute it. Much better simply to give the Id a new
570 -- unfolding each time, which is what the simplifier does.
574 = Just (info {inlinePragInfo = safe_inline_prag,
575 workerInfo = noWorkerInfo,
576 specInfo = emptyCoreRules,
577 unfoldingInfo = noUnfolding})
580 is_fragile_inline_prag = case inline_prag of
581 ICanSafelyBeINLINEd _ _ -> True
583 -- We used to say the dead-ness was fragile, but I don't
584 -- see why it is. Furthermore, deadness is a pain to lose;
585 -- see Simplify.mkDupableCont (Select ...)
590 -- Be careful not to destroy real 'pragma' info
591 safe_inline_prag | is_fragile_inline_prag = NoInlinePragInfo
592 | otherwise = inline_prag
596 @zapLamIdInfo@ is used for lambda binders that turn out to to be
597 part of an unsaturated lambda
600 zapLamIdInfo :: IdInfo -> Maybe IdInfo
601 zapLamIdInfo info@(IdInfo {inlinePragInfo = inline_prag, demandInfo = demand})
602 | is_safe_inline_prag && not (isStrict demand)
605 = Just (info {inlinePragInfo = safe_inline_prag,
606 demandInfo = wwLazy})
608 -- The "unsafe" prags are the ones that say I'm not in a lambda
609 -- because that might not be true for an unsaturated lambda
610 is_safe_inline_prag = case inline_prag of
611 ICanSafelyBeINLINEd NotInsideLam nalts -> False
614 safe_inline_prag = case inline_prag of
615 ICanSafelyBeINLINEd _ nalts
616 -> ICanSafelyBeINLINEd InsideLam nalts
621 zapIdInfoForStg :: IdInfo -> IdInfo
622 -- Return only the info needed for STG stuff
623 -- Namely, nothing, I think
624 zapIdInfoForStg info = vanillaIdInfo
628 %************************************************************************
630 \subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
632 %************************************************************************
634 If the @Id@ is a function then it may have CPR info. A CPR analysis
635 phase detects whether:
639 The function's return value has a product type, i.e. an algebraic type
640 with a single constructor. Examples of such types are tuples and boxed
643 The function always 'constructs' the value that it is returning. It
644 must do this on every path through, and it's OK if it calls another
645 function which constructs the result.
648 If this is the case then we store a template which tells us the
649 function has the CPR property and which components of the result are
658 -- e.g. const 5 == CPRInfo [NoCPRInfo]
665 -- CPRInfo [CPRInfo [NoCPRInfo],
666 -- CPRInfo [NoCprInfo,
667 -- CPRInfo [NoCPRInfo],
674 seqCpr :: CprInfo -> ()
675 seqCpr (CPRInfo cs) = seqCprs cs
676 seqCpr NoCPRInfo = ()
679 seqCprs (c:cs) = seqCpr c `seq` seqCprs cs
682 noCprInfo = NoCPRInfo
684 ppCprInfo NoCPRInfo = empty
685 ppCprInfo c@(CPRInfo _)
686 = hsep [ptext SLIT("__M"), ppCprInfo' c]
688 ppCprInfo' NoCPRInfo = char '-'
689 ppCprInfo' (CPRInfo args) = parens (hcat (map ppCprInfo' args))
691 instance Outputable CprInfo where
694 instance Show CprInfo where
695 showsPrec p c = showsPrecSDoc p (ppr c)
699 %************************************************************************
701 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
703 %************************************************************************
705 If the @Id@ is a lambda-bound variable then it may have lambda-bound
706 var info. The usage analysis (UsageSP) detects whether the lambda
707 binding this var is a ``one-shot'' lambda; that is, whether it is
708 applied at most once.
710 This information may be useful in optimisation, as computations may
711 safely be floated inside such a lambda without risk of duplicating
718 | IsOneShotLambda -- The lambda that binds this Id is applied
720 -- HACK ALERT! placing this info here is a short-term hack,
721 -- but it minimises changes to the rest of the compiler.
722 -- Hack agreed by SLPJ/KSW 1999-04.
724 seqLBVar l = l `seq` ()
728 noLBVarInfo = NoLBVarInfo
730 -- not safe to print or parse LBVarInfo because it is not really a
731 -- property of the definition, but a property of the context.
732 pprLBVarInfo NoLBVarInfo = empty
733 pprLBVarInfo IsOneShotLambda = getPprStyle $ \ sty ->
734 if ifaceStyle sty then empty
735 else ptext SLIT("OneShot")
737 instance Outputable LBVarInfo where
740 instance Show LBVarInfo where
741 showsPrec p c = showsPrecSDoc p (ppr c)