X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2FbasicTypes%2FBasicTypes.lhs;h=fad6533144b2003ed16dc47a3d18cafe7ff61a07;hp=35c57f36f34a1eb6ba014c89dea65c968fe58eec;hb=4bc25e8c30559b7a6a87b39afcc79340ae778788;hpb=e68a891932d615590d9b1ab5752ada8142db5053 diff --git a/compiler/basicTypes/BasicTypes.lhs b/compiler/basicTypes/BasicTypes.lhs index 35c57f3..fad6533 100644 --- a/compiler/basicTypes/BasicTypes.lhs +++ b/compiler/basicTypes/BasicTypes.lhs @@ -18,8 +18,10 @@ module BasicTypes( Version, bumpVersion, initialVersion, Arity, + + FunctionOrData(..), - DeprecTxt, + WarningTxt(..), Fixity(..), FixityDirection(..), defaultFixity, maxPrecedence, @@ -30,6 +32,8 @@ module BasicTypes( RecFlag(..), isRec, isNonRec, boolToRecFlag, + RuleName, + TopLevelFlag(..), isTopLevel, isNotTopLevel, OverlapFlag(..), @@ -51,14 +55,16 @@ module BasicTypes( CompilerPhase, Activation(..), isActive, isNeverActive, isAlwaysActive, + RuleMatchInfo(..), isConLike, isFunLike, + InlinePragma(..), defaultInlinePragma, isDefaultInlinePragma, + inlinePragmaActivation, inlinePragmaRuleMatchInfo, + setInlinePragmaActivation, setInlinePragmaRuleMatchInfo, InlineSpec(..), defaultInlineSpec, alwaysInlineSpec, neverInlineSpec, SuccessFlag(..), succeeded, failed, successIf ) where -#include "HsVersions.h" - -import FastString( FastString ) +import FastString import Outputable \end{code} @@ -72,6 +78,21 @@ import Outputable type Arity = Int \end{code} +%************************************************************************ +%* * +\subsection[FunctionOrData]{FunctionOrData} +%* * +%************************************************************************ + +\begin{code} +data FunctionOrData = IsFunction | IsData + deriving (Eq, Ord) + +instance Outputable FunctionOrData where + ppr IsFunction = text "(function)" + ppr IsData = text "(data)" +\end{code} + %************************************************************************ %* * @@ -97,7 +118,14 @@ initialVersion = 1 \begin{code} -type DeprecTxt = FastString -- reason/explanation for deprecation +-- reason/explanation from a WARNING or DEPRECATED pragma +data WarningTxt = WarningTxt FastString + | DeprecatedTxt FastString + deriving Eq + +instance Outputable WarningTxt where + ppr (WarningTxt w) = doubleQuotes (ftext w) + ppr (DeprecatedTxt d) = text "Deprecated:" <+> doubleQuotes (ftext d) \end{code} %************************************************************************ @@ -124,6 +152,15 @@ instance Outputable name => Outputable (IPName name) where ppr (IPName n) = char '?' <> ppr n -- Ordinary implicit parameters \end{code} +%************************************************************************ +%* * + Rules +%* * +%************************************************************************ + +\begin{code} +type RuleName = FastString +\end{code} %************************************************************************ %* * @@ -146,12 +183,14 @@ data FixityDirection = InfixL | InfixR | InfixN deriving(Eq) instance Outputable FixityDirection where - ppr InfixL = ptext SLIT("infixl") - ppr InfixR = ptext SLIT("infixr") - ppr InfixN = ptext SLIT("infix") + ppr InfixL = ptext (sLit "infixl") + ppr InfixR = ptext (sLit "infixr") + ppr InfixN = ptext (sLit "infix") ------------------------ -maxPrecedence = (9::Int) +maxPrecedence :: Int +maxPrecedence = 9 +defaultFixity :: Fixity defaultFixity = Fixity maxPrecedence InfixL negateFixity, funTyFixity :: Fixity @@ -207,8 +246,8 @@ isTopLevel TopLevel = True isTopLevel NotTopLevel = False instance Outputable TopLevelFlag where - ppr TopLevel = ptext SLIT("") - ppr NotTopLevel = ptext SLIT("") + ppr TopLevel = ptext (sLit "") + ppr NotTopLevel = ptext (sLit "") \end{code} @@ -254,8 +293,8 @@ boolToRecFlag True = Recursive boolToRecFlag False = NonRecursive instance Outputable RecFlag where - ppr Recursive = ptext SLIT("Recursive") - ppr NonRecursive = ptext SLIT("NonRecursive") + ppr Recursive = ptext (sLit "Recursive") + ppr NonRecursive = ptext (sLit "NonRecursive") \end{code} %************************************************************************ @@ -294,8 +333,8 @@ data OverlapFlag instance Outputable OverlapFlag where ppr NoOverlap = empty - ppr OverlapOk = ptext SLIT("[overlap ok]") - ppr Incoherent = ptext SLIT("[incoherent]") + ppr OverlapOk = ptext (sLit "[overlap ok]") + ppr Incoherent = ptext (sLit "[incoherent]") \end{code} @@ -313,7 +352,7 @@ instance Eq TupCon where tupleParens :: Boxity -> SDoc -> SDoc tupleParens Boxed p = parens p -tupleParens Unboxed p = ptext SLIT("(#") <+> p <+> ptext SLIT("#)") +tupleParens Unboxed p = ptext (sLit "(#") <+> p <+> ptext (sLit "#)") \end{code} %************************************************************************ @@ -365,32 +404,45 @@ the base of the module hierarchy. So it seemed simpler to put the defn of OccInfo here, safely at the bottom \begin{code} +-- | Identifier occurrence information data OccInfo - = NoOccInfo -- Many occurrences, or unknown + = NoOccInfo -- ^ There are many occurrences, or unknown occurences - | IAmDead -- Marks unused variables. Sometimes useful for + | IAmDead -- ^ Marks unused variables. Sometimes useful for -- lambda and case-bound variables. - | OneOcc -- Occurs exactly once, not inside a rule + | OneOcc !InsideLam !OneBranch - !InterestingCxt + !InterestingCxt -- ^ Occurs exactly once, not inside a rule - | IAmALoopBreaker -- Used by the occurrence analyser to mark loop-breakers - -- in a group of recursive definitions - !RulesOnly -- True <=> This loop breaker mentions the other binders - -- in its recursive group only in its RULES, not - -- in its rhs - -- See OccurAnal Note [RulesOnly] + -- | This identifier breaks a loop of mutually recursive functions. The field + -- marks whether it is only a loop breaker due to a reference in a rule + | IAmALoopBreaker -- Note [LoopBreaker OccInfo] + !RulesOnly -- True <=> This is a weak or rules-only loop breaker + -- See OccurAnal Note [Weak loop breakers] type RulesOnly = Bool \end{code} +Note [LoopBreaker OccInfo] +~~~~~~~~~~~~~~~~~~~~~~~~~~ +An OccInfo of (IAmLoopBreaker False) is used by the occurrence +analyser in two ways: + (a) to mark loop-breakers in a group of recursive + definitions (hence the name) + (b) to mark binders that must not be inlined in this phase + (perhaps it has a NOINLINE pragma) +Things with (IAmLoopBreaker False) do not get an unfolding +pinned on to them, so they are completely opaque. + +See OccurAnal Note [Weak loop breakers] for (IAmLoopBreaker True). + \begin{code} isNoOcc :: OccInfo -> Bool isNoOcc NoOccInfo = True -isNoOcc other = False +isNoOcc _ = False seqOccInfo :: OccInfo -> () seqOccInfo occ = occ `seq` () @@ -404,43 +456,46 @@ type InterestingCxt = Bool -- True <=> Function: is applied 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 (IAmALoopBreaker ro) = ptext SLIT("LoopBreaker") <> if ro then char '!' else empty - ppr IAmDead = ptext SLIT("Dead") + 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) - = ptext SLIT("Once") <> pp_lam <> pp_br <> pp_args + = ptext (sLit "Once") <> pp_lam <> pp_br <> pp_args where pp_lam | inside_lam = char 'L' | otherwise = empty @@ -469,16 +524,18 @@ data StrictnessMark -- Used in interface decls only | 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("!") - ppr MarkedUnboxed = ptext SLIT("!!") - ppr NotMarkedStrict = ptext SLIT("_") + ppr MarkedStrict = ptext (sLit "!") + ppr MarkedUnboxed = ptext (sLit "!!") + ppr NotMarkedStrict = ptext (sLit "_") \end{code} @@ -491,6 +548,10 @@ instance Outputable StrictnessMark where \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 @@ -523,38 +584,106 @@ data Activation = NeverActive | ActiveAfter CompilerPhase -- Active in this phase and later deriving( Eq ) -- Eq used in comparing rules in HsDecls +data RuleMatchInfo = ConLike + | FunLike + deriving( Eq ) + +isConLike :: RuleMatchInfo -> Bool +isConLike ConLike = True +isConLike _ = False + +isFunLike :: RuleMatchInfo -> Bool +isFunLike FunLike = True +isFunLike _ = False + +data InlinePragma + = InlinePragma + Activation -- Says during which phases inlining is allowed + RuleMatchInfo -- Should the function be treated like a constructor? + deriving( Eq ) + +defaultInlinePragma :: InlinePragma +defaultInlinePragma = InlinePragma AlwaysActive FunLike + +isDefaultInlinePragma :: InlinePragma -> Bool +isDefaultInlinePragma (InlinePragma activation match_info) + = isAlwaysActive activation && isFunLike match_info + +inlinePragmaActivation :: InlinePragma -> Activation +inlinePragmaActivation (InlinePragma activation _) = activation + +inlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo +inlinePragmaRuleMatchInfo (InlinePragma _ info) = info + +setInlinePragmaActivation :: InlinePragma -> Activation -> InlinePragma +setInlinePragmaActivation (InlinePragma _ info) activation + = InlinePragma activation info + +setInlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo -> InlinePragma +setInlinePragmaRuleMatchInfo (InlinePragma activation _) info + = InlinePragma activation info + data InlineSpec - = Inline - Activation -- Says during which phases inlining is allowed - Bool -- True <=> make the RHS look small, so that when inlining - -- is enabled, it will definitely actually happen + = Inline + InlinePragma + Bool -- True <=> INLINE + -- False <=> NOINLINE deriving( Eq ) -defaultInlineSpec = Inline AlwaysActive False -- Inlining is OK, but not forced -alwaysInlineSpec = Inline AlwaysActive True -- INLINE always -neverInlineSpec = Inline NeverActive False -- NOINLINE +defaultInlineSpec :: InlineSpec +alwaysInlineSpec, neverInlineSpec :: RuleMatchInfo -> InlineSpec + +defaultInlineSpec = Inline defaultInlinePragma False + -- Inlining is OK, but not forced +alwaysInlineSpec match_info + = Inline (InlinePragma AlwaysActive match_info) True + -- INLINE always +neverInlineSpec match_info + = Inline (InlinePragma NeverActive match_info) 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 RuleMatchInfo where + ppr ConLike = ptext (sLit "CONLIKE") + ppr FunLike = ptext (sLit "FUNLIKE") + +instance Outputable InlinePragma where + ppr (InlinePragma activation FunLike) + = ppr activation + ppr (InlinePragma activation match_info) + = ppr match_info <+> ppr activation instance Outputable InlineSpec where - ppr (Inline act True) = ptext SLIT("INLINE") <> ppr act - ppr (Inline act False) = ptext SLIT("NOINLINE") <> ppr act + ppr (Inline (InlinePragma act match_info) is_inline) + | is_inline = ptext (sLit "INLINE") + <+> ppr_match_info + <+> case act of + AlwaysActive -> empty + _ -> ppr act + | otherwise = ptext (sLit "NOINLINE") + <+> ppr_match_info + <+> case act of + NeverActive -> empty + _ -> ppr act + where + ppr_match_info = if isFunLike match_info then empty else ppr match_info 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}