shortableIdInfo, copyIdInfo,
-- Arity
- ArityInfo(..),
- exactArity, atLeastArity, unknownArity, hasArity,
+ ArityInfo,
+ exactArity, unknownArity, hasArity,
arityInfo, setArityInfo, ppArityInfo, arityLowerBound,
-- New demand and strictness info
newStrictnessInfo, setNewStrictnessInfo, mkNewStrictnessInfo,
- newDemandInfo, setNewDemandInfo, newDemand,
+ newDemandInfo, setNewDemandInfo, newDemand, oldDemand,
-- Strictness; imported from Demand
StrictnessInfo(..),
import ForeignCall ( ForeignCall )
import FieldLabel ( FieldLabel )
import Type ( usOnce, usMany )
-import Demand -- Lots of stuff
-import qualified NewDemand
+import Demand hiding( Demand )
+import qualified Demand
+import NewDemand ( Demand(..), Keepity(..), Deferredness(..), DmdResult(..),
+ lazyDmd, topDmd,
+ StrictSig, mkStrictSig,
+ DmdType, mkTopDmdType
+ )
import Outputable
import Util ( seqList )
import List ( replicate )
To be removed later
\begin{code}
-mkNewStrictnessInfo :: Id -> Arity -> StrictnessInfo -> CprInfo -> NewDemand.StrictSig
-mkNewStrictnessInfo id arity NoStrictnessInfo cpr
- = NewDemand.mkStrictSig id
- arity
- (NewDemand.mkTopDmdType (replicate arity NewDemand.Lazy) (newRes False cpr))
-
-mkNewStrictnessInfo id arity (StrictnessInfo ds res) cpr
- = NewDemand.mkStrictSig id
- arity
- (NewDemand.mkTopDmdType (take arity (map newDemand ds)) (newRes res cpr))
+mkNewStrictnessInfo :: Id -> Arity -> Demand.StrictnessInfo -> CprInfo -> StrictSig
+mkNewStrictnessInfo id arity Demand.NoStrictnessInfo cpr
+ = mkStrictSig id arity $
+ mkTopDmdType (replicate arity lazyDmd) (newRes False cpr)
+
+mkNewStrictnessInfo id arity (Demand.StrictnessInfo ds res) cpr
+ = mkStrictSig id arity $
+ mkTopDmdType (take arity (map newDemand ds)) (newRes res cpr)
-- Sometimes the old strictness analyser has more
-- demands than the arity justifies
-newRes True _ = NewDemand.BotRes
-newRes False ReturnsCPR = NewDemand.RetCPR
-newRes False NoCPRInfo = NewDemand.TopRes
-
-newDemand :: Demand -> NewDemand.Demand
-newDemand (WwLazy True) = NewDemand.Abs
-newDemand (WwLazy False) = NewDemand.Lazy
-newDemand WwStrict = NewDemand.Eval
-newDemand (WwUnpack unpk ds) = NewDemand.Seq NewDemand.Drop NewDemand.Now (map newDemand ds)
-newDemand WwPrim = NewDemand.Lazy
-newDemand WwEnum = NewDemand.Eval
+newRes True _ = BotRes
+newRes False ReturnsCPR = RetCPR
+newRes False NoCPRInfo = TopRes
+
+newDemand :: Demand.Demand -> NewDemand.Demand
+newDemand (WwLazy True) = Abs
+newDemand (WwLazy False) = Lazy
+newDemand WwStrict = Eval
+newDemand (WwUnpack unpk ds) = Seq Drop Now (map newDemand ds)
+newDemand WwPrim = Lazy
+newDemand WwEnum = Eval
+
+oldDemand :: NewDemand.Demand -> Demand.Demand
+oldDemand Abs = WwLazy True
+oldDemand Lazy = WwLazy False
+oldDemand Bot = WwStrict
+oldDemand Err = WwStrict
+oldDemand Eval = WwStrict
+oldDemand (Seq _ _ ds) = WwUnpack True (map oldDemand ds)
+oldDemand (Call _) = WwStrict
\end{code}
data IdInfo
= IdInfo {
arityInfo :: ArityInfo, -- Its arity
- demandInfo :: Demand, -- Whether or not it is definitely demanded
+ demandInfo :: Demand.Demand, -- Whether or not it is definitely demanded
specInfo :: CoreRules, -- Specialisations of this function which exist
tyGenInfo :: TyGenInfo, -- Restrictions on usage-generalisation of this Id
strictnessInfo :: StrictnessInfo, -- Strictness properties
inlinePragInfo :: InlinePragInfo, -- Inline pragma
occInfo :: OccInfo, -- How it occurs
- newStrictnessInfo :: Maybe NewDemand.StrictSig,
- newDemandInfo :: NewDemand.Demand
+ newStrictnessInfo :: Maybe StrictSig,
+ newDemandInfo :: Demand
}
seqIdInfo :: IdInfo -> ()
= info { unfoldingInfo = uf }
setDemandInfo info dd = info { demandInfo = dd }
-setArityInfo info ar = info { arityInfo = ar }
+setArityInfo info ar = info { arityInfo = Just ar }
setCgInfo info cg = info { cgInfo = cg }
setCprInfo info cp = info { cprInfo = cp }
setLBVarInfo info lb = info { lbvarInfo = lb }
setNewDemandInfo info dd = info { newDemandInfo = dd }
-setNewStrictnessInfo info dd = info { newStrictnessInfo = Just dd }
+setNewStrictnessInfo info dd = info { newStrictnessInfo = dd }
\end{code}
vanillaIdInfo
= IdInfo {
cgInfo = noCgInfo,
- arityInfo = UnknownArity,
+ arityInfo = unknownArity,
demandInfo = wwLazy,
specInfo = emptyCoreRules,
tyGenInfo = noTyGenInfo,
lbvarInfo = NoLBVarInfo,
inlinePragInfo = NoInlinePragInfo,
occInfo = NoOccInfo,
- newDemandInfo = NewDemand.topDmd,
+ newDemandInfo = topDmd,
newStrictnessInfo = Nothing
}
besides the code-generator need arity info!)
\begin{code}
-data ArityInfo
- = UnknownArity -- No idea
-
- | ArityExactly Arity -- Arity is exactly this. We use this when importing a
- -- function; it's already been compiled and we know its
- -- arity for sure.
+type ArityInfo = Maybe 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.
- | ArityAtLeast 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.
-
- -- functions in the module being compiled. Their arity
- -- might increase later in the compilation process, if
- -- an extra lambda floats up to the binding site.
- deriving( Eq )
+ -- The arity might increase later in the compilation process, if
+ -- an extra lambda floats up to the binding site.
seqArity :: ArityInfo -> ()
seqArity a = arityLowerBound a `seq` ()
-exactArity = ArityExactly
-atLeastArity = ArityAtLeast
-unknownArity = UnknownArity
+exactArity = Just
+unknownArity = Nothing
arityLowerBound :: ArityInfo -> Arity
-arityLowerBound UnknownArity = 0
-arityLowerBound (ArityAtLeast n) = n
-arityLowerBound (ArityExactly n) = n
+arityLowerBound Nothing = 0
+arityLowerBound (Just n) = n
hasArity :: ArityInfo -> Bool
-hasArity UnknownArity = False
-hasArity other = True
+hasArity Nothing = False
+hasArity other = True
-ppArityInfo UnknownArity = empty
-ppArityInfo (ArityExactly arity) = hsep [ptext SLIT("ArityExactly"), int arity]
-ppArityInfo (ArityAtLeast arity) = hsep [ptext SLIT("ArityAtLeast"), int arity]
+ppArityInfo Nothing = empty
+ppArityInfo (Just arity) = hsep [ptext SLIT("Arity"), int arity]
\end{code}
%************************************************************************
projects / ghc-hetmet.git / blobdiff