[project @ 2005-10-14 11:22:41 by simonpj]
[ghc-hetmet.git] / ghc / compiler / basicTypes / IdInfo.lhs
index 7e1c8d5..d53bf56 100644 (file)
@@ -1,5 +1,5 @@
 %
-% (c) The GRASP/AQUA Project, Glasgow University, 1993-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
 %
 \section[IdInfo]{@IdInfos@: Non-essential information about @Ids@}
 
@@ -8,68 +8,270 @@ Haskell. [WDP 94/11])
 
 \begin{code}
 module IdInfo (
+       GlobalIdDetails(..), notGlobalId,       -- Not abstract
+
        IdInfo,         -- Abstract
+       vanillaIdInfo, noCafIdInfo,
+       seqIdInfo, megaSeqIdInfo,
 
-       noIdInfo,
-       ppIdInfo,
+       -- Zapping
+       zapLamInfo, zapDemandInfo,
 
        -- Arity
-       ArityInfo(..),
-       exactArity, atLeastArity, unknownArity,
-       arityInfo, setArityInfo, ppArityInfo,
+       ArityInfo,
+       unknownArity, 
+       arityInfo, setArityInfo, ppArityInfo, 
+
+       -- New demand and strictness info
+       newStrictnessInfo, setNewStrictnessInfo, 
+       newDemandInfo, setNewDemandInfo, pprNewStrictness,
+       setAllStrictnessInfo,
+
+#ifdef OLD_STRICTNESS
+       -- Strictness; imported from Demand
+       StrictnessInfo(..),
+       mkStrictnessInfo, noStrictnessInfo,
+       ppStrictnessInfo,isBottomingStrictness, 
+#endif
+
+        -- Worker
+        WorkerInfo(..), workerExists, wrapperArity, workerId,
+        workerInfo, setWorkerInfo, ppWorkerInfo,
 
-       -- Demand
-       DemandInfo,
-       noDemandInfo, mkDemandInfo, demandInfo, ppDemandInfo, setDemandInfo, willBeDemanded,
-       Demand(..),                                     -- Non-abstract
+       -- Unfolding
+       unfoldingInfo, setUnfoldingInfo, setUnfoldingInfoLazily,
 
-       -- Strictness
-       StrictnessInfo(..),                             -- Non-abstract
-       workerExists,
-       mkStrictnessInfo, mkBottomStrictnessInfo, noStrictnessInfo, bottomIsGuaranteed,
-       strictnessInfo, ppStrictnessInfo, setStrictnessInfo, 
+#ifdef OLD_STRICTNESS
+       -- Old DemandInfo and StrictnessInfo
+       demandInfo, setDemandInfo, 
+       strictnessInfo, setStrictnessInfo,
+        cprInfoFromNewStrictness,
+       oldStrictnessFromNew, newStrictnessFromOld,
+       oldDemand, newDemand,
 
-       -- Unfolding
-       unfoldingInfo, setUnfoldingInfo, 
+        -- Constructed Product Result Info
+        CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
+#endif
 
        -- Inline prags
-       InlinePragInfo(..),
-       inlinePragInfo, setInlinePragInfo,
+       InlinePragInfo, 
+       inlinePragInfo, setInlinePragInfo, 
 
-       -- Specialisation
-       IdSpecEnv, specInfo, setSpecInfo,
+       -- Occurrence info
+       OccInfo(..), isFragileOcc, isDeadOcc, isLoopBreaker,
+       InsideLam, OneBranch, insideLam, notInsideLam, oneBranch, notOneBranch,
+       occInfo, setOccInfo, 
 
-       -- Update
-       UpdateInfo, UpdateSpec,
-       mkUpdateInfo, updateInfo, updateInfoMaybe, ppUpdateInfo, setUpdateInfo,
+       -- Specialisation
+       SpecInfo(..), specInfo, setSpecInfo, isEmptySpecInfo, 
+       specInfoFreeVars, specInfoRules, seqSpecInfo,
 
-       -- Arg usage 
-       ArgUsageInfo, ArgUsage(..), ArgUsageType,
-       mkArgUsageInfo, argUsageInfo, setArgUsageInfo, getArgUsage,
+       -- CAF info
+       CafInfo(..), cafInfo, ppCafInfo, setCafInfo, mayHaveCafRefs,
 
-       -- FB type
-       FBTypeInfo, FBType(..), FBConsum(..), FBProd(..),
-       fbTypeInfo, ppFBTypeInfo, setFBTypeInfo, mkFBTypeInfo, getFBType
+        -- Lambda-bound variable info
+        LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
     ) where
 
 #include "HsVersions.h"
 
 
-import {-# SOURCE #-} CoreUnfold ( Unfolding, noUnfolding )
-import {-# SOURCE #-} CoreSyn   ( CoreExpr )
+import CoreSyn
+import Class           ( Class )
+import PrimOp          ( PrimOp )
+import Var              ( Id )
+import VarSet          ( VarSet, emptyVarSet, seqVarSet )
+import BasicTypes      ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
+                         InsideLam, insideLam, notInsideLam, 
+                         OneBranch, oneBranch, notOneBranch,
+                         Arity,
+                         Activation(..)
+                       )
+import DataCon         ( DataCon )
+import TyCon           ( TyCon, FieldLabel )
+import ForeignCall     ( ForeignCall )
+import NewDemand
+import Outputable      
+import Maybe           ( isJust )
+
+#ifdef OLD_STRICTNESS
+import Name            ( Name )
+import Demand          hiding( Demand, seqDemand )
+import qualified Demand
+import Util            ( listLengthCmp )
+import List            ( replicate )
+#endif
+
+-- infixl so you can say (id `set` a `set` b)
+infixl         1 `setSpecInfo`,
+         `setArityInfo`,
+         `setInlinePragInfo`,
+         `setUnfoldingInfo`,
+         `setWorkerInfo`,
+         `setLBVarInfo`,
+         `setOccInfo`,
+         `setCafInfo`,
+         `setNewStrictnessInfo`,
+         `setAllStrictnessInfo`,
+         `setNewDemandInfo`
+#ifdef OLD_STRICTNESS
+         , `setCprInfo`
+         , `setDemandInfo`
+         , `setStrictnessInfo`
+#endif
+\end{code}
 
--- for mkdependHS, CoreSyn.hi-boot refers to it:
-import BinderInfo ( BinderInfo )
+%************************************************************************
+%*                                                                     *
+\subsection{New strictness info}
+%*                                                                     *
+%************************************************************************
 
-import SpecEnv         ( SpecEnv, emptySpecEnv )
-import BasicTypes      ( NewOrData )
+To be removed later
+
+\begin{code}
+-- setAllStrictnessInfo :: IdInfo -> Maybe StrictSig -> IdInfo
+-- Set old and new strictness info
+setAllStrictnessInfo info Nothing
+  = info { newStrictnessInfo = Nothing
+#ifdef OLD_STRICTNESS
+         , strictnessInfo = NoStrictnessInfo
+         , cprInfo = NoCPRInfo
+#endif
+         }
+
+setAllStrictnessInfo info (Just sig)
+  = info { newStrictnessInfo = Just sig
+#ifdef OLD_STRICTNESS
+         , strictnessInfo = oldStrictnessFromNew sig
+         , cprInfo = cprInfoFromNewStrictness sig
+#endif
+         }
+
+seqNewStrictnessInfo Nothing = ()
+seqNewStrictnessInfo (Just ty) = seqStrictSig ty
+
+pprNewStrictness Nothing = empty
+pprNewStrictness (Just sig) = ftext FSLIT("Str:") <+> ppr sig
+
+#ifdef OLD_STRICTNESS
+oldStrictnessFromNew :: StrictSig -> Demand.StrictnessInfo
+oldStrictnessFromNew sig = mkStrictnessInfo (map oldDemand dmds, isBotRes res_info)
+                        where
+                          (dmds, res_info) = splitStrictSig sig
+
+cprInfoFromNewStrictness :: StrictSig -> CprInfo
+cprInfoFromNewStrictness sig = case strictSigResInfo sig of
+                                 RetCPR -> ReturnsCPR
+                                 other  -> NoCPRInfo
+
+newStrictnessFromOld :: Name -> Arity -> Demand.StrictnessInfo -> CprInfo -> StrictSig
+newStrictnessFromOld name arity (Demand.StrictnessInfo ds res) cpr
+  | listLengthCmp ds arity /= GT -- length ds <= arity
+       -- Sometimes the old strictness analyser has more
+       -- demands than the arity justifies
+  = mk_strict_sig name arity $
+    mkTopDmdType (map newDemand ds) (newRes res cpr)
+
+newStrictnessFromOld name arity other cpr
+  =    -- Either no strictness info, or arity is too small
+       -- In either case we can't say anything useful
+    mk_strict_sig name arity $
+    mkTopDmdType (replicate arity lazyDmd) (newRes False cpr)
+
+mk_strict_sig name arity dmd_ty
+  = WARN( arity /= dmdTypeDepth dmd_ty, ppr name <+> (ppr arity $$ ppr dmd_ty) )
+    mkStrictSig dmd_ty
+
+newRes True  _                 = BotRes
+newRes False ReturnsCPR = retCPR
+newRes False NoCPRInfo  = TopRes
+
+newDemand :: Demand.Demand -> NewDemand.Demand
+newDemand (WwLazy True)      = Abs
+newDemand (WwLazy False)     = lazyDmd
+newDemand WwStrict          = evalDmd
+newDemand (WwUnpack unpk ds) = Eval (Prod (map newDemand ds))
+newDemand WwPrim            = lazyDmd
+newDemand WwEnum            = evalDmd
+
+oldDemand :: NewDemand.Demand -> Demand.Demand
+oldDemand Abs             = WwLazy True
+oldDemand Top             = WwLazy False
+oldDemand Bot             = WwStrict
+oldDemand (Box Bot)       = WwStrict
+oldDemand (Box Abs)       = WwLazy False
+oldDemand (Box (Eval _))   = WwStrict  -- Pass box only
+oldDemand (Defer d)        = WwLazy False
+oldDemand (Eval (Prod ds)) = WwUnpack True (map oldDemand ds)
+oldDemand (Eval (Poly _))  = WwStrict
+oldDemand (Call _)         = WwStrict
+
+#endif /* OLD_STRICTNESS */
+\end{code}
 
-import Demand
-import Outputable      
 
-import Char            ( ord )
+\begin{code}
+seqNewDemandInfo Nothing    = ()
+seqNewDemandInfo (Just dmd) = seqDemand dmd
 \end{code}
 
+
+%************************************************************************
+%*                                                                     *
+\subsection{GlobalIdDetails
+%*                                                                     *
+%************************************************************************
+
+This type is here (rather than in Id.lhs) mainly because there's 
+an IdInfo.hi-boot, but no Id.hi-boot, and GlobalIdDetails is imported
+(recursively) by Var.lhs.
+
+\begin{code}
+data GlobalIdDetails
+  = VanillaGlobal              -- Imported from elsewhere, a default method Id.
+
+  | RecordSelId                 -- The Id for a record selector
+    { sel_tycon   :: TyCon
+    , sel_label   :: FieldLabel
+    , sel_naughty :: Bool       -- True <=> naughty
+    }                          -- See Note [Naughty record selectors]
+                               -- with MkId.mkRecordSelectorId
+
+  | DataConWorkId DataCon      -- The Id for a data constructor *worker*
+  | DataConWrapId DataCon      -- The Id for a data constructor *wrapper*
+                               -- [the only reasons we need to know is so that
+                               --  a) to support isImplicitId
+                               --  b) when desugaring a RecordCon we can get 
+                               --     from the Id back to the data con]
+
+  | ClassOpId Class            -- An operation of a class
+
+  | PrimOpId PrimOp            -- The Id for a primitive operator
+  | FCallId ForeignCall                -- The Id for a foreign call
+
+  | NotGlobalId                        -- Used as a convenient extra return value from globalIdDetails
+    
+notGlobalId = NotGlobalId
+
+instance Outputable GlobalIdDetails where
+    ppr NotGlobalId       = ptext SLIT("[***NotGlobalId***]")
+    ppr VanillaGlobal     = ptext SLIT("[GlobalId]")
+    ppr (DataConWorkId _) = ptext SLIT("[DataCon]")
+    ppr (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
+    ppr (ClassOpId _)     = ptext SLIT("[ClassOp]")
+    ppr (PrimOpId _)      = ptext SLIT("[PrimOp]")
+    ppr (FCallId _)       = ptext SLIT("[ForeignCall]")
+    ppr (RecordSelId {})  = ptext SLIT("[RecSel]")
+\end{code}
+
+
+%************************************************************************
+%*                                                                     *
+\subsection{The main IdInfo type}
+%*                                                                     *
+%************************************************************************
+
 An @IdInfo@ gives {\em optional} information about an @Id@.  If
 present it never lies, but it may not be present, in which case there
 is always a conservative assumption which can be made.
@@ -80,94 +282,155 @@ the properties attached to the other.
 
 The @IdInfo@ gives information about the value, or definition, of the
 @Id@.  It does {\em not} contain information about the @Id@'s usage
-(except for @DemandInfo@? ToDo).
+(except for @DemandInfo@? ToDo). (@lbvarInfo@ is also a marginal
+case.  KSW 1999-04).
 
 \begin{code}
 data IdInfo
   = IdInfo {
-       arityInfo :: ArityInfo,                 -- Its arity
-
-       demandInfo :: DemandInfo,               -- Whether or not it is definitely demanded
-
-       specInfo :: IdSpecEnv,                  -- Specialisations of this function which exist
+       arityInfo       :: !ArityInfo,          -- Its arity
+       specInfo        :: SpecInfo,            -- Specialisations of this function which exist
+#ifdef OLD_STRICTNESS
+       cprInfo         :: CprInfo,             -- Function always constructs a product result
+       demandInfo      :: Demand.Demand,       -- Whether or not it is definitely demanded
+       strictnessInfo  :: StrictnessInfo,      -- Strictness properties
+#endif
+        workerInfo      :: WorkerInfo,          -- Pointer to Worker Function
+                                               -- Within one module this is irrelevant; the 
+                                               -- inlining of a worker is handled via the Unfolding
+                                               -- WorkerInfo is used *only* to indicate the form of
+                                               -- the RHS, so that interface files don't actually 
+                                               -- need to contain the RHS; it can be derived from
+                                               -- the strictness info
+
+       unfoldingInfo   :: Unfolding,           -- Its unfolding
+       cafInfo         :: CafInfo,             -- CAF info
+        lbvarInfo      :: LBVarInfo,           -- Info about a lambda-bound variable
+       inlinePragInfo  :: InlinePragInfo,      -- Inline pragma
+       occInfo         :: OccInfo,             -- How it occurs
+
+       newStrictnessInfo :: Maybe StrictSig,   -- Reason for Maybe: the DmdAnal phase needs to
+                                               -- know whether whether this is the first visit,
+                                               -- so it can assign botSig.  Other customers want
+                                               -- topSig.  So Nothing is good.
+
+       newDemandInfo     :: Maybe Demand       -- Similarly we want to know if there's no
+                                               -- known demand yet, for when we are looking for
+                                               -- CPR info
+    }
 
-       strictnessInfo :: StrictnessInfo,       -- Strictness properties
+seqIdInfo :: IdInfo -> ()
+seqIdInfo (IdInfo {}) = ()
 
-       unfoldingInfo :: Unfolding,             -- Its unfolding; for locally-defined
-                                               -- things, this can *only* be NoUnfolding
+megaSeqIdInfo :: IdInfo -> ()
+megaSeqIdInfo info
+  = seqSpecInfo (specInfo info)                        `seq`
+    seqWorker (workerInfo info)                        `seq`
 
-       updateInfo :: UpdateInfo,               -- Which args should be updated
+-- Omitting this improves runtimes a little, presumably because
+-- some unfoldings are not calculated at all
+--    seqUnfolding (unfoldingInfo info)                `seq`
 
-       argUsageInfo :: ArgUsageInfo,           -- how this Id uses its arguments
+    seqNewDemandInfo (newDemandInfo info)      `seq`
+    seqNewStrictnessInfo (newStrictnessInfo info) `seq`
 
-       fbTypeInfo :: FBTypeInfo,               -- the Foldr/Build W/W property of this function.
+#ifdef OLD_STRICTNESS
+    Demand.seqDemand (demandInfo info)         `seq`
+    seqStrictnessInfo (strictnessInfo info)    `seq`
+    seqCpr (cprInfo info)                      `seq`
+#endif
 
-       inlinePragInfo :: InlinePragInfo        -- Inline pragmas
-    }
+    seqCaf (cafInfo info)                      `seq`
+    seqLBVar (lbvarInfo info)                  `seq`
+    seqOccInfo (occInfo info) 
 \end{code}
 
 Setters
 
 \begin{code}
-setFBTypeInfo    fb info = info { fbTypeInfo = fb }
-setArgUsageInfo   au info = info { argUsageInfo = au }
-setUpdateInfo    ud info = info { updateInfo = ud }
-setDemandInfo    dd info = info { demandInfo = dd }
-setStrictnessInfo st info = info { strictnessInfo = st }
-setSpecInfo      sp info = info { specInfo = sp }
-setArityInfo     ar info = info { arityInfo = ar  }
-setInlinePragInfo pr info = info { inlinePragInfo = pr }
-setUnfoldingInfo  uf info = info { unfoldingInfo = uf }
+setWorkerInfo     info wk = wk `seq` info { workerInfo = wk }
+setSpecInfo      info sp = sp `seq` info { specInfo = sp }
+setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
+setOccInfo       info oc = oc `seq` info { occInfo = oc }
+#ifdef OLD_STRICTNESS
+setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
+#endif
+       -- Try to avoid spack leaks by seq'ing
+
+setUnfoldingInfoLazily info uf         -- Lazy variant to avoid looking at the
+  =                            -- unfolding of an imported Id unless necessary
+    info { unfoldingInfo = uf }        -- (In this case the demand-zapping is redundant.)
+
+setUnfoldingInfo info uf 
+       -- We do *not* seq on the unfolding info, For some reason, doing so 
+       -- actually increases residency significantly. 
+  = info { unfoldingInfo = uf }
+
+#ifdef OLD_STRICTNESS
+setDemandInfo    info dd = info { demandInfo = dd }
+setCprInfo        info cp = info { cprInfo = cp }
+#endif
+
+setArityInfo     info ar  = info { arityInfo = ar  }
+setCafInfo        info caf = info { cafInfo = caf }
+
+setLBVarInfo      info lb = {-lb `seq`-} info { lbvarInfo = lb }
+
+setNewDemandInfo     info dd = dd `seq` info { newDemandInfo = dd }
+setNewStrictnessInfo info dd = dd `seq` info { newStrictnessInfo = dd }
 \end{code}
 
 
 \begin{code}
-noIdInfo = IdInfo {
-               arityInfo       = UnknownArity,
-               demandInfo      = UnknownDemand,
-               specInfo        = emptySpecEnv,
-               strictnessInfo  = NoStrictnessInfo,
-               unfoldingInfo   = noUnfolding,
-               updateInfo      = NoUpdateInfo,
-               argUsageInfo    = NoArgUsageInfo,
-               fbTypeInfo      = NoFBTypeInfo, 
-               inlinePragInfo  = NoPragmaInfo
+vanillaIdInfo :: IdInfo
+vanillaIdInfo 
+  = IdInfo {
+           cafInfo             = vanillaCafInfo,
+           arityInfo           = unknownArity,
+#ifdef OLD_STRICTNESS
+           cprInfo             = NoCPRInfo,
+           demandInfo          = wwLazy,
+           strictnessInfo      = NoStrictnessInfo,
+#endif
+           specInfo            = emptySpecInfo,
+           workerInfo          = NoWorker,
+           unfoldingInfo       = noUnfolding,
+           lbvarInfo           = NoLBVarInfo,
+           inlinePragInfo      = AlwaysActive,
+           occInfo             = NoOccInfo,
+           newDemandInfo       = Nothing,
+           newStrictnessInfo   = Nothing
           }
-\end{code}
 
-\begin{code}
-ppIdInfo :: Bool       -- True <=> print specialisations, please
-        -> IdInfo
-        -> SDoc
-
-ppIdInfo specs_please (IdInfo {arityInfo, updateInfo, strictnessInfo, demandInfo})
-  = hsep [
-           ppArityInfo arityInfo,
-           ppUpdateInfo updateInfo,
-           ppStrictnessInfo strictnessInfo,
-           ppDemandInfo demandInfo
-       ]
+noCafIdInfo  = vanillaIdInfo `setCafInfo`    NoCafRefs
+       -- Used for built-in type Ids in MkId.
 \end{code}
 
+
 %************************************************************************
 %*                                                                     *
 \subsection[arity-IdInfo]{Arity info about an @Id@}
 %*                                                                     *
 %************************************************************************
 
+For locally-defined Ids, the code generator maintains its own notion
+of their arities; so it should not be asking...         (but other things
+besides the code-generator need arity info!)
+
 \begin{code}
-data ArityInfo
-  = UnknownArity       -- No idea
-  | ArityExactly Int   -- Arity is exactly this
-  | ArityAtLeast Int   -- Arity is this or greater
-
-exactArity   = ArityExactly
-atLeastArity = ArityAtLeast
-unknownArity = UnknownArity
-
-ppArityInfo UnknownArity        = empty
-ppArityInfo (ArityExactly arity) = hsep [ptext SLIT("_A_"), int arity]
-ppArityInfo (ArityAtLeast arity) = hsep [ptext SLIT("_A>_"), int arity]
+type ArityInfo = Arity
+       -- A partial application of this Id to up to n-1 value arguments
+       -- does essentially no work.  That is not necessarily the
+       -- same as saying that it has n leading lambdas, because coerces
+       -- may get in the way.
+
+       -- The arity might increase later in the compilation process, if
+       -- an extra lambda floats up to the binding site.
+
+unknownArity = 0 :: Arity
+
+ppArityInfo 0 = empty
+ppArityInfo n = hsep [ptext SLIT("Arity"), int n]
 \end{code}
 
 %************************************************************************
@@ -177,275 +440,260 @@ ppArityInfo (ArityAtLeast arity) = hsep [ptext SLIT("_A>_"), int arity]
 %************************************************************************
 
 \begin{code}
-data InlinePragInfo
-  = NoPragmaInfo
-
-  | IWantToBeINLINEd     -- user requests that we inline this
-
-  | IDontWantToBeINLINEd  -- user requests that we don't inline this
-
-  | IMustNotBeINLINEd  -- Used by the simplifier to prevent looping
-                       -- on recursive definitions
-
-  | IMustBeINLINEd     -- Absolutely must inline; used for PrimOps only
+type InlinePragInfo = Activation
+       -- Tells when the inlining is active
+       -- When it is active the thing may be inlined, depending on how
+       -- big it is.
+       --
+       -- If there was an INLINE pragma, then as a separate matter, the
+       -- RHS will have been made to look small with a CoreSyn Inline Note
+
+       -- The default InlinePragInfo is AlwaysActive, so the info serves
+       -- entirely as a way to inhibit inlining until we want it
 \end{code}
 
 
 %************************************************************************
 %*                                                                     *
-\subsection[specialisation-IdInfo]{Specialisation info about an @Id@}
+       SpecInfo
 %*                                                                     *
 %************************************************************************
 
-A @IdSpecEnv@ holds details of an @Id@'s specialisations. 
-
 \begin{code}
-type IdSpecEnv = SpecEnv CoreExpr
-\end{code}
-
-For example, if \tr{f}'s @SpecEnv@ contains the mapping:
-\begin{verbatim}
-       [List a, b]  ===>  (\d -> f' a b)
-\end{verbatim}
-then when we find an application of f to matching types, we simply replace
-it by the matching RHS:
-\begin{verbatim}
-       f (List Int) Bool ===>  (\d -> f' Int Bool)
-\end{verbatim}
-All the stuff about how many dictionaries to discard, and what types
-to apply the specialised function to, are handled by the fact that the
-SpecEnv contains a template for the result of the specialisation.
+-- CoreRules is used only in an idSpecialisation (move to IdInfo?)
+data SpecInfo 
+  = SpecInfo [CoreRule] VarSet -- Locally-defined free vars of RHSs
 
-There is one more exciting case, which is dealt with in exactly the same
-way.  If the specialised value is unboxed then it is lifted at its
-definition site and unlifted at its uses.  For example:
+emptySpecInfo :: SpecInfo
+emptySpecInfo = SpecInfo [] emptyVarSet
 
-       pi :: forall a. Num a => a
+isEmptySpecInfo :: SpecInfo -> Bool
+isEmptySpecInfo (SpecInfo rs _) = null rs
 
-might have a specialisation
+specInfoFreeVars :: SpecInfo -> VarSet
+specInfoFreeVars (SpecInfo _ fvs) = fvs
 
-       [Int#] ===>  (case pi' of Lift pi# -> pi#)
-
-where pi' :: Lift Int# is the specialised version of pi.
+specInfoRules :: SpecInfo -> [CoreRule]
+specInfoRules (SpecInfo rules _) = rules
 
+seqSpecInfo (SpecInfo rules fvs) = seqRules rules `seq` seqVarSet fvs
+\end{code}
 
 
 %************************************************************************
 %*                                                                     *
-\subsection[strictness-IdInfo]{Strictness info about an @Id@}
+\subsection[worker-IdInfo]{Worker info about an @Id@}
 %*                                                                     *
 %************************************************************************
 
-We specify the strictness of a function by giving information about
-each of the ``wrapper's'' arguments (see the description about
-worker/wrapper-style transformations in the PJ/Launchbury paper on
-unboxed types).
+If this Id has a worker then we store a reference to it. Worker
+functions are generated by the worker/wrapper pass.  This uses
+information from strictness analysis.
 
-The list of @Demands@ specifies: (a)~the strictness properties
-of a function's arguments; (b)~the {\em existence} of a ``worker''
-version of the function; and (c)~the type signature of that worker (if
-it exists); i.e. its calling convention.
+There might not be a worker, even for a strict function, because:
+(a) the function might be small enough to inline, so no need 
+    for w/w split
+(b) the strictness info might be "SSS" or something, so no w/w split.
 
-\begin{code}
-data StrictnessInfo
-  = NoStrictnessInfo
-
-  | BottomGuaranteed   -- This Id guarantees never to return;
-                       -- it is bottom regardless of its arguments.
-                       -- Useful for "error" and other disguised
-                       -- variants thereof.
-
-  | StrictnessInfo [Demand] 
-                  Bool         -- True <=> there is a worker. There might not be, even for a
-                               -- strict function, because:
-                               --      (a) the function might be small enough to inline, 
-                               --          so no need for w/w split
-                               --      (b) the strictness info might be "SSS" or something, so no w/w split.
-
-                               -- Worker's Id, if applicable, and a list of the constructors
-                               -- mentioned by the wrapper.  This is necessary so that the
-                               -- renamer can slurp them in.  Without this info, the renamer doesn't
-                               -- know which data types to slurp in concretely.  Remember, for
-                               -- strict things we don't put the unfolding in the interface file, to save space.
-                               -- This constructor list allows the renamer to behave much as if the
-                               -- unfolding *was* in the interface file.
-\end{code}
+Sometimes the arity of a wrapper changes from the original arity from
+which it was generated, so we always emit the "original" arity into
+the interface file, as part of the worker info.
 
-\begin{code}
-mkStrictnessInfo :: [Demand] -> Bool -> StrictnessInfo
+How can this happen?  Sometimes we get
+       f = coerce t (\x y -> $wf x y)
+at the moment of w/w split; but the eta reducer turns it into
+       f = coerce t $wf
+which is perfectly fine except that the exposed arity so far as
+the code generator is concerned (zero) differs from the arity
+when we did the split (2).  
 
-mkStrictnessInfo xs has_wrkr
-  | all is_lazy xs      = NoStrictnessInfo             -- Uninteresting
-  | otherwise           = StrictnessInfo xs has_wrkr
-  where
-    is_lazy (WwLazy False) = True      -- NB "Absent" args do *not* count!
-    is_lazy _             = False      -- (as they imply a worker)
+All this arises because we use 'arity' to mean "exactly how many
+top level lambdas are there" in interface files; but during the
+compilation of this module it means "how many things can I apply
+this to".
 
-noStrictnessInfo       = NoStrictnessInfo
-mkBottomStrictnessInfo = BottomGuaranteed
+\begin{code}
 
-bottomIsGuaranteed BottomGuaranteed = True
-bottomIsGuaranteed other           = False
+data WorkerInfo = NoWorker
+               | HasWorker Id Arity
+       -- The Arity is the arity of the *wrapper* at the moment of the
+       -- w/w split.  See notes above.
 
-ppStrictnessInfo NoStrictnessInfo = empty
-ppStrictnessInfo BottomGuaranteed = ptext SLIT("_bot_")
+seqWorker :: WorkerInfo -> ()
+seqWorker (HasWorker id a) = id `seq` a `seq` ()
+seqWorker NoWorker        = ()
 
-ppStrictnessInfo (StrictnessInfo wrapper_args wrkr_maybe)
-  = hsep [ptext SLIT("_S_"), text (showList wrapper_args "")]
-\end{code}
+ppWorkerInfo NoWorker            = empty
+ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("Worker") <+> ppr wk_id
 
+workerExists :: WorkerInfo -> Bool
+workerExists NoWorker        = False
+workerExists (HasWorker _ _) = True
 
-\begin{code}
-workerExists :: StrictnessInfo -> Bool
-workerExists (StrictnessInfo _ worker_exists) = worker_exists
-workerExists other                           = False
+workerId :: WorkerInfo -> Id
+workerId (HasWorker id _) = id
+
+wrapperArity :: WorkerInfo -> Arity
+wrapperArity (HasWorker _ a) = a
 \end{code}
 
 
 %************************************************************************
 %*                                                                     *
-\subsection[demand-IdInfo]{Demand info about an @Id@}
+\subsection[CG-IdInfo]{Code generator-related information}
 %*                                                                     *
 %************************************************************************
 
-Whether a value is certain to be demanded or not.  (This is the
-information that is computed by the ``front-end'' of the strictness
-analyser.)
+\begin{code}
+-- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
 
-This information is only used within a module, it is not exported
-(obviously).
+data CafInfo 
+       = MayHaveCafRefs                -- either:
+                                       -- (1) A function or static constructor
+                                       --     that refers to one or more CAFs,
+                                       -- (2) A real live CAF
 
-\begin{code}
-data DemandInfo
-  = UnknownDemand
-  | DemandedAsPer Demand
-\end{code}
+       | NoCafRefs                     -- A function or static constructor
+                                       -- that refers to no CAFs.
 
-\begin{code}
-noDemandInfo = UnknownDemand
+vanillaCafInfo = MayHaveCafRefs                -- Definitely safe
 
-mkDemandInfo :: Demand -> DemandInfo
-mkDemandInfo demand = DemandedAsPer demand
+mayHaveCafRefs  MayHaveCafRefs = True
+mayHaveCafRefs _              = False
 
-willBeDemanded :: DemandInfo -> Bool
-willBeDemanded (DemandedAsPer demand) = isStrict demand
-willBeDemanded _                     = False
+seqCaf c = c `seq` ()
 
-ppDemandInfo UnknownDemand           = text "{-# L #-}"
-ppDemandInfo (DemandedAsPer info) = hsep [text "{-#", text (showList [info] ""), text "#-}"]
+ppCafInfo NoCafRefs = ptext SLIT("NoCafRefs")
+ppCafInfo MayHaveCafRefs = empty
 \end{code}
 
-
 %************************************************************************
 %*                                                                     *
-\subsection[update-IdInfo]{Update-analysis info about an @Id@}
+\subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
 %*                                                                     *
 %************************************************************************
 
-\begin{code}
-data UpdateInfo
-  = NoUpdateInfo
-  | SomeUpdateInfo UpdateSpec
-  deriving (Eq, Ord)
-      -- we need Eq/Ord to cross-chk update infos in interfaces
-
--- the form in which we pass update-analysis info between modules:
-type UpdateSpec = [Int]
-\end{code}
+If the @Id@ is a function then it may have CPR info. A CPR analysis
+phase detects whether:
+
+\begin{enumerate}
+\item
+The function's return value has a product type, i.e. an algebraic  type 
+with a single constructor. Examples of such types are tuples and boxed
+primitive values.
+\item
+The function always 'constructs' the value that it is returning.  It
+must do this on every path through,  and it's OK if it calls another
+function which constructs the result.
+\end{enumerate}
+
+If this is the case then we store a template which tells us the
+function has the CPR property and which components of the result are
+also CPRs.   
 
 \begin{code}
-mkUpdateInfo = SomeUpdateInfo
+#ifdef OLD_STRICTNESS
+data CprInfo
+  = NoCPRInfo
+  | ReturnsCPR -- Yes, this function returns a constructed product
+               -- Implicitly, this means "after the function has been applied
+               -- to all its arguments", so the worker/wrapper builder in 
+               -- WwLib.mkWWcpr checks that that it is indeed saturated before
+               -- making use of the CPR info
 
-updateInfoMaybe NoUpdateInfo       = Nothing
-updateInfoMaybe (SomeUpdateInfo []) = Nothing
-updateInfoMaybe (SomeUpdateInfo         u) = Just u
-\end{code}
+       -- We used to keep nested info about sub-components, but
+       -- we never used it so I threw it away
 
-Text instance so that the update annotations can be read in.
+seqCpr :: CprInfo -> ()
+seqCpr ReturnsCPR = ()
+seqCpr NoCPRInfo  = ()
 
-\begin{code}
-ppUpdateInfo NoUpdateInfo             = empty
-ppUpdateInfo (SomeUpdateInfo [])   = empty
-ppUpdateInfo (SomeUpdateInfo spec) = (<>) (ptext SLIT("_U_ ")) (hcat (map int spec))
+noCprInfo       = NoCPRInfo
+
+ppCprInfo NoCPRInfo  = empty
+ppCprInfo ReturnsCPR = ptext SLIT("__M")
+
+instance Outputable CprInfo where
+    ppr = ppCprInfo
+
+instance Show CprInfo where
+    showsPrec p c = showsPrecSDoc p (ppr c)
+#endif
 \end{code}
 
+
 %************************************************************************
 %*                                                                     *
-\subsection[argUsage-IdInfo]{Argument Usage info about an @Id@}
+\subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
 %*                                                                     *
 %************************************************************************
 
-\begin{code}
-data ArgUsageInfo
-  = NoArgUsageInfo
-  | SomeArgUsageInfo ArgUsageType
+If the @Id@ is a lambda-bound variable then it may have lambda-bound
+var info.  Sometimes we know whether the lambda binding this var is a
+``one-shot'' lambda; that is, whether it is applied at most once.
 
-data ArgUsage = ArgUsage Int   -- number of arguments (is linear!)
-             | UnknownArgUsage
-
-type ArgUsageType  = [ArgUsage]                -- c_1 -> ... -> BLOB
-\end{code}
+This information may be useful in optimisation, as computations may
+safely be floated inside such a lambda without risk of duplicating
+work.
 
 \begin{code}
-mkArgUsageInfo [] = NoArgUsageInfo
-mkArgUsageInfo au = SomeArgUsageInfo au
+data LBVarInfo = NoLBVarInfo 
+              | IsOneShotLambda        -- The lambda is applied at most once).
 
-getArgUsage :: ArgUsageInfo -> ArgUsageType
-getArgUsage NoArgUsageInfo       = []
-getArgUsage (SomeArgUsageInfo u)  = u
+seqLBVar l = l `seq` ()
 \end{code}
 
 \begin{code}
-{- UNUSED:
-ppArgUsageInfo NoArgUsageInfo    = empty
-ppArgUsageInfo (SomeArgUsageInfo aut) = (<>) (ptext SLIT("_L_ ")) (ppArgUsageType aut)
--}
-
-ppArgUsage (ArgUsage n)      = int n
-ppArgUsage (UnknownArgUsage) = char '-'
-
-ppArgUsageType aut = hcat
-       [ char '"' ,
-         hcat (punctuate comma (map ppArgUsage aut)),
-         char '"' ]
+hasNoLBVarInfo NoLBVarInfo     = True
+hasNoLBVarInfo IsOneShotLambda = False
+
+noLBVarInfo = NoLBVarInfo
+
+pprLBVarInfo NoLBVarInfo     = empty
+pprLBVarInfo IsOneShotLambda = ptext SLIT("OneShot")
+
+instance Outputable LBVarInfo where
+    ppr = pprLBVarInfo
+
+instance Show LBVarInfo where
+    showsPrec p c = showsPrecSDoc p (ppr c)
 \end{code}
 
 
 %************************************************************************
 %*                                                                     *
-\subsection[FBType-IdInfo]{Type of an expression through Foldr/build's eyes}
+\subsection{Bulk operations on IdInfo}
 %*                                                                     *
 %************************************************************************
 
+@zapLamInfo@ is used for lambda binders that turn out to to be
+part of an unsaturated lambda
+
 \begin{code}
-data FBTypeInfo
-  = NoFBTypeInfo
-  | SomeFBTypeInfo FBType
+zapLamInfo :: IdInfo -> Maybe IdInfo
+zapLamInfo info@(IdInfo {occInfo = occ, newDemandInfo = demand})
+  | is_safe_occ occ && is_safe_dmd demand
+  = Nothing
+  | otherwise
+  = Just (info {occInfo = safe_occ, newDemandInfo = Nothing})
+  where
+       -- The "unsafe" occ info is the ones that say I'm not in a lambda
+       -- because that might not be true for an unsaturated lambda
+    is_safe_occ (OneOcc in_lam _ _) = in_lam
+    is_safe_occ other              = True
 
-data FBType = FBType [FBConsum] FBProd deriving (Eq)
+    safe_occ = case occ of
+                OneOcc _ once int_cxt -> OneOcc insideLam once int_cxt
+                other                 -> occ
 
-data FBConsum = FBGoodConsum | FBBadConsum deriving(Eq)
-data FBProd = FBGoodProd | FBBadProd deriving(Eq)
+    is_safe_dmd Nothing    = True
+    is_safe_dmd (Just dmd) = not (isStrictDmd dmd)
 \end{code}
 
 \begin{code}
-mkFBTypeInfo = SomeFBTypeInfo
-
-getFBType :: FBTypeInfo -> Maybe FBType
-getFBType NoFBTypeInfo       = Nothing
-getFBType (SomeFBTypeInfo u)  = Just u
+zapDemandInfo :: IdInfo -> Maybe IdInfo
+zapDemandInfo info@(IdInfo {newDemandInfo = dmd})
+  | isJust dmd = Just (info {newDemandInfo = Nothing})
+  | otherwise  = Nothing
 \end{code}
 
-\begin{code}
-ppFBTypeInfo NoFBTypeInfo = empty
-ppFBTypeInfo (SomeFBTypeInfo (FBType cons prod))
-      = (<>) (ptext SLIT("_F_ ")) (ppFBType cons prod)
-
-ppFBType cons prod = hcat
-       ([ char '"' ] ++ map ppCons cons ++ [ char '-', ppProd prod, char '"' ])
-  where
-       ppCons FBGoodConsum = char 'G'
-       ppCons FBBadConsum  = char 'B'
-       ppProd FBGoodProd   = char 'G'
-       ppProd FBBadProd    = char 'B'
-\end{code}