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, hasCafIdInfo,
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 CgInfo(..), cgInfo, setCgInfo, pprCgInfo,
69 cgCafInfo, vanillaCgInfo,
70 CgInfoEnv, lookupCgInfo,
73 CafInfo(..), ppCafInfo, setCafInfo, mayHaveCafRefs,
75 -- Lambda-bound variable info
76 LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
79 #include "HsVersions.h"
83 import Type ( Type, usOnce, eqUsage )
84 import PrimOp ( PrimOp )
85 import NameEnv ( NameEnv, lookupNameEnv )
88 import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
89 InsideLam, insideLam, notInsideLam,
90 OneBranch, oneBranch, notOneBranch,
94 import DataCon ( DataCon )
95 import ForeignCall ( ForeignCall )
96 import FieldLabel ( FieldLabel )
97 import Type ( usOnce )
98 import Demand hiding( Demand, seqDemand )
99 import qualified Demand
102 import Maybe ( isJust )
103 #ifdef OLD_STRICTNESS
104 import Util ( listLengthCmp )
105 import List ( replicate )
108 -- infixl so you can say (id `set` a `set` b)
109 infixl 1 `setSpecInfo`,
118 `setNewStrictnessInfo`,
119 `setAllStrictnessInfo`,
121 #ifdef OLD_STRICTNESS
124 , `setStrictnessInfo`
128 %************************************************************************
130 \subsection{New strictness info}
132 %************************************************************************
137 -- setAllStrictnessInfo :: IdInfo -> Maybe StrictSig -> IdInfo
138 -- Set old and new strictness info
139 setAllStrictnessInfo info Nothing
140 = info { newStrictnessInfo = Nothing
141 #ifdef OLD_STRICTNESS
142 , strictnessInfo = NoStrictnessInfo
143 , cprInfo = NoCPRInfo
147 setAllStrictnessInfo info (Just sig)
148 = info { newStrictnessInfo = Just sig
149 #ifdef OLD_STRICTNESS
150 , strictnessInfo = oldStrictnessFromNew sig
151 , cprInfo = cprInfoFromNewStrictness sig
155 seqNewStrictnessInfo Nothing = ()
156 seqNewStrictnessInfo (Just ty) = seqStrictSig ty
158 pprNewStrictness Nothing = empty
159 pprNewStrictness (Just sig) = ftext FSLIT("Str:") <+> ppr sig
161 #ifdef OLD_STRICTNESS
162 oldStrictnessFromNew :: StrictSig -> Demand.StrictnessInfo
163 oldStrictnessFromNew sig = mkStrictnessInfo (map oldDemand dmds, isBotRes res_info)
165 (dmds, res_info) = splitStrictSig sig
167 cprInfoFromNewStrictness :: StrictSig -> CprInfo
168 cprInfoFromNewStrictness sig = case strictSigResInfo sig of
172 newStrictnessFromOld :: Name -> Arity -> Demand.StrictnessInfo -> CprInfo -> StrictSig
173 newStrictnessFromOld name arity (Demand.StrictnessInfo ds res) cpr
174 | listLengthCmp ds arity /= GT -- length ds <= arity
175 -- Sometimes the old strictness analyser has more
176 -- demands than the arity justifies
177 = mk_strict_sig name arity $
178 mkTopDmdType (map newDemand ds) (newRes res cpr)
180 newStrictnessFromOld name arity other cpr
181 = -- Either no strictness info, or arity is too small
182 -- In either case we can't say anything useful
183 mk_strict_sig name arity $
184 mkTopDmdType (replicate arity lazyDmd) (newRes False cpr)
186 mk_strict_sig name arity dmd_ty
187 = WARN( arity /= dmdTypeDepth dmd_ty, ppr name <+> (ppr arity $$ ppr dmd_ty) )
190 newRes True _ = BotRes
191 newRes False ReturnsCPR = retCPR
192 newRes False NoCPRInfo = TopRes
194 newDemand :: Demand.Demand -> NewDemand.Demand
195 newDemand (WwLazy True) = Abs
196 newDemand (WwLazy False) = lazyDmd
197 newDemand WwStrict = evalDmd
198 newDemand (WwUnpack unpk ds) = Eval (Prod (map newDemand ds))
199 newDemand WwPrim = lazyDmd
200 newDemand WwEnum = evalDmd
202 oldDemand :: NewDemand.Demand -> Demand.Demand
203 oldDemand Abs = WwLazy True
204 oldDemand Top = WwLazy False
205 oldDemand Bot = WwStrict
206 oldDemand (Box Bot) = WwStrict
207 oldDemand (Box Abs) = WwLazy False
208 oldDemand (Box (Eval _)) = WwStrict -- Pass box only
209 oldDemand (Defer d) = WwLazy False
210 oldDemand (Eval (Prod ds)) = WwUnpack True (map oldDemand ds)
211 oldDemand (Eval (Poly _)) = WwStrict
212 oldDemand (Call _) = WwStrict
214 #endif /* OLD_STRICTNESS */
219 seqNewDemandInfo Nothing = ()
220 seqNewDemandInfo (Just dmd) = seqDemand dmd
224 %************************************************************************
226 \subsection{GlobalIdDetails
228 %************************************************************************
230 This type is here (rather than in Id.lhs) mainly because there's
231 an IdInfo.hi-boot, but no Id.hi-boot, and GlobalIdDetails is imported
232 (recursively) by Var.lhs.
236 = VanillaGlobal -- Imported from elsewhere, a default method Id.
238 | RecordSelId FieldLabel -- The Id for a record selector
239 | DataConId DataCon -- The Id for a data constructor *worker*
240 | DataConWrapId DataCon -- The Id for a data constructor *wrapper*
241 -- [the only reasons we need to know is so that
242 -- a) we can suppress printing a definition in the interface file
243 -- b) when typechecking a pattern we can get from the
244 -- Id back to the data con]
246 | PrimOpId PrimOp -- The Id for a primitive operator
247 | FCallId ForeignCall -- The Id for a foreign call
249 | NotGlobalId -- Used as a convenient extra return value from globalIdDetails
251 notGlobalId = NotGlobalId
253 instance Outputable GlobalIdDetails where
254 ppr NotGlobalId = ptext SLIT("[***NotGlobalId***]")
255 ppr VanillaGlobal = ptext SLIT("[GlobalId]")
256 ppr (DataConId _) = ptext SLIT("[DataCon]")
257 ppr (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
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 cgInfo :: CgInfo, -- Code generator info (arity, 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 -- CgInfo is involved in a loop, so we have to be careful not to seq it
333 -- seqCg (cgInfo info) `seq`
334 seqLBVar (lbvarInfo info) `seq`
335 seqOccInfo (occInfo info)
341 setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
342 setSpecInfo info sp = sp `seq` info { specInfo = sp }
343 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
344 setOccInfo info oc = oc `seq` info { occInfo = oc }
345 #ifdef OLD_STRICTNESS
346 setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
348 -- Try to avoid spack leaks by seq'ing
350 setUnfoldingInfoLazily info uf -- Lazy variant to avoid looking at the
351 = -- unfolding of an imported Id unless necessary
352 info { unfoldingInfo = uf } -- (In this case the demand-zapping is redundant.)
354 setUnfoldingInfo info uf
355 | isEvaldUnfolding uf
356 -- If the unfolding is a value, the demand info may
357 -- go pear-shaped, so we nuke it. Example:
359 -- case x of (p,q) -> h p q x
360 -- Here x is certainly demanded. But after we've nuked
361 -- the case, we'll get just
362 -- let x = (a,b) in h a b x
363 -- and now x is not demanded (I'm assuming h is lazy)
364 -- This really happens. The solution here is a bit ad hoc...
365 = info { unfoldingInfo = uf, newDemandInfo = Nothing }
368 -- We do *not* seq on the unfolding info, For some reason, doing so
369 -- actually increases residency significantly.
370 = info { unfoldingInfo = uf }
372 #ifdef OLD_STRICTNESS
373 setDemandInfo info dd = info { demandInfo = dd }
374 setCprInfo info cp = info { cprInfo = cp }
377 setArityInfo info ar = info { arityInfo = ar }
378 setCgInfo info cg = info { cgInfo = cg }
380 setLBVarInfo info lb = {-lb `seq`-} info { lbvarInfo = lb }
382 setNewDemandInfo info dd = dd `seq` info { newDemandInfo = dd }
383 setNewStrictnessInfo info dd = dd `seq` info { newStrictnessInfo = dd }
388 vanillaIdInfo :: IdInfo
392 arityInfo = unknownArity,
393 #ifdef OLD_STRICTNESS
396 strictnessInfo = NoStrictnessInfo,
398 specInfo = emptyCoreRules,
399 workerInfo = NoWorker,
400 unfoldingInfo = noUnfolding,
401 lbvarInfo = NoLBVarInfo,
402 inlinePragInfo = AlwaysActive,
404 newDemandInfo = Nothing,
405 newStrictnessInfo = Nothing
408 hasCafIdInfo = vanillaIdInfo `setCgInfo` CgInfo MayHaveCafRefs
409 noCafIdInfo = vanillaIdInfo `setCgInfo` CgInfo NoCafRefs
410 -- Used for built-in type Ids in MkId.
411 -- These must have a valid CgInfo set, so you can't
412 -- use vanillaIdInfo!
416 %************************************************************************
418 \subsection[arity-IdInfo]{Arity info about an @Id@}
420 %************************************************************************
422 For locally-defined Ids, the code generator maintains its own notion
423 of their arities; so it should not be asking... (but other things
424 besides the code-generator need arity info!)
427 type ArityInfo = Arity
428 -- A partial application of this Id to up to n-1 value arguments
429 -- does essentially no work. That is not necessarily the
430 -- same as saying that it has n leading lambdas, because coerces
431 -- may get in the way.
433 -- The arity might increase later in the compilation process, if
434 -- an extra lambda floats up to the binding site.
436 unknownArity = 0 :: Arity
438 ppArityInfo 0 = empty
439 ppArityInfo n = hsep [ptext SLIT("Arity"), int n]
442 %************************************************************************
444 \subsection{Inline-pragma information}
446 %************************************************************************
449 type InlinePragInfo = Activation
450 -- Tells when the inlining is active
451 -- When it is active the thing may be inlined, depending on how
454 -- If there was an INLINE pragma, then as a separate matter, the
455 -- RHS will have been made to look small with a CoreSyn Inline Note
459 %************************************************************************
461 \subsection[worker-IdInfo]{Worker info about an @Id@}
463 %************************************************************************
465 If this Id has a worker then we store a reference to it. Worker
466 functions are generated by the worker/wrapper pass. This uses
467 information from strictness analysis.
469 There might not be a worker, even for a strict function, because:
470 (a) the function might be small enough to inline, so no need
472 (b) the strictness info might be "SSS" or something, so no w/w split.
474 Sometimes the arity of a wrapper changes from the original arity from
475 which it was generated, so we always emit the "original" arity into
476 the interface file, as part of the worker info.
478 How can this happen? Sometimes we get
479 f = coerce t (\x y -> $wf x y)
480 at the moment of w/w split; but the eta reducer turns it into
482 which is perfectly fine except that the exposed arity so far as
483 the code generator is concerned (zero) differs from the arity
484 when we did the split (2).
486 All this arises because we use 'arity' to mean "exactly how many
487 top level lambdas are there" in interface files; but during the
488 compilation of this module it means "how many things can I apply
493 data WorkerInfo = NoWorker
495 -- The Arity is the arity of the *wrapper* at the moment of the
496 -- w/w split. See comments in MkIface.ifaceId, with the 'Worker' code.
498 seqWorker :: WorkerInfo -> ()
499 seqWorker (HasWorker id a) = id `seq` a `seq` ()
500 seqWorker NoWorker = ()
502 ppWorkerInfo NoWorker = empty
503 ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("__P") <+> ppr wk_id
505 workerExists :: WorkerInfo -> Bool
506 workerExists NoWorker = False
507 workerExists (HasWorker _ _) = True
509 workerId :: WorkerInfo -> Id
510 workerId (HasWorker id _) = id
512 wrapperArity :: WorkerInfo -> Arity
513 wrapperArity (HasWorker _ a) = a
517 %************************************************************************
519 \subsection[CG-IdInfo]{Code generator-related information}
521 %************************************************************************
523 CgInfo encapsulates calling-convention information produced by the code
524 generator. It is pasted into the IdInfo of each emitted Id by CoreTidy,
525 but only as a thunk --- the information is only actually produced further
526 downstream, by the code generator.
529 #ifndef OLD_STRICTNESS
530 newtype CgInfo = CgInfo CafInfo -- We are back to only having CafRefs in CgInfo
531 noCgInfo = panic "NoCgInfo!"
533 data CgInfo = CgInfo CafInfo
534 | NoCgInfo -- In debug mode we don't want a black hole here
536 -- noCgInfo is used for local Ids, which shouldn't need any CgInfo
540 cgCafInfo (CgInfo caf_info) = caf_info
542 setCafInfo info caf_info = info `setCgInfo` CgInfo caf_info
544 seqCg c = c `seq` () -- fields are strict anyhow
546 vanillaCgInfo = CgInfo MayHaveCafRefs -- Definitely safe
548 -- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
551 = MayHaveCafRefs -- either:
552 -- (1) A function or static constructor
553 -- that refers to one or more CAFs,
554 -- (2) A real live CAF
556 | NoCafRefs -- A function or static constructor
557 -- that refers to no CAFs.
559 mayHaveCafRefs MayHaveCafRefs = True
560 mayHaveCafRefs _ = False
562 seqCaf c = c `seq` ()
564 pprCgInfo (CgInfo caf_info) = ppCafInfo caf_info
567 ppArity n = hsep [ptext SLIT("__A"), int n]
569 ppCafInfo NoCafRefs = ptext SLIT("__C")
570 ppCafInfo MayHaveCafRefs = empty
574 type CgInfoEnv = NameEnv CgInfo
576 lookupCgInfo :: NameEnv CgInfo -> Name -> CgInfo
577 lookupCgInfo env n = case lookupNameEnv env n of
579 Nothing -> pprTrace "Urk! Not in CgInfo env" (ppr n) vanillaCgInfo
583 %************************************************************************
585 \subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
587 %************************************************************************
589 If the @Id@ is a function then it may have CPR info. A CPR analysis
590 phase detects whether:
594 The function's return value has a product type, i.e. an algebraic type
595 with a single constructor. Examples of such types are tuples and boxed
598 The function always 'constructs' the value that it is returning. It
599 must do this on every path through, and it's OK if it calls another
600 function which constructs the result.
603 If this is the case then we store a template which tells us the
604 function has the CPR property and which components of the result are
608 #ifdef OLD_STRICTNESS
611 | ReturnsCPR -- Yes, this function returns a constructed product
612 -- Implicitly, this means "after the function has been applied
613 -- to all its arguments", so the worker/wrapper builder in
614 -- WwLib.mkWWcpr checks that that it is indeed saturated before
615 -- making use of the CPR info
617 -- We used to keep nested info about sub-components, but
618 -- we never used it so I threw it away
620 seqCpr :: CprInfo -> ()
621 seqCpr ReturnsCPR = ()
622 seqCpr NoCPRInfo = ()
624 noCprInfo = NoCPRInfo
626 ppCprInfo NoCPRInfo = empty
627 ppCprInfo ReturnsCPR = ptext SLIT("__M")
629 instance Outputable CprInfo where
632 instance Show CprInfo where
633 showsPrec p c = showsPrecSDoc p (ppr c)
638 %************************************************************************
640 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
642 %************************************************************************
644 If the @Id@ is a lambda-bound variable then it may have lambda-bound
645 var info. The usage analysis (UsageSP) detects whether the lambda
646 binding this var is a ``one-shot'' lambda; that is, whether it is
647 applied at most once.
649 This information may be useful in optimisation, as computations may
650 safely be floated inside such a lambda without risk of duplicating
657 | LBVarInfo Type -- The lambda that binds this Id has this usage
658 -- annotation (i.e., if ==usOnce, then the
659 -- lambda is applied at most once).
660 -- The annotation's kind must be `$'
661 -- HACK ALERT! placing this info here is a short-term hack,
662 -- but it minimises changes to the rest of the compiler.
663 -- Hack agreed by SLPJ/KSW 1999-04.
665 seqLBVar l = l `seq` ()
669 hasNoLBVarInfo NoLBVarInfo = True
670 hasNoLBVarInfo other = False
672 noLBVarInfo = NoLBVarInfo
674 -- not safe to print or parse LBVarInfo because it is not really a
675 -- property of the definition, but a property of the context.
676 pprLBVarInfo NoLBVarInfo = empty
677 pprLBVarInfo (LBVarInfo u) | u `eqUsage` usOnce
678 = ptext SLIT("OneShot")
682 instance Outputable LBVarInfo where
685 instance Show LBVarInfo where
686 showsPrec p c = showsPrecSDoc p (ppr c)
690 %************************************************************************
692 \subsection{Bulk operations on IdInfo}
694 %************************************************************************
696 @zapLamInfo@ is used for lambda binders that turn out to to be
697 part of an unsaturated lambda
700 zapLamInfo :: IdInfo -> Maybe IdInfo
701 zapLamInfo info@(IdInfo {occInfo = occ, newDemandInfo = demand})
702 | is_safe_occ occ && is_safe_dmd demand
705 = Just (info {occInfo = safe_occ, newDemandInfo = Nothing})
707 -- The "unsafe" occ info is the ones that say I'm not in a lambda
708 -- because that might not be true for an unsaturated lambda
709 is_safe_occ (OneOcc in_lam once) = in_lam
710 is_safe_occ other = True
712 safe_occ = case occ of
713 OneOcc _ once -> OneOcc insideLam once
716 is_safe_dmd Nothing = True
717 is_safe_dmd (Just dmd) = not (isStrictDmd dmd)
721 zapDemandInfo :: IdInfo -> Maybe IdInfo
722 zapDemandInfo info@(IdInfo {newDemandInfo = dmd})
723 | isJust dmd = Just (info {newDemandInfo = Nothing})
724 | otherwise = Nothing
728 copyIdInfo is used when shorting out a top-level binding
731 where f is exported. We are going to swizzle it around to
735 BUT (a) we must be careful about messing up rules
736 (b) we must ensure f's IdInfo ends up right
738 (a) Messing up the rules
740 The example that went bad on me was this one:
742 iterate :: (a -> a) -> a -> [a]
743 iterate = iterateList
745 iterateFB c f x = x `c` iterateFB c f (f x)
746 iterateList f x = x : iterateList f (f x)
749 "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
750 "iterateFB" iterateFB (:) = iterateList
753 This got shorted out to:
755 iterateList :: (a -> a) -> a -> [a]
756 iterateList = iterate
758 iterateFB c f x = x `c` iterateFB c f (f x)
759 iterate f x = x : iterate f (f x)
762 "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
763 "iterateFB" iterateFB (:) = iterate
766 And now we get an infinite loop in the rule system
767 iterate f x -> build (\cn -> iterateFB c f x)
771 Tiresome solution: don't do shorting out if f has rewrite rules.
772 Hence shortableIdInfo.
774 (b) Keeping the IdInfo right
775 ~~~~~~~~~~~~~~~~~~~~~~~~
776 We want to move strictness/worker info from f_local to f, but keep the rest.
780 shortableIdInfo :: IdInfo -> Bool
781 shortableIdInfo info = isEmptyCoreRules (specInfo info)
783 copyIdInfo :: IdInfo -- f_local
784 -> IdInfo -- f (the exported one)
785 -> IdInfo -- New info for f
786 copyIdInfo f_local f = f { newStrictnessInfo = newStrictnessInfo f_local,
787 #ifdef OLD_STRICTNESS
788 strictnessInfo = strictnessInfo f_local,
789 cprInfo = cprInfo f_local,
791 workerInfo = workerInfo f_local