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
11 GlobalIdDetails(..), notGlobalId, -- Not abstract
14 vanillaIdInfo, noCafIdInfo,
15 seqIdInfo, megaSeqIdInfo,
18 zapLamInfo, zapDemandInfo,
19 shortableIdInfo, copyIdInfo,
24 arityInfo, setArityInfo, ppArityInfo,
26 -- New demand and strictness info
27 newStrictnessInfo, setNewStrictnessInfo,
28 newDemandInfo, setNewDemandInfo, pprNewStrictness,
30 -- Strictness; imported from Demand
32 mkStrictnessInfo, noStrictnessInfo,
33 ppStrictnessInfo,isBottomingStrictness,
37 WorkerInfo(..), workerExists, wrapperArity, workerId,
38 workerInfo, setWorkerInfo, ppWorkerInfo,
41 unfoldingInfo, setUnfoldingInfo, setUnfoldingInfoLazily,
44 -- Old DemandInfo and StrictnessInfo
45 demandInfo, setDemandInfo,
46 strictnessInfo, setStrictnessInfo,
47 cprInfoFromNewStrictness,
48 oldStrictnessFromNew, newStrictnessFromOld,
51 -- Constructed Product Result Info
52 CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
57 inlinePragInfo, setInlinePragInfo,
60 OccInfo(..), isFragileOcc, isDeadOcc, isLoopBreaker,
61 InsideLam, OneBranch, insideLam, notInsideLam, oneBranch, notOneBranch,
65 specInfo, setSpecInfo,
68 CafInfo(..), cafInfo, ppCafInfo, setCafInfo, mayHaveCafRefs,
70 -- Lambda-bound variable info
71 LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
74 #include "HsVersions.h"
78 import TyCon ( TyCon )
79 import Class ( Class )
80 import PrimOp ( PrimOp )
85 import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
86 InsideLam, insideLam, notInsideLam,
87 OneBranch, oneBranch, notOneBranch,
91 import DataCon ( DataCon )
92 import ForeignCall ( ForeignCall )
93 import FieldLabel ( FieldLabel )
94 import Demand hiding( Demand, seqDemand )
95 import qualified Demand
98 import Maybe ( isJust )
100 import Util ( listLengthCmp )
101 import List ( replicate )
104 -- infixl so you can say (id `set` a `set` b)
105 infixl 1 `setSpecInfo`,
113 `setNewStrictnessInfo`,
114 `setAllStrictnessInfo`,
116 #ifdef OLD_STRICTNESS
119 , `setStrictnessInfo`
123 %************************************************************************
125 \subsection{New strictness info}
127 %************************************************************************
132 -- setAllStrictnessInfo :: IdInfo -> Maybe StrictSig -> IdInfo
133 -- Set old and new strictness info
134 setAllStrictnessInfo info Nothing
135 = info { newStrictnessInfo = Nothing
136 #ifdef OLD_STRICTNESS
137 , strictnessInfo = NoStrictnessInfo
138 , cprInfo = NoCPRInfo
142 setAllStrictnessInfo info (Just sig)
143 = info { newStrictnessInfo = Just sig
144 #ifdef OLD_STRICTNESS
145 , strictnessInfo = oldStrictnessFromNew sig
146 , cprInfo = cprInfoFromNewStrictness sig
150 seqNewStrictnessInfo Nothing = ()
151 seqNewStrictnessInfo (Just ty) = seqStrictSig ty
153 pprNewStrictness Nothing = empty
154 pprNewStrictness (Just sig) = ftext FSLIT("Str:") <+> ppr sig
156 #ifdef OLD_STRICTNESS
157 oldStrictnessFromNew :: StrictSig -> Demand.StrictnessInfo
158 oldStrictnessFromNew sig = mkStrictnessInfo (map oldDemand dmds, isBotRes res_info)
160 (dmds, res_info) = splitStrictSig sig
162 cprInfoFromNewStrictness :: StrictSig -> CprInfo
163 cprInfoFromNewStrictness sig = case strictSigResInfo sig of
167 newStrictnessFromOld :: Name -> Arity -> Demand.StrictnessInfo -> CprInfo -> StrictSig
168 newStrictnessFromOld name arity (Demand.StrictnessInfo ds res) cpr
169 | listLengthCmp ds arity /= GT -- length ds <= arity
170 -- Sometimes the old strictness analyser has more
171 -- demands than the arity justifies
172 = mk_strict_sig name arity $
173 mkTopDmdType (map newDemand ds) (newRes res cpr)
175 newStrictnessFromOld name arity other cpr
176 = -- Either no strictness info, or arity is too small
177 -- In either case we can't say anything useful
178 mk_strict_sig name arity $
179 mkTopDmdType (replicate arity lazyDmd) (newRes False cpr)
181 mk_strict_sig name arity dmd_ty
182 = WARN( arity /= dmdTypeDepth dmd_ty, ppr name <+> (ppr arity $$ ppr dmd_ty) )
185 newRes True _ = BotRes
186 newRes False ReturnsCPR = retCPR
187 newRes False NoCPRInfo = TopRes
189 newDemand :: Demand.Demand -> NewDemand.Demand
190 newDemand (WwLazy True) = Abs
191 newDemand (WwLazy False) = lazyDmd
192 newDemand WwStrict = evalDmd
193 newDemand (WwUnpack unpk ds) = Eval (Prod (map newDemand ds))
194 newDemand WwPrim = lazyDmd
195 newDemand WwEnum = evalDmd
197 oldDemand :: NewDemand.Demand -> Demand.Demand
198 oldDemand Abs = WwLazy True
199 oldDemand Top = WwLazy False
200 oldDemand Bot = WwStrict
201 oldDemand (Box Bot) = WwStrict
202 oldDemand (Box Abs) = WwLazy False
203 oldDemand (Box (Eval _)) = WwStrict -- Pass box only
204 oldDemand (Defer d) = WwLazy False
205 oldDemand (Eval (Prod ds)) = WwUnpack True (map oldDemand ds)
206 oldDemand (Eval (Poly _)) = WwStrict
207 oldDemand (Call _) = WwStrict
209 #endif /* OLD_STRICTNESS */
214 seqNewDemandInfo Nothing = ()
215 seqNewDemandInfo (Just dmd) = seqDemand dmd
219 %************************************************************************
221 \subsection{GlobalIdDetails
223 %************************************************************************
225 This type is here (rather than in Id.lhs) mainly because there's
226 an IdInfo.hi-boot, but no Id.hi-boot, and GlobalIdDetails is imported
227 (recursively) by Var.lhs.
231 = VanillaGlobal -- Imported from elsewhere, a default method Id.
233 | GenericOpId TyCon -- The to/from operations of a
234 | RecordSelId FieldLabel -- The Id for a record selector
235 | DataConWorkId DataCon -- The Id for a data constructor *worker*
236 | DataConWrapId DataCon -- The Id for a data constructor *wrapper*
237 -- [the only reasons we need to know is so that
238 -- a) we can suppress printing a definition in the interface file
239 -- b) when typechecking a pattern we can get from the
240 -- Id back to the data con]
242 | ClassOpId Class -- An operation of a class
244 | PrimOpId PrimOp -- The Id for a primitive operator
245 | FCallId ForeignCall -- The Id for a foreign call
247 | NotGlobalId -- Used as a convenient extra return value from globalIdDetails
249 notGlobalId = NotGlobalId
251 instance Outputable GlobalIdDetails where
252 ppr NotGlobalId = ptext SLIT("[***NotGlobalId***]")
253 ppr VanillaGlobal = ptext SLIT("[GlobalId]")
254 ppr (GenericOpId _) = ptext SLIT("[GenericOp]")
255 ppr (DataConWorkId _) = ptext SLIT("[DataCon]")
256 ppr (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
257 ppr (ClassOpId _) = ptext SLIT("[ClassOp]")
258 ppr (PrimOpId _) = ptext SLIT("[PrimOp]")
259 ppr (FCallId _) = ptext SLIT("[ForeignCall]")
260 ppr (RecordSelId _) = ptext SLIT("[RecSel]")
264 %************************************************************************
266 \subsection{The main IdInfo type}
268 %************************************************************************
270 An @IdInfo@ gives {\em optional} information about an @Id@. If
271 present it never lies, but it may not be present, in which case there
272 is always a conservative assumption which can be made.
274 Two @Id@s may have different info even though they have the same
275 @Unique@ (and are hence the same @Id@); for example, one might lack
276 the properties attached to the other.
278 The @IdInfo@ gives information about the value, or definition, of the
279 @Id@. It does {\em not} contain information about the @Id@'s usage
280 (except for @DemandInfo@? ToDo). (@lbvarInfo@ is also a marginal
286 arityInfo :: !ArityInfo, -- Its arity
287 specInfo :: CoreRules, -- Specialisations of this function which exist
288 #ifdef OLD_STRICTNESS
289 cprInfo :: CprInfo, -- Function always constructs a product result
290 demandInfo :: Demand.Demand, -- Whether or not it is definitely demanded
291 strictnessInfo :: StrictnessInfo, -- Strictness properties
293 workerInfo :: WorkerInfo, -- Pointer to Worker Function
294 unfoldingInfo :: Unfolding, -- Its unfolding
295 cafInfo :: CafInfo, -- CAF info
296 lbvarInfo :: LBVarInfo, -- Info about a lambda-bound variable
297 inlinePragInfo :: InlinePragInfo, -- Inline pragma
298 occInfo :: OccInfo, -- How it occurs
300 newStrictnessInfo :: Maybe StrictSig, -- Reason for Maybe: the DmdAnal phase needs to
301 -- know whether whether this is the first visit,
302 -- so it can assign botSig. Other customers want
303 -- topSig. So Nothing is good.
305 newDemandInfo :: Maybe Demand -- Similarly we want to know if there's no
306 -- known demand yet, for when we are looking for
310 seqIdInfo :: IdInfo -> ()
311 seqIdInfo (IdInfo {}) = ()
313 megaSeqIdInfo :: IdInfo -> ()
315 = seqRules (specInfo info) `seq`
316 seqWorker (workerInfo info) `seq`
318 -- Omitting this improves runtimes a little, presumably because
319 -- some unfoldings are not calculated at all
320 -- seqUnfolding (unfoldingInfo info) `seq`
322 seqNewDemandInfo (newDemandInfo info) `seq`
323 seqNewStrictnessInfo (newStrictnessInfo info) `seq`
325 #ifdef OLD_STRICTNESS
326 Demand.seqDemand (demandInfo info) `seq`
327 seqStrictnessInfo (strictnessInfo info) `seq`
328 seqCpr (cprInfo info) `seq`
331 seqCaf (cafInfo info) `seq`
332 seqLBVar (lbvarInfo info) `seq`
333 seqOccInfo (occInfo info)
339 setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
340 setSpecInfo info sp = sp `seq` info { specInfo = sp }
341 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
342 setOccInfo info oc = oc `seq` info { occInfo = oc }
343 #ifdef OLD_STRICTNESS
344 setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
346 -- Try to avoid spack leaks by seq'ing
348 setUnfoldingInfoLazily info uf -- Lazy variant to avoid looking at the
349 = -- unfolding of an imported Id unless necessary
350 info { unfoldingInfo = uf } -- (In this case the demand-zapping is redundant.)
352 setUnfoldingInfo info uf
353 | isEvaldUnfolding uf
354 -- If the unfolding is a value, the demand info may
355 -- go pear-shaped, so we nuke it. Example:
357 -- case x of (p,q) -> h p q x
358 -- Here x is certainly demanded. But after we've nuked
359 -- the case, we'll get just
360 -- let x = (a,b) in h a b x
361 -- and now x is not demanded (I'm assuming h is lazy)
362 -- This really happens. The solution here is a bit ad hoc...
363 = info { unfoldingInfo = uf, newDemandInfo = Nothing }
366 -- We do *not* seq on the unfolding info, For some reason, doing so
367 -- actually increases residency significantly.
368 = info { unfoldingInfo = uf }
370 #ifdef OLD_STRICTNESS
371 setDemandInfo info dd = info { demandInfo = dd }
372 setCprInfo info cp = info { cprInfo = cp }
375 setArityInfo info ar = info { arityInfo = ar }
376 setCafInfo info caf = info { cafInfo = caf }
378 setLBVarInfo info lb = {-lb `seq`-} info { lbvarInfo = lb }
380 setNewDemandInfo info dd = dd `seq` info { newDemandInfo = dd }
381 setNewStrictnessInfo info dd = dd `seq` info { newStrictnessInfo = dd }
386 vanillaIdInfo :: IdInfo
389 cafInfo = vanillaCafInfo,
390 arityInfo = unknownArity,
391 #ifdef OLD_STRICTNESS
394 strictnessInfo = NoStrictnessInfo,
396 specInfo = emptyCoreRules,
397 workerInfo = NoWorker,
398 unfoldingInfo = noUnfolding,
399 lbvarInfo = NoLBVarInfo,
400 inlinePragInfo = AlwaysActive,
402 newDemandInfo = Nothing,
403 newStrictnessInfo = Nothing
406 noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
407 -- Used for built-in type Ids in MkId.
411 %************************************************************************
413 \subsection[arity-IdInfo]{Arity info about an @Id@}
415 %************************************************************************
417 For locally-defined Ids, the code generator maintains its own notion
418 of their arities; so it should not be asking... (but other things
419 besides the code-generator need arity info!)
422 type ArityInfo = Arity
423 -- A partial application of this Id to up to n-1 value arguments
424 -- does essentially no work. That is not necessarily the
425 -- same as saying that it has n leading lambdas, because coerces
426 -- may get in the way.
428 -- The arity might increase later in the compilation process, if
429 -- an extra lambda floats up to the binding site.
431 unknownArity = 0 :: Arity
433 ppArityInfo 0 = empty
434 ppArityInfo n = hsep [ptext SLIT("Arity"), int n]
437 %************************************************************************
439 \subsection{Inline-pragma information}
441 %************************************************************************
444 type InlinePragInfo = Activation
445 -- Tells when the inlining is active
446 -- When it is active the thing may be inlined, depending on how
449 -- If there was an INLINE pragma, then as a separate matter, the
450 -- RHS will have been made to look small with a CoreSyn Inline Note
454 %************************************************************************
456 \subsection[worker-IdInfo]{Worker info about an @Id@}
458 %************************************************************************
460 If this Id has a worker then we store a reference to it. Worker
461 functions are generated by the worker/wrapper pass. This uses
462 information from strictness analysis.
464 There might not be a worker, even for a strict function, because:
465 (a) the function might be small enough to inline, so no need
467 (b) the strictness info might be "SSS" or something, so no w/w split.
469 Sometimes the arity of a wrapper changes from the original arity from
470 which it was generated, so we always emit the "original" arity into
471 the interface file, as part of the worker info.
473 How can this happen? Sometimes we get
474 f = coerce t (\x y -> $wf x y)
475 at the moment of w/w split; but the eta reducer turns it into
477 which is perfectly fine except that the exposed arity so far as
478 the code generator is concerned (zero) differs from the arity
479 when we did the split (2).
481 All this arises because we use 'arity' to mean "exactly how many
482 top level lambdas are there" in interface files; but during the
483 compilation of this module it means "how many things can I apply
488 data WorkerInfo = NoWorker
490 -- The Arity is the arity of the *wrapper* at the moment of the
491 -- w/w split. See comments in MkIface.ifaceId, with the 'Worker' code.
493 seqWorker :: WorkerInfo -> ()
494 seqWorker (HasWorker id a) = id `seq` a `seq` ()
495 seqWorker NoWorker = ()
497 ppWorkerInfo NoWorker = empty
498 ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("__P") <+> ppr wk_id
500 workerExists :: WorkerInfo -> Bool
501 workerExists NoWorker = False
502 workerExists (HasWorker _ _) = True
504 workerId :: WorkerInfo -> Id
505 workerId (HasWorker id _) = id
507 wrapperArity :: WorkerInfo -> Arity
508 wrapperArity (HasWorker _ a) = a
512 %************************************************************************
514 \subsection[CG-IdInfo]{Code generator-related information}
516 %************************************************************************
519 -- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
522 = MayHaveCafRefs -- either:
523 -- (1) A function or static constructor
524 -- that refers to one or more CAFs,
525 -- (2) A real live CAF
527 | NoCafRefs -- A function or static constructor
528 -- that refers to no CAFs.
530 vanillaCafInfo = MayHaveCafRefs -- Definitely safe
532 mayHaveCafRefs MayHaveCafRefs = True
533 mayHaveCafRefs _ = False
535 seqCaf c = c `seq` ()
537 ppCafInfo NoCafRefs = ptext SLIT("NoCafRefs")
538 ppCafInfo MayHaveCafRefs = empty
541 %************************************************************************
543 \subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
545 %************************************************************************
547 If the @Id@ is a function then it may have CPR info. A CPR analysis
548 phase detects whether:
552 The function's return value has a product type, i.e. an algebraic type
553 with a single constructor. Examples of such types are tuples and boxed
556 The function always 'constructs' the value that it is returning. It
557 must do this on every path through, and it's OK if it calls another
558 function which constructs the result.
561 If this is the case then we store a template which tells us the
562 function has the CPR property and which components of the result are
566 #ifdef OLD_STRICTNESS
569 | ReturnsCPR -- Yes, this function returns a constructed product
570 -- Implicitly, this means "after the function has been applied
571 -- to all its arguments", so the worker/wrapper builder in
572 -- WwLib.mkWWcpr checks that that it is indeed saturated before
573 -- making use of the CPR info
575 -- We used to keep nested info about sub-components, but
576 -- we never used it so I threw it away
578 seqCpr :: CprInfo -> ()
579 seqCpr ReturnsCPR = ()
580 seqCpr NoCPRInfo = ()
582 noCprInfo = NoCPRInfo
584 ppCprInfo NoCPRInfo = empty
585 ppCprInfo ReturnsCPR = ptext SLIT("__M")
587 instance Outputable CprInfo where
590 instance Show CprInfo where
591 showsPrec p c = showsPrecSDoc p (ppr c)
596 %************************************************************************
598 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
600 %************************************************************************
602 If the @Id@ is a lambda-bound variable then it may have lambda-bound
603 var info. Sometimes we know whether the lambda binding this var is a
604 ``one-shot'' lambda; that is, whether it is applied at most once.
606 This information may be useful in optimisation, as computations may
607 safely be floated inside such a lambda without risk of duplicating
611 data LBVarInfo = NoLBVarInfo
612 | IsOneShotLambda -- The lambda is applied at most once).
614 seqLBVar l = l `seq` ()
618 hasNoLBVarInfo NoLBVarInfo = True
619 hasNoLBVarInfo IsOneShotLambda = False
621 noLBVarInfo = NoLBVarInfo
623 pprLBVarInfo NoLBVarInfo = empty
624 pprLBVarInfo IsOneShotLambda = ptext SLIT("OneShot")
626 instance Outputable LBVarInfo where
629 instance Show LBVarInfo where
630 showsPrec p c = showsPrecSDoc p (ppr c)
634 %************************************************************************
636 \subsection{Bulk operations on IdInfo}
638 %************************************************************************
640 @zapLamInfo@ is used for lambda binders that turn out to to be
641 part of an unsaturated lambda
644 zapLamInfo :: IdInfo -> Maybe IdInfo
645 zapLamInfo info@(IdInfo {occInfo = occ, newDemandInfo = demand})
646 | is_safe_occ occ && is_safe_dmd demand
649 = Just (info {occInfo = safe_occ, newDemandInfo = Nothing})
651 -- The "unsafe" occ info is the ones that say I'm not in a lambda
652 -- because that might not be true for an unsaturated lambda
653 is_safe_occ (OneOcc in_lam once) = in_lam
654 is_safe_occ other = True
656 safe_occ = case occ of
657 OneOcc _ once -> OneOcc insideLam once
660 is_safe_dmd Nothing = True
661 is_safe_dmd (Just dmd) = not (isStrictDmd dmd)
665 zapDemandInfo :: IdInfo -> Maybe IdInfo
666 zapDemandInfo info@(IdInfo {newDemandInfo = dmd})
667 | isJust dmd = Just (info {newDemandInfo = Nothing})
668 | otherwise = Nothing
672 copyIdInfo is used when shorting out a top-level binding
675 where f is exported. We are going to swizzle it around to
679 BUT (a) we must be careful about messing up rules
680 (b) we must ensure f's IdInfo ends up right
682 (a) Messing up the rules
684 The example that went bad on me was this one:
686 iterate :: (a -> a) -> a -> [a]
687 iterate = iterateList
689 iterateFB c f x = x `c` iterateFB c f (f x)
690 iterateList f x = x : iterateList f (f x)
693 "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
694 "iterateFB" iterateFB (:) = iterateList
697 This got shorted out to:
699 iterateList :: (a -> a) -> a -> [a]
700 iterateList = iterate
702 iterateFB c f x = x `c` iterateFB c f (f x)
703 iterate f x = x : iterate f (f x)
706 "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
707 "iterateFB" iterateFB (:) = iterate
710 And now we get an infinite loop in the rule system
711 iterate f x -> build (\cn -> iterateFB c f x)
715 Tiresome solution: don't do shorting out if f has rewrite rules.
716 Hence shortableIdInfo.
718 (b) Keeping the IdInfo right
719 ~~~~~~~~~~~~~~~~~~~~~~~~
720 We want to move strictness/worker info from f_local to f, but keep the rest.
724 shortableIdInfo :: IdInfo -> Bool
725 shortableIdInfo info = isEmptyCoreRules (specInfo info)
727 copyIdInfo :: IdInfo -- f_local
728 -> IdInfo -- f (the exported one)
729 -> IdInfo -- New info for f
730 copyIdInfo f_local f = f { newStrictnessInfo = newStrictnessInfo f_local,
731 #ifdef OLD_STRICTNESS
732 strictnessInfo = strictnessInfo f_local,
733 cprInfo = cprInfo f_local,
735 workerInfo = workerInfo f_local