floatOutLambdas :: Maybe Int
Just n = float lambdas to top level, if doing so will abstract over n or fewer value variables Nothing = float all lambdas to top level, regardless of how many free variables Just 0 is the vanilla case: float a lambda iff it has no free vars
floatOutConstants :: Bool
True = float constants to top level, even if they do not escape a lambda
floatOutOverSatApps :: Bool
True = float out over-saturated applications based on arity information. See Note [Floating over-saturated applications] in GHC.Core.Opt.SetLevels
floatToTopLevelOnly :: Bool
Allow floating to the top level only.

Instances

Instances details

Outputable FloatOutSwitches Source #
Instance details Defined in GHC.Core.Opt.Monad Methods ppr :: FloatOutSwitches -> SDoc Source #

pprPassDetails :: CoreToDo -> SDoc Source #

Plugins

type CorePluginPass = ModGuts -> CoreM ModGuts Source #

A description of the plugin pass itself

bindsOnlyPass :: (CoreProgram -> CoreM CoreProgram) -> ModGuts -> CoreM ModGuts Source #

Counting

data SimplCount Source #

doSimplTick :: DynFlags -> Tick -> SimplCount -> SimplCount Source #

doFreeSimplTick :: Tick -> SimplCount -> SimplCount Source #

simplCountN :: SimplCount -> Int Source #

pprSimplCount :: SimplCount -> SDoc Source #

plusSimplCount :: SimplCount -> SimplCount -> SimplCount Source #

zeroSimplCount :: DynFlags -> SimplCount Source #

isZeroSimplCount :: SimplCount -> Bool Source #

hasDetailedCounts :: SimplCount -> Bool Source #

data Tick Source #

Instances

Instances details

Outputable Tick Source #
Instance details Defined in GHC.Core.Opt.Monad Methods ppr :: Tick -> SDoc Source #
Eq Tick Source #
Instance details Defined in GHC.Core.Opt.Monad Methods (==) :: Tick -> Tick -> Bool # (/=) :: Tick -> Tick -> Bool #
Ord Tick Source #
Instance details Defined in GHC.Core.Opt.Monad Methods compare :: Tick -> Tick -> Ordering # (<) :: Tick -> Tick -> Bool # (<=) :: Tick -> Tick -> Bool # (>) :: Tick -> Tick -> Bool # (>=) :: Tick -> Tick -> Bool # max :: Tick -> Tick -> Tick # min :: Tick -> Tick -> Tick #

The monad

data CoreM a Source #

The monad used by Core-to-Core passes to register simplification statistics. Also used to have common state (in the form of UniqueSupply) for generating Uniques.

Instances

Instances details

MonadIO CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods liftIO :: IO a -> CoreM a Source #
Alternative CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods empty :: CoreM a Source # (<\|>) :: CoreM a -> CoreM a -> CoreM a Source # some :: CoreM a -> CoreM [a] Source # many :: CoreM a -> CoreM [a] Source #
Applicative CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods pure :: a -> CoreM a Source # (<>) :: CoreM (a -> b) -> CoreM a -> CoreM b Source # liftA2 :: (a -> b -> c) -> CoreM a -> CoreM b -> CoreM c Source # (>) :: CoreM a -> CoreM b -> CoreM b Source # (<*) :: CoreM a -> CoreM b -> CoreM a Source #
Functor CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods fmap :: (a -> b) -> CoreM a -> CoreM b Source # (<$) :: a -> CoreM b -> CoreM a Source #
Monad CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods (>>=) :: CoreM a -> (a -> CoreM b) -> CoreM b Source # (>>) :: CoreM a -> CoreM b -> CoreM b Source # return :: a -> CoreM a Source #
MonadPlus CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods mzero :: CoreM a Source # mplus :: CoreM a -> CoreM a -> CoreM a Source #
HasDynFlags CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods getDynFlags :: CoreM DynFlags Source #
MonadThings CoreM Source #
Instance details Defined in GHC.Plugins Methods lookupThing :: Name -> CoreM TyThing Source # lookupId :: Name -> CoreM Id Source # lookupDataCon :: Name -> CoreM DataCon Source # lookupTyCon :: Name -> CoreM TyCon Source #
MonadUnique CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods getUniqueSupplyM :: CoreM UniqSupply Source # getUniqueM :: CoreM Unique Source # getUniquesM :: CoreM [Unique] Source #
HasModule CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods getModule :: CoreM Module Source #
HasLogger CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods getLogger :: CoreM Logger Source #

runCoreM Source #

Arguments

:: HscEnv
-> RuleBase
-> Char	Mask
-> Module
-> ModuleSet
-> PrintUnqualified
-> SrcSpan
-> CoreM a
-> IO (a, SimplCount)

Reading from the monad

getHscEnv :: CoreM HscEnv Source #

getRuleBase :: CoreM RuleBase Source #

getModule :: HasModule m => m Module Source #

getDynFlags :: HasDynFlags m => m DynFlags Source #

getPackageFamInstEnv :: CoreM PackageFamInstEnv Source #

getVisibleOrphanMods :: CoreM ModuleSet Source #

getUniqMask :: CoreM Char Source #

getPrintUnqualified :: CoreM PrintUnqualified Source #

getSrcSpanM :: CoreM SrcSpan Source #

Writing to the monad

addSimplCount :: SimplCount -> CoreM () Source #

Lifting into the monad

liftIO :: MonadIO m => IO a -> m a Source #

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

Expand

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

liftIOWithCount :: IO (SimplCount, a) -> CoreM a Source #

Lift an IO operation into CoreM while consuming its SimplCount

Dealing with annotations

getAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv [a], NameEnv [a]) Source #

Get all annotations of a given type. This happens lazily, that is no deserialization will take place until the [a] is actually demanded and the [a] can also be empty (the UniqFM is not filtered).

This should be done once at the start of a Core-to-Core pass that uses annotations.

See Note [Annotations]

getFirstAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv a, NameEnv a) Source #

Get at most one annotation of a given type per annotatable item.

Screen output

putMsg :: SDoc -> CoreM () Source #

Output a message to the screen

putMsgS :: String -> CoreM () Source #

Output a String message to the screen

errorMsg :: SDoc -> CoreM () Source #

Output an error to the screen. Does not cause the compiler to die.

errorMsgS :: String -> CoreM () Source #

Output an error to the screen. Does not cause the compiler to die.

warnMsg :: WarnReason -> SDoc -> CoreM () Source #

fatalErrorMsg :: SDoc -> CoreM () Source #

Output a fatal error to the screen. Does not cause the compiler to die.

fatalErrorMsgS :: String -> CoreM () Source #

Output a fatal error to the screen. Does not cause the compiler to die.

debugTraceMsg :: SDoc -> CoreM () Source #

Outputs a debugging message at verbosity level of -v or higher

debugTraceMsgS :: String -> CoreM () Source #

Output a string debugging message at verbosity level of -v or higher

dumpIfSet_dyn :: DumpFlag -> String -> DumpFormat -> SDoc -> CoreM () Source #

Show some labelled SDoc if a particular flag is set or at a verbosity level of -v -ddump-most or higher

CoreDoSimplify Int SimplMode
CoreDoPluginPass String CorePluginPass
CoreDoFloatInwards
CoreDoFloatOutwards FloatOutSwitches
CoreLiberateCase
CoreDoPrintCore
CoreDoStaticArgs
CoreDoCallArity
CoreDoExitify
CoreDoDemand
CoreDoCpr
CoreDoWorkerWrapper
CoreDoSpecialising
CoreDoSpecConstr
CoreCSE
CoreDoRuleCheck CompilerPhase String
CoreDoNothing
CoreDoPasses [CoreToDo]
CoreDesugar
CoreDesugarOpt
CoreTidy
CorePrep
CoreAddCallerCcs
CoreOccurAnal

PreInlineUnconditionally Id
PostInlineUnconditionally Id
UnfoldingDone Id
RuleFired FastString
LetFloatFromLet
EtaExpansion Id
EtaReduction Id
BetaReduction Id
CaseOfCase Id
KnownBranch Id
CaseMerge Id
AltMerge Id
CaseElim Id
CaseIdentity Id
FillInCaseDefault Id
SimplifierDone