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,
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, setSpecInfo,
70 CafInfo(..), cafInfo, ppCafInfo, setCafInfo, mayHaveCafRefs,
72 -- Lambda-bound variable info
73 LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
76 #include "HsVersions.h"
80 import TyCon ( TyCon )
81 import Class ( Class )
82 import PrimOp ( PrimOp )
84 import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
85 InsideLam, insideLam, notInsideLam,
86 OneBranch, oneBranch, notOneBranch,
90 import DataCon ( DataCon )
91 import ForeignCall ( ForeignCall )
92 import FieldLabel ( FieldLabel )
95 import Maybe ( isJust )
99 import Demand hiding( Demand, seqDemand )
100 import qualified Demand
101 import Util ( listLengthCmp )
102 import List ( replicate )
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 | GenericOpId TyCon -- The to/from operations of a
235 | RecordSelId FieldLabel -- The Id for a record selector
236 | DataConWorkId DataCon -- The Id for a data constructor *worker*
237 | DataConWrapId DataCon -- The Id for a data constructor *wrapper*
238 -- [the only reasons we need to know is so that
239 -- a) we can suppress printing a definition in the interface file
240 -- b) when typechecking a pattern we can get from the
241 -- Id back to the data con]
243 | ClassOpId Class -- An operation of a class
245 | PrimOpId PrimOp -- The Id for a primitive operator
246 | FCallId ForeignCall -- The Id for a foreign call
248 | NotGlobalId -- Used as a convenient extra return value from globalIdDetails
250 notGlobalId = NotGlobalId
252 instance Outputable GlobalIdDetails where
253 ppr NotGlobalId = ptext SLIT("[***NotGlobalId***]")
254 ppr VanillaGlobal = ptext SLIT("[GlobalId]")
255 ppr (GenericOpId _) = ptext SLIT("[GenericOp]")
256 ppr (DataConWorkId _) = ptext SLIT("[DataCon]")
257 ppr (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
258 ppr (ClassOpId _) = ptext SLIT("[ClassOp]")
259 ppr (PrimOpId _) = ptext SLIT("[PrimOp]")
260 ppr (FCallId _) = ptext SLIT("[ForeignCall]")
261 ppr (RecordSelId _) = ptext SLIT("[RecSel]")
265 %************************************************************************
267 \subsection{The main IdInfo type}
269 %************************************************************************
271 An @IdInfo@ gives {\em optional} information about an @Id@. If
272 present it never lies, but it may not be present, in which case there
273 is always a conservative assumption which can be made.
275 Two @Id@s may have different info even though they have the same
276 @Unique@ (and are hence the same @Id@); for example, one might lack
277 the properties attached to the other.
279 The @IdInfo@ gives information about the value, or definition, of the
280 @Id@. It does {\em not} contain information about the @Id@'s usage
281 (except for @DemandInfo@? ToDo). (@lbvarInfo@ is also a marginal
287 arityInfo :: !ArityInfo, -- Its arity
288 specInfo :: CoreRules, -- Specialisations of this function which exist
289 #ifdef OLD_STRICTNESS
290 cprInfo :: CprInfo, -- Function always constructs a product result
291 demandInfo :: Demand.Demand, -- Whether or not it is definitely demanded
292 strictnessInfo :: StrictnessInfo, -- Strictness properties
294 workerInfo :: WorkerInfo, -- Pointer to Worker Function
295 unfoldingInfo :: Unfolding, -- Its unfolding
296 cafInfo :: CafInfo, -- CAF info
297 lbvarInfo :: LBVarInfo, -- Info about a lambda-bound variable
298 inlinePragInfo :: InlinePragInfo, -- Inline pragma
299 occInfo :: OccInfo, -- How it occurs
301 newStrictnessInfo :: Maybe StrictSig, -- Reason for Maybe: the DmdAnal phase needs to
302 -- know whether whether this is the first visit,
303 -- so it can assign botSig. Other customers want
304 -- topSig. So Nothing is good.
306 newDemandInfo :: Maybe Demand -- Similarly we want to know if there's no
307 -- known demand yet, for when we are looking for
311 seqIdInfo :: IdInfo -> ()
312 seqIdInfo (IdInfo {}) = ()
314 megaSeqIdInfo :: IdInfo -> ()
316 = seqRules (specInfo info) `seq`
317 seqWorker (workerInfo info) `seq`
319 -- Omitting this improves runtimes a little, presumably because
320 -- some unfoldings are not calculated at all
321 -- seqUnfolding (unfoldingInfo info) `seq`
323 seqNewDemandInfo (newDemandInfo info) `seq`
324 seqNewStrictnessInfo (newStrictnessInfo info) `seq`
326 #ifdef OLD_STRICTNESS
327 Demand.seqDemand (demandInfo info) `seq`
328 seqStrictnessInfo (strictnessInfo info) `seq`
329 seqCpr (cprInfo info) `seq`
332 seqCaf (cafInfo info) `seq`
333 seqLBVar (lbvarInfo info) `seq`
334 seqOccInfo (occInfo info)
340 setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
341 setSpecInfo info sp = sp `seq` info { specInfo = sp }
342 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
343 setOccInfo info oc = oc `seq` info { occInfo = oc }
344 #ifdef OLD_STRICTNESS
345 setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
347 -- Try to avoid spack leaks by seq'ing
349 setUnfoldingInfoLazily info uf -- Lazy variant to avoid looking at the
350 = -- unfolding of an imported Id unless necessary
351 info { unfoldingInfo = uf } -- (In this case the demand-zapping is redundant.)
353 setUnfoldingInfo info uf
354 | isEvaldUnfolding uf
355 -- If the unfolding is a value, the demand info may
356 -- go pear-shaped, so we nuke it. Example:
358 -- case x of (p,q) -> h p q x
359 -- Here x is certainly demanded. But after we've nuked
360 -- the case, we'll get just
361 -- let x = (a,b) in h a b x
362 -- and now x is not demanded (I'm assuming h is lazy)
363 -- This really happens. The solution here is a bit ad hoc...
364 = info { unfoldingInfo = uf, newDemandInfo = Nothing }
367 -- We do *not* seq on the unfolding info, For some reason, doing so
368 -- actually increases residency significantly.
369 = info { unfoldingInfo = uf }
371 #ifdef OLD_STRICTNESS
372 setDemandInfo info dd = info { demandInfo = dd }
373 setCprInfo info cp = info { cprInfo = cp }
376 setArityInfo info ar = info { arityInfo = ar }
377 setCafInfo info caf = info { cafInfo = caf }
379 setLBVarInfo info lb = {-lb `seq`-} info { lbvarInfo = lb }
381 setNewDemandInfo info dd = dd `seq` info { newDemandInfo = dd }
382 setNewStrictnessInfo info dd = dd `seq` info { newStrictnessInfo = dd }
387 vanillaIdInfo :: IdInfo
390 cafInfo = vanillaCafInfo,
391 arityInfo = unknownArity,
392 #ifdef OLD_STRICTNESS
395 strictnessInfo = NoStrictnessInfo,
397 specInfo = emptyCoreRules,
398 workerInfo = NoWorker,
399 unfoldingInfo = noUnfolding,
400 lbvarInfo = NoLBVarInfo,
401 inlinePragInfo = AlwaysActive,
403 newDemandInfo = Nothing,
404 newStrictnessInfo = Nothing
407 noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
408 -- Used for built-in type Ids in MkId.
412 %************************************************************************
414 \subsection[arity-IdInfo]{Arity info about an @Id@}
416 %************************************************************************
418 For locally-defined Ids, the code generator maintains its own notion
419 of their arities; so it should not be asking... (but other things
420 besides the code-generator need arity info!)
423 type ArityInfo = Arity
424 -- A partial application of this Id to up to n-1 value arguments
425 -- does essentially no work. That is not necessarily the
426 -- same as saying that it has n leading lambdas, because coerces
427 -- may get in the way.
429 -- The arity might increase later in the compilation process, if
430 -- an extra lambda floats up to the binding site.
432 unknownArity = 0 :: Arity
434 ppArityInfo 0 = empty
435 ppArityInfo n = hsep [ptext SLIT("Arity"), int n]
438 %************************************************************************
440 \subsection{Inline-pragma information}
442 %************************************************************************
445 type InlinePragInfo = Activation
446 -- Tells when the inlining is active
447 -- When it is active the thing may be inlined, depending on how
450 -- If there was an INLINE pragma, then as a separate matter, the
451 -- RHS will have been made to look small with a CoreSyn Inline Note
455 %************************************************************************
457 \subsection[worker-IdInfo]{Worker info about an @Id@}
459 %************************************************************************
461 If this Id has a worker then we store a reference to it. Worker
462 functions are generated by the worker/wrapper pass. This uses
463 information from strictness analysis.
465 There might not be a worker, even for a strict function, because:
466 (a) the function might be small enough to inline, so no need
468 (b) the strictness info might be "SSS" or something, so no w/w split.
470 Sometimes the arity of a wrapper changes from the original arity from
471 which it was generated, so we always emit the "original" arity into
472 the interface file, as part of the worker info.
474 How can this happen? Sometimes we get
475 f = coerce t (\x y -> $wf x y)
476 at the moment of w/w split; but the eta reducer turns it into
478 which is perfectly fine except that the exposed arity so far as
479 the code generator is concerned (zero) differs from the arity
480 when we did the split (2).
482 All this arises because we use 'arity' to mean "exactly how many
483 top level lambdas are there" in interface files; but during the
484 compilation of this module it means "how many things can I apply
489 data WorkerInfo = NoWorker
491 -- The Arity is the arity of the *wrapper* at the moment of the
492 -- w/w split. See comments in MkIface.ifaceId, with the 'Worker' code.
494 seqWorker :: WorkerInfo -> ()
495 seqWorker (HasWorker id a) = id `seq` a `seq` ()
496 seqWorker NoWorker = ()
498 ppWorkerInfo NoWorker = empty
499 ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("__P") <+> ppr wk_id
501 workerExists :: WorkerInfo -> Bool
502 workerExists NoWorker = False
503 workerExists (HasWorker _ _) = True
505 workerId :: WorkerInfo -> Id
506 workerId (HasWorker id _) = id
508 wrapperArity :: WorkerInfo -> Arity
509 wrapperArity (HasWorker _ a) = a
513 %************************************************************************
515 \subsection[CG-IdInfo]{Code generator-related information}
517 %************************************************************************
520 -- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
523 = MayHaveCafRefs -- either:
524 -- (1) A function or static constructor
525 -- that refers to one or more CAFs,
526 -- (2) A real live CAF
528 | NoCafRefs -- A function or static constructor
529 -- that refers to no CAFs.
531 vanillaCafInfo = MayHaveCafRefs -- Definitely safe
533 mayHaveCafRefs MayHaveCafRefs = True
534 mayHaveCafRefs _ = False
536 seqCaf c = c `seq` ()
538 ppCafInfo NoCafRefs = ptext SLIT("NoCafRefs")
539 ppCafInfo MayHaveCafRefs = empty
542 %************************************************************************
544 \subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
546 %************************************************************************
548 If the @Id@ is a function then it may have CPR info. A CPR analysis
549 phase detects whether:
553 The function's return value has a product type, i.e. an algebraic type
554 with a single constructor. Examples of such types are tuples and boxed
557 The function always 'constructs' the value that it is returning. It
558 must do this on every path through, and it's OK if it calls another
559 function which constructs the result.
562 If this is the case then we store a template which tells us the
563 function has the CPR property and which components of the result are
567 #ifdef OLD_STRICTNESS
570 | ReturnsCPR -- Yes, this function returns a constructed product
571 -- Implicitly, this means "after the function has been applied
572 -- to all its arguments", so the worker/wrapper builder in
573 -- WwLib.mkWWcpr checks that that it is indeed saturated before
574 -- making use of the CPR info
576 -- We used to keep nested info about sub-components, but
577 -- we never used it so I threw it away
579 seqCpr :: CprInfo -> ()
580 seqCpr ReturnsCPR = ()
581 seqCpr NoCPRInfo = ()
583 noCprInfo = NoCPRInfo
585 ppCprInfo NoCPRInfo = empty
586 ppCprInfo ReturnsCPR = ptext SLIT("__M")
588 instance Outputable CprInfo where
591 instance Show CprInfo where
592 showsPrec p c = showsPrecSDoc p (ppr c)
597 %************************************************************************
599 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
601 %************************************************************************
603 If the @Id@ is a lambda-bound variable then it may have lambda-bound
604 var info. Sometimes we know whether the lambda binding this var is a
605 ``one-shot'' lambda; that is, whether it is applied at most once.
607 This information may be useful in optimisation, as computations may
608 safely be floated inside such a lambda without risk of duplicating
612 data LBVarInfo = NoLBVarInfo
613 | IsOneShotLambda -- The lambda is applied at most once).
615 seqLBVar l = l `seq` ()
619 hasNoLBVarInfo NoLBVarInfo = True
620 hasNoLBVarInfo IsOneShotLambda = False
622 noLBVarInfo = NoLBVarInfo
624 pprLBVarInfo NoLBVarInfo = empty
625 pprLBVarInfo IsOneShotLambda = ptext SLIT("OneShot")
627 instance Outputable LBVarInfo where
630 instance Show LBVarInfo where
631 showsPrec p c = showsPrecSDoc p (ppr c)
635 %************************************************************************
637 \subsection{Bulk operations on IdInfo}
639 %************************************************************************
641 @zapLamInfo@ is used for lambda binders that turn out to to be
642 part of an unsaturated lambda
645 zapLamInfo :: IdInfo -> Maybe IdInfo
646 zapLamInfo info@(IdInfo {occInfo = occ, newDemandInfo = demand})
647 | is_safe_occ occ && is_safe_dmd demand
650 = Just (info {occInfo = safe_occ, newDemandInfo = Nothing})
652 -- The "unsafe" occ info is the ones that say I'm not in a lambda
653 -- because that might not be true for an unsaturated lambda
654 is_safe_occ (OneOcc in_lam once) = in_lam
655 is_safe_occ other = True
657 safe_occ = case occ of
658 OneOcc _ once -> OneOcc insideLam once
661 is_safe_dmd Nothing = True
662 is_safe_dmd (Just dmd) = not (isStrictDmd dmd)
666 zapDemandInfo :: IdInfo -> Maybe IdInfo
667 zapDemandInfo info@(IdInfo {newDemandInfo = dmd})
668 | isJust dmd = Just (info {newDemandInfo = Nothing})
669 | otherwise = Nothing
673 copyIdInfo is used when shorting out a top-level binding
676 where f is exported. We are going to swizzle it around to
680 BUT (a) we must be careful about messing up rules
681 (b) we must ensure f's IdInfo ends up right
683 (a) Messing up the rules
685 The example that went bad on me was this one:
687 iterate :: (a -> a) -> a -> [a]
688 iterate = iterateList
690 iterateFB c f x = x `c` iterateFB c f (f x)
691 iterateList f x = x : iterateList f (f x)
694 "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
695 "iterateFB" iterateFB (:) = iterateList
698 This got shorted out to:
700 iterateList :: (a -> a) -> a -> [a]
701 iterateList = iterate
703 iterateFB c f x = x `c` iterateFB c f (f x)
704 iterate f x = x : iterate f (f x)
707 "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
708 "iterateFB" iterateFB (:) = iterate
711 And now we get an infinite loop in the rule system
712 iterate f x -> build (\cn -> iterateFB c f x)
716 Tiresome solution: don't do shorting out if f has rewrite rules.
717 Hence shortableIdInfo.
719 (b) Keeping the IdInfo right
720 ~~~~~~~~~~~~~~~~~~~~~~~~
721 We want to move strictness/worker info from f_local to f, but keep the rest.
725 shortableIdInfo :: IdInfo -> Bool
726 shortableIdInfo info = isEmptyCoreRules (specInfo info)
728 copyIdInfo :: IdInfo -- f_local
729 -> IdInfo -- f (the exported one)
730 -> IdInfo -- New info for f
731 copyIdInfo f_local f = f { newStrictnessInfo = newStrictnessInfo f_local,
732 #ifdef OLD_STRICTNESS
733 strictnessInfo = strictnessInfo f_local,
734 cprInfo = cprInfo f_local,
736 workerInfo = workerInfo f_local