GlobalIdDetails(..), notGlobalId, -- Not abstract
IdInfo, -- Abstract
- vanillaIdInfo, noCafIdInfo, hasCafIdInfo,
+ vanillaIdInfo, noCafIdInfo,
seqIdInfo, megaSeqIdInfo,
-- Zapping
-- New demand and strictness info
newStrictnessInfo, setNewStrictnessInfo,
newDemandInfo, setNewDemandInfo, pprNewStrictness,
+ setAllStrictnessInfo,
+#ifdef OLD_STRICTNESS
-- Strictness; imported from Demand
StrictnessInfo(..),
mkStrictnessInfo, noStrictnessInfo,
ppStrictnessInfo,isBottomingStrictness,
- setAllStrictnessInfo,
+#endif
-- Worker
WorkerInfo(..), workerExists, wrapperArity, workerId,
-- Specialisation
specInfo, setSpecInfo,
- -- CG info
- CgInfo(..), cgInfo, setCgInfo, pprCgInfo,
- cgCafInfo, vanillaCgInfo,
- CgInfoEnv, lookupCgInfo,
-
-- CAF info
- CafInfo(..), ppCafInfo, setCafInfo, mayHaveCafRefs,
+ CafInfo(..), cafInfo, ppCafInfo, setCafInfo, mayHaveCafRefs,
-- Lambda-bound variable info
LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
import CoreSyn
-import Type ( Type )
+import Class ( Class )
import PrimOp ( PrimOp )
-import NameEnv ( NameEnv, lookupNameEnv )
-import Name ( Name )
import Var ( Id )
import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
InsideLam, insideLam, notInsideLam,
Activation(..)
)
import DataCon ( DataCon )
+import TyCon ( TyCon, FieldLabel )
import ForeignCall ( ForeignCall )
-import FieldLabel ( FieldLabel )
-import Demand hiding( Demand, seqDemand )
-import qualified Demand
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
`setWorkerInfo`,
`setLBVarInfo`,
`setOccInfo`,
- `setCgInfo`,
`setCafInfo`,
`setNewStrictnessInfo`,
`setAllStrictnessInfo`,
data GlobalIdDetails
= VanillaGlobal -- Imported from elsewhere, a default method Id.
- | RecordSelId FieldLabel -- The Id for a record selector
+ | RecordSelId TyCon FieldLabel -- The Id for a record selector
+
| 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
-- b) when typechecking a pattern 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
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]")
+ ppr (RecordSelId _ _) = ptext SLIT("[RecSel]")
\end{code}
#endif
workerInfo :: WorkerInfo, -- Pointer to Worker Function
unfoldingInfo :: Unfolding, -- Its unfolding
- cgInfo :: CgInfo, -- Code generator info (arity, CAF info)
+ cafInfo :: CafInfo, -- CAF info
lbvarInfo :: LBVarInfo, -- Info about a lambda-bound variable
inlinePragInfo :: InlinePragInfo, -- Inline pragma
occInfo :: OccInfo, -- How it occurs
seqCpr (cprInfo info) `seq`
#endif
--- CgInfo is involved in a loop, so we have to be careful not to seq it
--- too early.
--- seqCg (cgInfo info) `seq`
- seqLBVar (lbvarInfo info) `seq`
+ seqCaf (cafInfo info) `seq`
+ seqLBVar (lbvarInfo info) `seq`
seqOccInfo (occInfo info)
\end{code}
info { unfoldingInfo = uf } -- (In this case the demand-zapping is redundant.)
setUnfoldingInfo info uf
- | isEvaldUnfolding uf
- -- If the unfolding is a value, the demand info may
- -- go pear-shaped, so we nuke it. Example:
- -- let x = (a,b) in
- -- case x of (p,q) -> h p q x
- -- Here x is certainly demanded. But after we've nuked
- -- the case, we'll get just
- -- let x = (a,b) in h a b x
- -- and now x is not demanded (I'm assuming h is lazy)
- -- This really happens. The solution here is a bit ad hoc...
- = info { unfoldingInfo = uf, newDemandInfo = Nothing }
-
- | otherwise
-- We do *not* seq on the unfolding info, For some reason, doing so
-- actually increases residency significantly.
= info { unfoldingInfo = uf }
setCprInfo info cp = info { cprInfo = cp }
#endif
-setArityInfo info ar = info { arityInfo = ar }
-setCgInfo info cg = info { cgInfo = cg }
+setArityInfo info ar = info { arityInfo = ar }
+setCafInfo info caf = info { cafInfo = caf }
setLBVarInfo info lb = {-lb `seq`-} info { lbvarInfo = lb }
vanillaIdInfo :: IdInfo
vanillaIdInfo
= IdInfo {
- cgInfo = noCgInfo,
+ cafInfo = vanillaCafInfo,
arityInfo = unknownArity,
#ifdef OLD_STRICTNESS
cprInfo = NoCPRInfo,
newStrictnessInfo = Nothing
}
-hasCafIdInfo = vanillaIdInfo `setCgInfo` CgInfo MayHaveCafRefs
-noCafIdInfo = vanillaIdInfo `setCgInfo` CgInfo NoCafRefs
+noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
-- Used for built-in type Ids in MkId.
- -- These must have a valid CgInfo set, so you can't
- -- use vanillaIdInfo!
\end{code}
data WorkerInfo = NoWorker
| HasWorker Id Arity
-- The Arity is the arity of the *wrapper* at the moment of the
- -- w/w split. See comments in MkIface.ifaceId, with the 'Worker' code.
+ -- w/w split. See notes above.
seqWorker :: WorkerInfo -> ()
seqWorker (HasWorker id a) = id `seq` a `seq` ()
%* *
%************************************************************************
-CgInfo encapsulates calling-convention information produced by the code
-generator. It is pasted into the IdInfo of each emitted Id by CoreTidy,
-but only as a thunk --- the information is only actually produced further
-downstream, by the code generator.
-
\begin{code}
-#ifndef OLD_STRICTNESS
-newtype CgInfo = CgInfo CafInfo -- We are back to only having CafRefs in CgInfo
-noCgInfo = panic "NoCgInfo!"
-#else
-data CgInfo = CgInfo CafInfo
- | NoCgInfo -- In debug mode we don't want a black hole here
- -- See Id.idCgInfo
- -- noCgInfo is used for local Ids, which shouldn't need any CgInfo
-noCgInfo = NoCgInfo
-#endif
-
-cgCafInfo (CgInfo caf_info) = caf_info
-
-setCafInfo info caf_info = info `setCgInfo` CgInfo caf_info
-
-seqCg c = c `seq` () -- fields are strict anyhow
-
-vanillaCgInfo = CgInfo MayHaveCafRefs -- Definitely safe
-
-- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
data CafInfo
| NoCafRefs -- A function or static constructor
-- that refers to no CAFs.
+vanillaCafInfo = MayHaveCafRefs -- Definitely safe
+
mayHaveCafRefs MayHaveCafRefs = True
mayHaveCafRefs _ = False
seqCaf c = c `seq` ()
-pprCgInfo (CgInfo caf_info) = ppCafInfo caf_info
-
-ppArity 0 = empty
-ppArity n = hsep [ptext SLIT("__A"), int n]
-
-ppCafInfo NoCafRefs = ptext SLIT("__C")
+ppCafInfo NoCafRefs = ptext SLIT("NoCafRefs")
ppCafInfo MayHaveCafRefs = empty
\end{code}
-\begin{code}
-type CgInfoEnv = NameEnv CgInfo
-
-lookupCgInfo :: NameEnv CgInfo -> Name -> CgInfo
-lookupCgInfo env n = case lookupNameEnv env n of
- Just info -> info
- Nothing -> pprTrace "Urk! Not in CgInfo env" (ppr n) vanillaCgInfo
-\end{code}
-
-
%************************************************************************
%* *
\subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
projects / ghc-hetmet.git / blobdiff