%
+% (c) The University of Glasgow 2006
% (c) The GRASP/AQUA Project, Glasgow University, 1997-1998
%
\section[BasicTypes]{Miscellanous types}
#include "HsVersions.h"
-import FastString( FastString )
+import FastString
import Outputable
\end{code}
ppr InfixN = ptext SLIT("infix")
------------------------
-maxPrecedence = (9::Int)
+maxPrecedence :: Int
+maxPrecedence = 9
+defaultFixity :: Fixity
defaultFixity = Fixity maxPrecedence InfixL
negateFixity, funTyFixity :: Fixity
%* *
%************************************************************************
-\begin{code}
+\begin{code}
data RecFlag = Recursive
| NonRecursive
deriving( Eq )
data OccInfo
= NoOccInfo -- Many occurrences, or unknown
- | RulesOnly -- Occurs only in the RHS of one or more rules
-
| IAmDead -- Marks unused variables. Sometimes useful for
-- lambda and case-bound variables.
| IAmALoopBreaker -- Used by the occurrence analyser to mark loop-breakers
-- in a group of recursive definitions
- !Bool -- True <=> This loop breaker occurs only the RHS of a RULE
-\end{code}
-
-Note [RulesOnly]
-~~~~~~~~~~~~~~~~
-The RulesOnly constructor records if an Id occurs only in the RHS of a Rule.
-Similarly, the boolean in IAmLoopbreaker True if the only reason the Id is a
-loop-breaker only because of recursion through a RULE. In that case,
-we can ignore the loop-breaker-ness for inlining purposes. Example
-(from GHC.Enum):
-
- eftInt :: Int# -> Int# -> [Int]
- eftInt x y = ...(non-recursive)...
-
- {-# INLINE [0] eftIntFB #-}
- eftIntFB :: (Int -> r -> r) -> r -> Int# -> Int# -> r
- eftIntFB c n x y = ...(non-recursive)...
+ !RulesOnly -- True <=> This is a weak or rules-only loop breaker
+ -- See OccurAnal Note [Weak loop breakers]
- {-# RULES
- "eftInt" [~1] forall x y. eftInt x y = build (\ c n -> eftIntFB c n x y)
- "eftIntList" [1] eftIntFB (:) [] = eftInt
- #-}
+type RulesOnly = Bool
+\end{code}
-The two look mutually recursive only because of their RULES;
-we don't want that to inhibit inlining!
\begin{code}
isNoOcc :: OccInfo -> Bool
isNoOcc NoOccInfo = True
-isNoOcc other = False
+isNoOcc _ = False
seqOccInfo :: OccInfo -> ()
seqOccInfo occ = occ `seq` ()
type InsideLam = Bool -- True <=> Occurs inside a non-linear lambda
-- Substituting a redex for this occurrence is
-- dangerous because it might duplicate work.
+insideLam, notInsideLam :: InsideLam
insideLam = True
notInsideLam = False
-----------------
type OneBranch = Bool -- True <=> Occurs in only one case branch
-- so no code-duplication issue to worry about
+oneBranch, notOneBranch :: OneBranch
oneBranch = True
notOneBranch = False
isLoopBreaker :: OccInfo -> Bool
isLoopBreaker (IAmALoopBreaker _) = True
-isLoopBreaker other = False
+isLoopBreaker _ = False
isNonRuleLoopBreaker :: OccInfo -> Bool
-isNonRuleLoopBreaker (IAmALoopBreaker False) = True -- Loop-breaker that breaks a non-rule cycle
-isNonRuleLoopBreaker other = False
+isNonRuleLoopBreaker (IAmALoopBreaker False) = True -- Loop-breaker that breaks a non-rule cycle
+isNonRuleLoopBreaker _ = False
isDeadOcc :: OccInfo -> Bool
isDeadOcc IAmDead = True
-isDeadOcc other = False
+isDeadOcc _ = False
+isOneOcc :: OccInfo -> Bool
isOneOcc (OneOcc _ _ _) = True
-isOneOcc other = False
+isOneOcc _ = False
isFragileOcc :: OccInfo -> Bool
isFragileOcc (OneOcc _ _ _) = True
-isFragileOcc other = False
+isFragileOcc _ = False
\end{code}
\begin{code}
instance Outputable OccInfo where
-- only used for debugging; never parsed. KSW 1999-07
ppr NoOccInfo = empty
- ppr RulesOnly = ptext SLIT("RulesOnly")
ppr (IAmALoopBreaker ro) = ptext SLIT("LoopBreaker") <> if ro then char '!' else empty
ppr IAmDead = ptext SLIT("Dead")
ppr (OneOcc inside_lam one_branch int_cxt)
| NotMarkedStrict
deriving( Eq )
+isMarkedUnboxed :: StrictnessMark -> Bool
isMarkedUnboxed MarkedUnboxed = True
-isMarkedUnboxed other = False
+isMarkedUnboxed _ = False
+isMarkedStrict :: StrictnessMark -> Bool
isMarkedStrict NotMarkedStrict = False
-isMarkedStrict other = True -- All others are strict
+isMarkedStrict _ = True -- All others are strict
instance Outputable StrictnessMark where
ppr MarkedStrict = ptext SLIT("!")
\begin{code}
data SuccessFlag = Succeeded | Failed
+instance Outputable SuccessFlag where
+ ppr Succeeded = ptext SLIT("Succeeded")
+ ppr Failed = ptext SLIT("Failed")
+
successIf :: Bool -> SuccessFlag
successIf True = Succeeded
successIf False = Failed
-- is enabled, it will definitely actually happen
deriving( Eq )
+defaultInlineSpec, alwaysInlineSpec, neverInlineSpec :: InlineSpec
+
defaultInlineSpec = Inline AlwaysActive False -- Inlining is OK, but not forced
alwaysInlineSpec = Inline AlwaysActive True -- INLINE always
neverInlineSpec = Inline NeverActive False -- NOINLINE
instance Outputable Activation where
- ppr AlwaysActive = empty -- The default
+ ppr NeverActive = ptext SLIT("NEVER")
+ ppr AlwaysActive = ptext SLIT("ALWAYS")
ppr (ActiveBefore n) = brackets (char '~' <> int n)
ppr (ActiveAfter n) = brackets (int n)
- ppr NeverActive = ptext SLIT("NEVER")
instance Outputable InlineSpec where
- ppr (Inline act True) = ptext SLIT("INLINE") <> ppr act
- ppr (Inline act False) = ptext SLIT("NOINLINE") <> ppr act
+ ppr (Inline act is_inline)
+ | is_inline = ptext SLIT("INLINE")
+ <> case act of
+ AlwaysActive -> empty
+ _ -> ppr act
+ | otherwise = ptext SLIT("NOINLINE")
+ <> case act of
+ NeverActive -> empty
+ _ -> ppr act
isActive :: CompilerPhase -> Activation -> Bool
-isActive p NeverActive = False
-isActive p AlwaysActive = True
+isActive _ NeverActive = False
+isActive _ AlwaysActive = True
isActive p (ActiveAfter n) = p <= n
isActive p (ActiveBefore n) = p > n
isNeverActive, isAlwaysActive :: Activation -> Bool
isNeverActive NeverActive = True
-isNeverActive act = False
+isNeverActive _ = False
isAlwaysActive AlwaysActive = True
-isAlwaysActive other = False
+isAlwaysActive _ = False
\end{code}
projects / ghc-hetmet.git / blobdiff