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,
23 arityInfo, setArityInfo, ppArityInfo,
25 -- New demand and strictness info
26 newStrictnessInfo, setNewStrictnessInfo,
27 newDemandInfo, setNewDemandInfo, pprNewStrictness,
31 -- Strictness; imported from Demand
33 mkStrictnessInfo, noStrictnessInfo,
34 ppStrictnessInfo,isBottomingStrictness,
38 WorkerInfo(..), workerExists, wrapperArity, workerId,
39 workerInfo, setWorkerInfo, ppWorkerInfo,
42 unfoldingInfo, setUnfoldingInfo, setUnfoldingInfoLazily,
45 -- Old DemandInfo and StrictnessInfo
46 demandInfo, setDemandInfo,
47 strictnessInfo, setStrictnessInfo,
48 cprInfoFromNewStrictness,
49 oldStrictnessFromNew, newStrictnessFromOld,
52 -- Constructed Product Result Info
53 CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
58 inlinePragInfo, setInlinePragInfo,
61 OccInfo(..), isFragileOcc, isDeadOcc, isLoopBreaker,
62 InsideLam, OneBranch, insideLam, notInsideLam, oneBranch, notOneBranch,
66 SpecInfo(..), specInfo, setSpecInfo, isEmptySpecInfo,
67 specInfoFreeVars, specInfoRules, seqSpecInfo,
70 CafInfo(..), cafInfo, ppCafInfo, setCafInfo, mayHaveCafRefs,
72 -- Lambda-bound variable info
73 LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
76 #include "HsVersions.h"
80 import Class ( Class )
81 import PrimOp ( PrimOp )
83 import VarSet ( VarSet, emptyVarSet, seqVarSet )
84 import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
85 InsideLam, insideLam, notInsideLam,
86 OneBranch, oneBranch, notOneBranch,
90 import DataCon ( DataCon )
91 import TyCon ( TyCon, FieldLabel )
92 import ForeignCall ( ForeignCall )
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 | RecordSelId TyCon 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) to support isImplicitId
240 -- b) when desugaring a RecordCon we can get
241 -- from the 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 (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 :: SpecInfo, -- 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 -- Within one module this is irrelevant; the
295 -- inlining of a worker is handled via the Unfolding
296 -- WorkerInfo is used *only* to indicate the form of
297 -- the RHS, so that interface files don't actually
298 -- need to contain the RHS; it can be derived from
299 -- the strictness info
301 unfoldingInfo :: Unfolding, -- Its unfolding
302 cafInfo :: CafInfo, -- CAF info
303 lbvarInfo :: LBVarInfo, -- Info about a lambda-bound variable
304 inlinePragInfo :: InlinePragInfo, -- Inline pragma
305 occInfo :: OccInfo, -- How it occurs
307 newStrictnessInfo :: Maybe StrictSig, -- Reason for Maybe: the DmdAnal phase needs to
308 -- know whether whether this is the first visit,
309 -- so it can assign botSig. Other customers want
310 -- topSig. So Nothing is good.
312 newDemandInfo :: Maybe Demand -- Similarly we want to know if there's no
313 -- known demand yet, for when we are looking for
317 seqIdInfo :: IdInfo -> ()
318 seqIdInfo (IdInfo {}) = ()
320 megaSeqIdInfo :: IdInfo -> ()
322 = seqSpecInfo (specInfo info) `seq`
323 seqWorker (workerInfo info) `seq`
325 -- Omitting this improves runtimes a little, presumably because
326 -- some unfoldings are not calculated at all
327 -- seqUnfolding (unfoldingInfo info) `seq`
329 seqNewDemandInfo (newDemandInfo info) `seq`
330 seqNewStrictnessInfo (newStrictnessInfo info) `seq`
332 #ifdef OLD_STRICTNESS
333 Demand.seqDemand (demandInfo info) `seq`
334 seqStrictnessInfo (strictnessInfo info) `seq`
335 seqCpr (cprInfo info) `seq`
338 seqCaf (cafInfo info) `seq`
339 seqLBVar (lbvarInfo info) `seq`
340 seqOccInfo (occInfo info)
346 setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
347 setSpecInfo info sp = sp `seq` info { specInfo = sp }
348 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
349 setOccInfo info oc = oc `seq` info { occInfo = oc }
350 #ifdef OLD_STRICTNESS
351 setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
353 -- Try to avoid spack leaks by seq'ing
355 setUnfoldingInfoLazily info uf -- Lazy variant to avoid looking at the
356 = -- unfolding of an imported Id unless necessary
357 info { unfoldingInfo = uf } -- (In this case the demand-zapping is redundant.)
359 setUnfoldingInfo info uf
360 -- We do *not* seq on the unfolding info, For some reason, doing so
361 -- actually increases residency significantly.
362 = info { unfoldingInfo = uf }
364 #ifdef OLD_STRICTNESS
365 setDemandInfo info dd = info { demandInfo = dd }
366 setCprInfo info cp = info { cprInfo = cp }
369 setArityInfo info ar = info { arityInfo = ar }
370 setCafInfo info caf = info { cafInfo = caf }
372 setLBVarInfo info lb = {-lb `seq`-} info { lbvarInfo = lb }
374 setNewDemandInfo info dd = dd `seq` info { newDemandInfo = dd }
375 setNewStrictnessInfo info dd = dd `seq` info { newStrictnessInfo = dd }
380 vanillaIdInfo :: IdInfo
383 cafInfo = vanillaCafInfo,
384 arityInfo = unknownArity,
385 #ifdef OLD_STRICTNESS
388 strictnessInfo = NoStrictnessInfo,
390 specInfo = emptySpecInfo,
391 workerInfo = NoWorker,
392 unfoldingInfo = noUnfolding,
393 lbvarInfo = NoLBVarInfo,
394 inlinePragInfo = AlwaysActive,
396 newDemandInfo = Nothing,
397 newStrictnessInfo = Nothing
400 noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
401 -- Used for built-in type Ids in MkId.
405 %************************************************************************
407 \subsection[arity-IdInfo]{Arity info about an @Id@}
409 %************************************************************************
411 For locally-defined Ids, the code generator maintains its own notion
412 of their arities; so it should not be asking... (but other things
413 besides the code-generator need arity info!)
416 type ArityInfo = Arity
417 -- A partial application of this Id to up to n-1 value arguments
418 -- does essentially no work. That is not necessarily the
419 -- same as saying that it has n leading lambdas, because coerces
420 -- may get in the way.
422 -- The arity might increase later in the compilation process, if
423 -- an extra lambda floats up to the binding site.
425 unknownArity = 0 :: Arity
427 ppArityInfo 0 = empty
428 ppArityInfo n = hsep [ptext SLIT("Arity"), int n]
431 %************************************************************************
433 \subsection{Inline-pragma information}
435 %************************************************************************
438 type InlinePragInfo = Activation
439 -- Tells when the inlining is active
440 -- When it is active the thing may be inlined, depending on how
443 -- If there was an INLINE pragma, then as a separate matter, the
444 -- RHS will have been made to look small with a CoreSyn Inline Note
446 -- The default InlinePragInfo is AlwaysActive, so the info serves
447 -- entirely as a way to inhibit inlining until we want it
451 %************************************************************************
455 %************************************************************************
458 -- CoreRules is used only in an idSpecialisation (move to IdInfo?)
460 = SpecInfo [CoreRule] VarSet -- Locally-defined free vars of RHSs
462 emptySpecInfo :: SpecInfo
463 emptySpecInfo = SpecInfo [] emptyVarSet
465 isEmptySpecInfo :: SpecInfo -> Bool
466 isEmptySpecInfo (SpecInfo rs _) = null rs
468 specInfoFreeVars :: SpecInfo -> VarSet
469 specInfoFreeVars (SpecInfo _ fvs) = fvs
471 specInfoRules :: SpecInfo -> [CoreRule]
472 specInfoRules (SpecInfo rules _) = rules
474 seqSpecInfo (SpecInfo rules fvs) = seqRules rules `seq` seqVarSet fvs
478 %************************************************************************
480 \subsection[worker-IdInfo]{Worker info about an @Id@}
482 %************************************************************************
484 If this Id has a worker then we store a reference to it. Worker
485 functions are generated by the worker/wrapper pass. This uses
486 information from strictness analysis.
488 There might not be a worker, even for a strict function, because:
489 (a) the function might be small enough to inline, so no need
491 (b) the strictness info might be "SSS" or something, so no w/w split.
493 Sometimes the arity of a wrapper changes from the original arity from
494 which it was generated, so we always emit the "original" arity into
495 the interface file, as part of the worker info.
497 How can this happen? Sometimes we get
498 f = coerce t (\x y -> $wf x y)
499 at the moment of w/w split; but the eta reducer turns it into
501 which is perfectly fine except that the exposed arity so far as
502 the code generator is concerned (zero) differs from the arity
503 when we did the split (2).
505 All this arises because we use 'arity' to mean "exactly how many
506 top level lambdas are there" in interface files; but during the
507 compilation of this module it means "how many things can I apply
512 data WorkerInfo = NoWorker
514 -- The Arity is the arity of the *wrapper* at the moment of the
515 -- w/w split. See notes above.
517 seqWorker :: WorkerInfo -> ()
518 seqWorker (HasWorker id a) = id `seq` a `seq` ()
519 seqWorker NoWorker = ()
521 ppWorkerInfo NoWorker = empty
522 ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("Worker") <+> ppr wk_id
524 workerExists :: WorkerInfo -> Bool
525 workerExists NoWorker = False
526 workerExists (HasWorker _ _) = True
528 workerId :: WorkerInfo -> Id
529 workerId (HasWorker id _) = id
531 wrapperArity :: WorkerInfo -> Arity
532 wrapperArity (HasWorker _ a) = a
536 %************************************************************************
538 \subsection[CG-IdInfo]{Code generator-related information}
540 %************************************************************************
543 -- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
546 = MayHaveCafRefs -- either:
547 -- (1) A function or static constructor
548 -- that refers to one or more CAFs,
549 -- (2) A real live CAF
551 | NoCafRefs -- A function or static constructor
552 -- that refers to no CAFs.
554 vanillaCafInfo = MayHaveCafRefs -- Definitely safe
556 mayHaveCafRefs MayHaveCafRefs = True
557 mayHaveCafRefs _ = False
559 seqCaf c = c `seq` ()
561 ppCafInfo NoCafRefs = ptext SLIT("NoCafRefs")
562 ppCafInfo MayHaveCafRefs = empty
565 %************************************************************************
567 \subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
569 %************************************************************************
571 If the @Id@ is a function then it may have CPR info. A CPR analysis
572 phase detects whether:
576 The function's return value has a product type, i.e. an algebraic type
577 with a single constructor. Examples of such types are tuples and boxed
580 The function always 'constructs' the value that it is returning. It
581 must do this on every path through, and it's OK if it calls another
582 function which constructs the result.
585 If this is the case then we store a template which tells us the
586 function has the CPR property and which components of the result are
590 #ifdef OLD_STRICTNESS
593 | ReturnsCPR -- Yes, this function returns a constructed product
594 -- Implicitly, this means "after the function has been applied
595 -- to all its arguments", so the worker/wrapper builder in
596 -- WwLib.mkWWcpr checks that that it is indeed saturated before
597 -- making use of the CPR info
599 -- We used to keep nested info about sub-components, but
600 -- we never used it so I threw it away
602 seqCpr :: CprInfo -> ()
603 seqCpr ReturnsCPR = ()
604 seqCpr NoCPRInfo = ()
606 noCprInfo = NoCPRInfo
608 ppCprInfo NoCPRInfo = empty
609 ppCprInfo ReturnsCPR = ptext SLIT("__M")
611 instance Outputable CprInfo where
614 instance Show CprInfo where
615 showsPrec p c = showsPrecSDoc p (ppr c)
620 %************************************************************************
622 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
624 %************************************************************************
626 If the @Id@ is a lambda-bound variable then it may have lambda-bound
627 var info. Sometimes we know whether the lambda binding this var is a
628 ``one-shot'' lambda; that is, whether it is applied at most once.
630 This information may be useful in optimisation, as computations may
631 safely be floated inside such a lambda without risk of duplicating
635 data LBVarInfo = NoLBVarInfo
636 | IsOneShotLambda -- The lambda is applied at most once).
638 seqLBVar l = l `seq` ()
642 hasNoLBVarInfo NoLBVarInfo = True
643 hasNoLBVarInfo IsOneShotLambda = False
645 noLBVarInfo = NoLBVarInfo
647 pprLBVarInfo NoLBVarInfo = empty
648 pprLBVarInfo IsOneShotLambda = ptext SLIT("OneShot")
650 instance Outputable LBVarInfo where
653 instance Show LBVarInfo where
654 showsPrec p c = showsPrecSDoc p (ppr c)
658 %************************************************************************
660 \subsection{Bulk operations on IdInfo}
662 %************************************************************************
664 @zapLamInfo@ is used for lambda binders that turn out to to be
665 part of an unsaturated lambda
668 zapLamInfo :: IdInfo -> Maybe IdInfo
669 zapLamInfo info@(IdInfo {occInfo = occ, newDemandInfo = demand})
670 | is_safe_occ occ && is_safe_dmd demand
673 = Just (info {occInfo = safe_occ, newDemandInfo = Nothing})
675 -- The "unsafe" occ info is the ones that say I'm not in a lambda
676 -- because that might not be true for an unsaturated lambda
677 is_safe_occ (OneOcc in_lam _ _) = in_lam
678 is_safe_occ other = True
680 safe_occ = case occ of
681 OneOcc _ once min_args -> OneOcc insideLam once min_args
684 is_safe_dmd Nothing = True
685 is_safe_dmd (Just dmd) = not (isStrictDmd dmd)
689 zapDemandInfo :: IdInfo -> Maybe IdInfo
690 zapDemandInfo info@(IdInfo {newDemandInfo = dmd})
691 | isJust dmd = Just (info {newDemandInfo = Nothing})
692 | otherwise = Nothing