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, noCafNoTyGenIdInfo,
15 seqIdInfo, megaSeqIdInfo,
18 zapLamInfo, zapDemandInfo,
19 shortableIdInfo, copyIdInfo,
23 exactArity, unknownArity, hasArity,
24 arityInfo, setArityInfo, ppArityInfo, arityLowerBound,
26 -- New demand and strictness info
27 newStrictnessInfo, setNewStrictnessInfo, mkNewStrictnessInfo,
28 newDemandInfo, setNewDemandInfo, newDemand, oldDemand,
30 -- Strictness; imported from Demand
32 mkStrictnessInfo, noStrictnessInfo,
33 ppStrictnessInfo,isBottomingStrictness,
34 strictnessInfo, setStrictnessInfo,
36 -- Usage generalisation
38 tyGenInfo, setTyGenInfo,
39 noTyGenInfo, isNoTyGenInfo, ppTyGenInfo, tyGenInfoString,
42 WorkerInfo(..), workerExists, wrapperArity, workerId,
43 workerInfo, setWorkerInfo, ppWorkerInfo,
46 unfoldingInfo, setUnfoldingInfo,
49 demandInfo, setDemandInfo,
53 inlinePragInfo, setInlinePragInfo, pprInlinePragInfo,
54 isNeverInlinePrag, neverInlinePrag,
57 OccInfo(..), isFragileOcc, isDeadOcc, isLoopBreaker,
58 InsideLam, OneBranch, insideLam, notInsideLam, oneBranch, notOneBranch,
62 specInfo, setSpecInfo,
65 CgInfo(..), cgInfo, setCgInfo, cgMayHaveCafRefs, pprCgInfo,
66 cgArity, cgCafInfo, vanillaCgInfo,
67 CgInfoEnv, lookupCgInfo,
71 CafInfo(..), ppCafInfo, setCafInfo, mayHaveCafRefs,
73 -- Constructed Product Result Info
74 CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
76 -- Lambda-bound variable info
77 LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
80 #include "HsVersions.h"
84 import Type ( Type, usOnce, eqUsage )
85 import PrimOp ( PrimOp )
86 import NameEnv ( NameEnv, lookupNameEnv )
89 import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
90 InsideLam, insideLam, notInsideLam,
91 OneBranch, oneBranch, notOneBranch,
94 import DataCon ( DataCon )
95 import ForeignCall ( ForeignCall )
96 import FieldLabel ( FieldLabel )
97 import Type ( usOnce, usMany )
98 import Demand hiding( Demand )
99 import qualified Demand
100 import NewDemand ( Demand(..), Keepity(..), Deferredness(..), DmdResult(..),
102 StrictSig, mkStrictSig, mkTopDmdType
105 import Util ( seqList )
106 import List ( replicate )
108 infixl 1 `setDemandInfo`,
122 `setNewStrictnessInfo`,
124 -- infixl so you can say (id `set` a `set` b)
127 %************************************************************************
129 \subsection{New strictness info}
131 %************************************************************************
136 mkNewStrictnessInfo :: Id -> Arity -> Demand.StrictnessInfo -> CprInfo -> StrictSig
137 mkNewStrictnessInfo id arity (Demand.StrictnessInfo ds res) cpr
139 -- Sometimes the old strictness analyser has more
140 -- demands than the arity justifies
141 = mkStrictSig id arity $
142 mkTopDmdType (map newDemand ds) (newRes res cpr)
144 mkNewStrictnessInfo id arity other cpr
145 = -- Either no strictness info, or arity is too small
146 -- In either case we can't say anything useful
147 mkStrictSig id arity $
148 mkTopDmdType (replicate arity lazyDmd) (newRes False cpr)
150 newRes True _ = BotRes
151 newRes False ReturnsCPR = RetCPR
152 newRes False NoCPRInfo = TopRes
154 newDemand :: Demand.Demand -> NewDemand.Demand
155 newDemand (WwLazy True) = Abs
156 newDemand (WwLazy False) = Lazy
157 newDemand WwStrict = Eval
158 newDemand (WwUnpack unpk ds) = Seq Drop Now (map newDemand ds)
159 newDemand WwPrim = Lazy
160 newDemand WwEnum = Eval
162 oldDemand :: NewDemand.Demand -> Demand.Demand
163 oldDemand Abs = WwLazy True
164 oldDemand Lazy = WwLazy False
165 oldDemand Bot = WwStrict
166 oldDemand Err = WwStrict
167 oldDemand Eval = WwStrict
168 oldDemand (Seq _ _ ds) = WwUnpack True (map oldDemand ds)
169 oldDemand (Call _) = WwStrict
173 %************************************************************************
175 \subsection{GlobalIdDetails
177 %************************************************************************
179 This type is here (rather than in Id.lhs) mainly because there's
180 an IdInfo.hi-boot, but no Id.hi-boot, and GlobalIdDetails is imported
181 (recursively) by Var.lhs.
185 = VanillaGlobal -- Imported from elsewhere, a default method Id.
187 | RecordSelId FieldLabel -- The Id for a record selector
188 | DataConId DataCon -- The Id for a data constructor *worker*
189 | DataConWrapId DataCon -- The Id for a data constructor *wrapper*
190 -- [the only reasons we need to know is so that
191 -- a) we can suppress printing a definition in the interface file
192 -- b) when typechecking a pattern we can get from the
193 -- Id back to the data con]
195 | PrimOpId PrimOp -- The Id for a primitive operator
196 | FCallId ForeignCall -- The Id for a foreign call
198 | NotGlobalId -- Used as a convenient extra return value from globalIdDetails
200 notGlobalId = NotGlobalId
202 instance Outputable GlobalIdDetails where
203 ppr NotGlobalId = ptext SLIT("[***NotGlobalId***]")
204 ppr VanillaGlobal = ptext SLIT("[GlobalId]")
205 ppr (DataConId _) = ptext SLIT("[DataCon]")
206 ppr (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
207 ppr (PrimOpId _) = ptext SLIT("[PrimOp]")
208 ppr (FCallId _) = ptext SLIT("[ForeignCall]")
209 ppr (RecordSelId _) = ptext SLIT("[RecSel]")
213 %************************************************************************
215 \subsection{The main IdInfo type}
217 %************************************************************************
219 An @IdInfo@ gives {\em optional} information about an @Id@. If
220 present it never lies, but it may not be present, in which case there
221 is always a conservative assumption which can be made.
223 Two @Id@s may have different info even though they have the same
224 @Unique@ (and are hence the same @Id@); for example, one might lack
225 the properties attached to the other.
227 The @IdInfo@ gives information about the value, or definition, of the
228 @Id@. It does {\em not} contain information about the @Id@'s usage
229 (except for @DemandInfo@? ToDo). (@lbvarInfo@ is also a marginal
235 arityInfo :: ArityInfo, -- Its arity
236 demandInfo :: Demand.Demand, -- Whether or not it is definitely demanded
237 specInfo :: CoreRules, -- Specialisations of this function which exist
238 tyGenInfo :: TyGenInfo, -- Restrictions on usage-generalisation of this Id
239 strictnessInfo :: StrictnessInfo, -- Strictness properties
240 workerInfo :: WorkerInfo, -- Pointer to Worker Function
241 unfoldingInfo :: Unfolding, -- Its unfolding
242 cgInfo :: CgInfo, -- Code generator info (arity, CAF info)
243 cprInfo :: CprInfo, -- Function always constructs a product result
244 lbvarInfo :: LBVarInfo, -- Info about a lambda-bound variable
245 inlinePragInfo :: InlinePragInfo, -- Inline pragma
246 occInfo :: OccInfo, -- How it occurs
248 newStrictnessInfo :: Maybe StrictSig,
249 newDemandInfo :: Demand
252 seqIdInfo :: IdInfo -> ()
253 seqIdInfo (IdInfo {}) = ()
255 megaSeqIdInfo :: IdInfo -> ()
257 = seqArity (arityInfo info) `seq`
258 seqDemand (demandInfo info) `seq`
259 seqRules (specInfo info) `seq`
260 seqTyGenInfo (tyGenInfo info) `seq`
261 seqStrictnessInfo (strictnessInfo info) `seq`
262 seqWorker (workerInfo info) `seq`
264 -- seqUnfolding (unfoldingInfo info) `seq`
265 -- Omitting this improves runtimes a little, presumably because
266 -- some unfoldings are not calculated at all
268 -- CgInfo is involved in a loop, so we have to be careful not to seq it
270 -- seqCg (cgInfo info) `seq`
271 seqCpr (cprInfo info) `seq`
272 seqLBVar (lbvarInfo info) `seq`
273 seqOccInfo (occInfo info)
279 setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
280 setSpecInfo info sp = PSEQ sp (info { specInfo = sp })
281 setTyGenInfo info tg = tg `seq` info { tyGenInfo = tg }
282 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
283 setOccInfo info oc = oc `seq` info { occInfo = oc }
284 setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
285 -- Try to avoid spack leaks by seq'ing
287 setUnfoldingInfo info uf
288 | isEvaldUnfolding uf && isStrict (demandInfo info)
289 -- If the unfolding is a value, the demand info may
290 -- go pear-shaped, so we nuke it. Example:
292 -- case x of (p,q) -> h p q x
293 -- Here x is certainly demanded. But after we've nuked
294 -- the case, we'll get just
295 -- let x = (a,b) in h a b x
296 -- and now x is not demanded (I'm assuming h is lazy)
297 -- This really happens. The solution here is a bit ad hoc...
298 = info { unfoldingInfo = uf, demandInfo = wwLazy }
301 -- We do *not* seq on the unfolding info, For some reason, doing so
302 -- actually increases residency significantly.
303 = info { unfoldingInfo = uf }
305 setDemandInfo info dd = info { demandInfo = dd }
306 setArityInfo info ar = info { arityInfo = Just ar }
307 setCgInfo info cg = info { cgInfo = cg }
308 setCprInfo info cp = info { cprInfo = cp }
309 setLBVarInfo info lb = info { lbvarInfo = lb }
311 setNewDemandInfo info dd = info { newDemandInfo = dd }
312 setNewStrictnessInfo info dd = info { newStrictnessInfo = dd }
317 vanillaIdInfo :: IdInfo
321 arityInfo = unknownArity,
323 specInfo = emptyCoreRules,
324 tyGenInfo = noTyGenInfo,
325 workerInfo = NoWorker,
326 strictnessInfo = NoStrictnessInfo,
327 unfoldingInfo = noUnfolding,
329 lbvarInfo = NoLBVarInfo,
330 inlinePragInfo = NoInlinePragInfo,
332 newDemandInfo = topDmd,
333 newStrictnessInfo = Nothing
336 noCafNoTyGenIdInfo = vanillaIdInfo `setTyGenInfo` TyGenNever
337 `setCgInfo` (CgInfo 0 NoCafRefs)
338 -- Used for built-in type Ids in MkId.
339 -- Many built-in things have fixed types, so we shouldn't
340 -- run around generalising them
344 %************************************************************************
346 \subsection[arity-IdInfo]{Arity info about an @Id@}
348 %************************************************************************
350 For locally-defined Ids, the code generator maintains its own notion
351 of their arities; so it should not be asking... (but other things
352 besides the code-generator need arity info!)
355 type ArityInfo = Maybe Arity
356 -- A partial application of this Id to up to n-1 value arguments
357 -- does essentially no work. That is not necessarily the
358 -- same as saying that it has n leading lambdas, because coerces
359 -- may get in the way.
361 -- The arity might increase later in the compilation process, if
362 -- an extra lambda floats up to the binding site.
364 seqArity :: ArityInfo -> ()
365 seqArity a = arityLowerBound a `seq` ()
368 unknownArity = Nothing
370 arityLowerBound :: ArityInfo -> Arity
371 arityLowerBound Nothing = 0
372 arityLowerBound (Just n) = n
374 hasArity :: ArityInfo -> Bool
375 hasArity Nothing = False
376 hasArity other = True
378 ppArityInfo Nothing = empty
379 ppArityInfo (Just arity) = hsep [ptext SLIT("Arity"), int arity]
382 %************************************************************************
384 \subsection{Inline-pragma information}
386 %************************************************************************
391 | IMustNotBeINLINEd Bool -- True <=> came from an INLINE prag, False <=> came from a NOINLINE prag
392 (Maybe Int) -- Phase number from pragma, if any
394 -- The True, Nothing case doesn't need to be recorded
396 -- SEE COMMENTS WITH CoreUnfold.blackListed on the
397 -- exact significance of the IMustNotBeINLINEd pragma
399 isNeverInlinePrag :: InlinePragInfo -> Bool
400 isNeverInlinePrag (IMustNotBeINLINEd _ Nothing) = True
401 isNeverInlinePrag other = False
403 neverInlinePrag :: InlinePragInfo
404 neverInlinePrag = IMustNotBeINLINEd True{-should be False? --SDM -} Nothing
406 instance Outputable InlinePragInfo where
407 -- This is now parsed in interface files
408 ppr NoInlinePragInfo = empty
409 ppr other_prag = ptext SLIT("__U") <> pprInlinePragInfo other_prag
411 pprInlinePragInfo NoInlinePragInfo = empty
412 pprInlinePragInfo (IMustNotBeINLINEd True Nothing) = empty
413 pprInlinePragInfo (IMustNotBeINLINEd True (Just n)) = brackets (int n)
414 pprInlinePragInfo (IMustNotBeINLINEd False Nothing) = brackets (char '!')
415 pprInlinePragInfo (IMustNotBeINLINEd False (Just n)) = brackets (char '!' <> int n)
417 instance Show InlinePragInfo where
418 showsPrec p prag = showsPrecSDoc p (ppr prag)
422 %************************************************************************
424 \subsection[TyGen-IdInfo]{Type generalisation info about an @Id@}
426 %************************************************************************
428 Certain passes (notably usage inference) may change the type of an
429 identifier, modifying all in-scope uses of that identifier
430 appropriately to maintain type safety.
432 However, some identifiers must not have their types changed in this
433 way, because their types are conjured up in the front end of the
434 compiler rather than being read from the interface file. Default
435 methods, dictionary functions, record selectors, and others are in
436 this category. (see comment at TcClassDcl.tcClassSig).
438 To indicate this property, such identifiers are marked TyGenNever.
440 Furthermore, if the usage inference generates a usage-specialised
441 variant of a function, we must NOT re-infer a fully-generalised type
442 at the next inference. This finer property is indicated by a
443 TyGenUInfo on the identifier.
447 = NoTyGenInfo -- no restriction on type generalisation
449 | TyGenUInfo [Maybe Type] -- restrict generalisation of this Id to
450 -- preserve specified usage annotations
452 | TyGenNever -- never generalise the type of this Id
455 For TyGenUInfo, the list has one entry for each usage annotation on
456 the type of the Id, in left-to-right pre-order (annotations come
457 before the type they annotate). Nothing means no restriction; Just
458 usOnce or Just usMany forces that annotation to that value. Other
459 usage annotations are illegal.
462 seqTyGenInfo :: TyGenInfo -> ()
463 seqTyGenInfo NoTyGenInfo = ()
464 seqTyGenInfo (TyGenUInfo us) = seqList us ()
465 seqTyGenInfo TyGenNever = ()
467 noTyGenInfo :: TyGenInfo
468 noTyGenInfo = NoTyGenInfo
470 isNoTyGenInfo :: TyGenInfo -> Bool
471 isNoTyGenInfo NoTyGenInfo = True
472 isNoTyGenInfo _ = False
474 -- NB: There's probably no need to write this information out to the interface file.
475 -- Why? Simply because imported identifiers never get their types re-inferred.
476 -- But it's definitely nice to see in dumps, it for debugging purposes.
478 ppTyGenInfo :: TyGenInfo -> SDoc
479 ppTyGenInfo NoTyGenInfo = empty
480 ppTyGenInfo (TyGenUInfo us) = ptext SLIT("__G") <+> text (tyGenInfoString us)
481 ppTyGenInfo TyGenNever = ptext SLIT("__G N")
483 tyGenInfoString us = map go us
484 where go Nothing = 'x' -- for legibility, choose
485 go (Just u) | u `eqUsage` usOnce = '1' -- chars with identity
486 | u `eqUsage` usMany = 'M' -- Z-encoding.
487 go other = pprPanic "IdInfo.tyGenInfoString: unexpected annotation" (ppr other)
489 instance Outputable TyGenInfo where
492 instance Show TyGenInfo where
493 showsPrec p c = showsPrecSDoc p (ppr c)
497 %************************************************************************
499 \subsection[worker-IdInfo]{Worker info about an @Id@}
501 %************************************************************************
503 If this Id has a worker then we store a reference to it. Worker
504 functions are generated by the worker/wrapper pass. This uses
505 information from the strictness and CPR analyses.
507 There might not be a worker, even for a strict function, because:
508 (a) the function might be small enough to inline, so no need
510 (b) the strictness info might be "SSS" or something, so no w/w split.
512 Sometimes the arity of a wrapper changes from the original arity from
513 which it was generated, so we always emit the "original" arity into
514 the interface file, as part of the worker info.
516 How can this happen? Sometimes we get
517 f = coerce t (\x y -> $wf x y)
518 at the moment of w/w split; but the eta reducer turns it into
520 which is perfectly fine except that the exposed arity so far as
521 the code generator is concerned (zero) differs from the arity
522 when we did the split (2).
524 All this arises because we use 'arity' to mean "exactly how many
525 top level lambdas are there" in interface files; but during the
526 compilation of this module it means "how many things can I apply
531 data WorkerInfo = NoWorker
533 -- The Arity is the arity of the *wrapper* at the moment of the
534 -- w/w split. See comments in MkIface.ifaceId, with the 'Worker' code.
536 seqWorker :: WorkerInfo -> ()
537 seqWorker (HasWorker id _) = id `seq` ()
538 seqWorker NoWorker = ()
540 ppWorkerInfo NoWorker = empty
541 ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("__P") <+> ppr wk_id
543 workerExists :: WorkerInfo -> Bool
544 workerExists NoWorker = False
545 workerExists (HasWorker _ _) = True
547 workerId :: WorkerInfo -> Id
548 workerId (HasWorker id _) = id
550 wrapperArity :: WorkerInfo -> Arity
551 wrapperArity (HasWorker _ a) = a
555 %************************************************************************
557 \subsection[CG-IdInfo]{Code generator-related information}
559 %************************************************************************
561 CgInfo encapsulates calling-convention information produced by the code
562 generator. It is pasted into the IdInfo of each emitted Id by CoreTidy,
563 but only as a thunk --- the information is only actually produced further
564 downstream, by the code generator.
568 !Arity -- Exact arity for calling purposes
571 | NoCgInfo -- In debug mode we don't want a black hole here
574 -- noCgInfo is used for local Ids, which shouldn't need any CgInfo
577 noCgInfo = panic "NoCgInfo!"
580 cgArity (CgInfo arity _) = arity
581 cgCafInfo (CgInfo _ caf_info) = caf_info
583 setCafInfo info caf_info =
584 case cgInfo info of { CgInfo arity _ ->
585 info `setCgInfo` CgInfo arity caf_info }
587 setCgArity info arity =
588 case cgInfo info of { CgInfo _ caf_info ->
589 info `setCgInfo` CgInfo arity caf_info }
591 cgMayHaveCafRefs (CgInfo _ caf_info) = mayHaveCafRefs caf_info
593 seqCg c = c `seq` () -- fields are strict anyhow
595 vanillaCgInfo = CgInfo 0 MayHaveCafRefs -- Definitely safe
597 -- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
600 = MayHaveCafRefs -- either:
601 -- (1) A function or static constructor
602 -- that refers to one or more CAFs,
603 -- (2) A real live CAF
605 | NoCafRefs -- A function or static constructor
606 -- that refers to no CAFs.
608 mayHaveCafRefs MayHaveCafRefs = True
609 mayHaveCafRefs _ = False
611 seqCaf c = c `seq` ()
613 pprCgInfo (CgInfo arity caf_info) = ppArity arity <+> ppCafInfo caf_info
616 ppArity n = hsep [ptext SLIT("__A"), int n]
618 ppCafInfo NoCafRefs = ptext SLIT("__C")
619 ppCafInfo MayHaveCafRefs = empty
623 type CgInfoEnv = NameEnv CgInfo
625 lookupCgInfo :: NameEnv CgInfo -> Name -> CgInfo
626 lookupCgInfo env n = case lookupNameEnv env n of
628 Nothing -> pprTrace "Urk! Not in CgInfo env" (ppr n) vanillaCgInfo
632 %************************************************************************
634 \subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
636 %************************************************************************
638 If the @Id@ is a function then it may have CPR info. A CPR analysis
639 phase detects whether:
643 The function's return value has a product type, i.e. an algebraic type
644 with a single constructor. Examples of such types are tuples and boxed
647 The function always 'constructs' the value that it is returning. It
648 must do this on every path through, and it's OK if it calls another
649 function which constructs the result.
652 If this is the case then we store a template which tells us the
653 function has the CPR property and which components of the result are
659 | ReturnsCPR -- Yes, this function returns a constructed product
660 -- Implicitly, this means "after the function has been applied
661 -- to all its arguments", so the worker/wrapper builder in
662 -- WwLib.mkWWcpr checks that that it is indeed saturated before
663 -- making use of the CPR info
665 -- We used to keep nested info about sub-components, but
666 -- we never used it so I threw it away
670 seqCpr :: CprInfo -> ()
671 seqCpr ReturnsCPR = ()
672 seqCpr NoCPRInfo = ()
674 noCprInfo = NoCPRInfo
676 ppCprInfo NoCPRInfo = empty
677 ppCprInfo ReturnsCPR = ptext SLIT("__M")
679 instance Outputable CprInfo where
682 instance Show CprInfo where
683 showsPrec p c = showsPrecSDoc p (ppr c)
687 %************************************************************************
689 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
691 %************************************************************************
693 If the @Id@ is a lambda-bound variable then it may have lambda-bound
694 var info. The usage analysis (UsageSP) detects whether the lambda
695 binding this var is a ``one-shot'' lambda; that is, whether it is
696 applied at most once.
698 This information may be useful in optimisation, as computations may
699 safely be floated inside such a lambda without risk of duplicating
706 | LBVarInfo Type -- The lambda that binds this Id has this usage
707 -- annotation (i.e., if ==usOnce, then the
708 -- lambda is applied at most once).
709 -- The annotation's kind must be `$'
710 -- HACK ALERT! placing this info here is a short-term hack,
711 -- but it minimises changes to the rest of the compiler.
712 -- Hack agreed by SLPJ/KSW 1999-04.
714 seqLBVar l = l `seq` ()
718 hasNoLBVarInfo NoLBVarInfo = True
719 hasNoLBVarInfo other = False
721 noLBVarInfo = NoLBVarInfo
723 -- not safe to print or parse LBVarInfo because it is not really a
724 -- property of the definition, but a property of the context.
725 pprLBVarInfo NoLBVarInfo = empty
726 pprLBVarInfo (LBVarInfo u) | u `eqUsage` usOnce
727 = getPprStyle $ \ sty ->
730 else ptext SLIT("OneShot")
734 instance Outputable LBVarInfo where
737 instance Show LBVarInfo where
738 showsPrec p c = showsPrecSDoc p (ppr c)
742 %************************************************************************
744 \subsection{Bulk operations on IdInfo}
746 %************************************************************************
748 @zapLamInfo@ is used for lambda binders that turn out to to be
749 part of an unsaturated lambda
752 zapLamInfo :: IdInfo -> Maybe IdInfo
753 zapLamInfo info@(IdInfo {occInfo = occ, demandInfo = demand})
754 | is_safe_occ && not (isStrict demand)
757 = Just (info {occInfo = safe_occ,
758 demandInfo = wwLazy})
760 -- The "unsafe" occ info is the ones that say I'm not in a lambda
761 -- because that might not be true for an unsaturated lambda
762 is_safe_occ = case occ of
763 OneOcc in_lam once -> in_lam
766 safe_occ = case occ of
767 OneOcc _ once -> OneOcc insideLam once
772 zapDemandInfo :: IdInfo -> Maybe IdInfo
773 zapDemandInfo info@(IdInfo {demandInfo = demand})
774 | not (isStrict demand) = Nothing
775 | otherwise = Just (info {demandInfo = wwLazy})
779 copyIdInfo is used when shorting out a top-level binding
782 where f is exported. We are going to swizzle it around to
786 BUT (a) we must be careful about messing up rules
787 (b) we must ensure f's IdInfo ends up right
789 (a) Messing up the rules
791 The example that went bad on me was this one:
793 iterate :: (a -> a) -> a -> [a]
794 iterate = iterateList
796 iterateFB c f x = x `c` iterateFB c f (f x)
797 iterateList f x = x : iterateList f (f x)
800 "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
801 "iterateFB" iterateFB (:) = iterateList
804 This got shorted out to:
806 iterateList :: (a -> a) -> a -> [a]
807 iterateList = iterate
809 iterateFB c f x = x `c` iterateFB c f (f x)
810 iterate f x = x : iterate f (f x)
813 "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
814 "iterateFB" iterateFB (:) = iterate
817 And now we get an infinite loop in the rule system
818 iterate f x -> build (\cn -> iterateFB c f x)
822 Tiresome solution: don't do shorting out if f has rewrite rules.
823 Hence shortableIdInfo.
825 (b) Keeping the IdInfo right
826 ~~~~~~~~~~~~~~~~~~~~~~~~
827 We want to move strictness/worker info from f_local to f, but keep the rest.
831 shortableIdInfo :: IdInfo -> Bool
832 shortableIdInfo info = isEmptyCoreRules (specInfo info)
834 copyIdInfo :: IdInfo -- f_local
835 -> IdInfo -- f (the exported one)
836 -> IdInfo -- New info for f
837 copyIdInfo f_local f = f { strictnessInfo = strictnessInfo f_local,
838 workerInfo = workerInfo f_local,
839 cprInfo = cprInfo f_local