{-# LANGUAGE OverloadedStrings #-}
-- | This module provides an enumeration of the various transformation (e.g. optimization) passes
-- provided by LLVM. They can be used to create a 'LLVM.PassManager.PassManager' to, in turn,
-- run the passes on 'LLVM.Module.Module's. If you don't know what passes you want, consider
-- instead using 'LLVM.PassManager.CuratedPassSetSpec'.
module LLVM.Transforms where

import LLVM.Prelude

-- | <http://llvm.org/docs/Passes.html#transform-passes>
-- A few passes can make use of information in a 'LLVM.Target.TargetMachine' if one
-- is provided to 'LLVM.PassManager.createPassManager'.
-- <http://llvm.org/doxygen/classllvm_1_1Pass.html>
data Pass
  -- here begin the Scalar passes
  = AggressiveDeadCodeElimination
  | BreakCriticalEdges
  -- | can use a 'LLVM.Target.TargetMachine'
  | CodeGenPrepare
  | ConstantPropagation
  | CorrelatedValuePropagation
  | DeadCodeElimination
  | DeadInstructionElimination
  | DeadStoreElimination
  | DemoteRegisterToMemory
  | EarlyCommonSubexpressionElimination
  | GlobalValueNumbering { Pass -> Bool
noLoads :: Bool }
  | InductionVariableSimplify
  | InstructionCombining
  | JumpThreading
  | LoopClosedSingleStaticAssignment
  | LoopInvariantCodeMotion
  | LoopDeletion
  | LoopIdiom
  | LoopInstructionSimplify
  | LoopRotate
  | LoopStrengthReduce
  | LoopUnroll { Pass -> Maybe Word
loopUnrollThreshold :: Maybe Word, Pass -> Maybe Word
count :: Maybe Word, Pass -> Maybe Bool
allowPartial :: Maybe Bool }
  | LoopUnswitch { Pass -> Bool
optimizeForSize :: Bool }
  | LowerAtomic
  | LowerInvoke
  | LowerSwitch
  | LowerExpectIntrinsic
  | MemcpyOptimization
  | PromoteMemoryToRegister
  | Reassociate
  | ScalarReplacementOfAggregates { Pass -> Bool
requiresDominatorTree :: Bool }
  | OldScalarReplacementOfAggregates { 
      Pass -> Maybe Word
oldScalarReplacementOfAggregatesThreshold :: Maybe Word, 
      Pass -> Bool
useDominatorTree :: Bool, 
      Pass -> Maybe Word
structMemberThreshold :: Maybe Word,
      Pass -> Maybe Word
arrayElementThreshold :: Maybe Word,
      Pass -> Maybe Word
scalarLoadThreshold :: Maybe Word
    }
  | SparseConditionalConstantPropagation
  | SimplifyLibCalls
  | SimplifyControlFlowGraph
  | Sinking
  | TailCallElimination

  -- here begin the Interprocedural passes
  | AlwaysInline { Pass -> Bool
insertLifetime :: Bool }
  | ArgumentPromotion
  | ConstantMerge
  | FunctionAttributes
  | FunctionInlining { 
      Pass -> Word
functionInliningThreshold :: Word
    }
  | GlobalDeadCodeElimination
  | InternalizeFunctions { Pass -> [String]
exportList :: [String] }
  | InterproceduralConstantPropagation
  | InterproceduralSparseConditionalConstantPropagation
  | MergeFunctions
  | PartialInlining
  | PruneExceptionHandling
  | StripDeadDebugInfo
  | StripDebugDeclare
  | StripNonDebugSymbols
  | StripSymbols { Pass -> Bool
onlyDebugInfo :: Bool }

  -- here begin the vectorization passes
  | LoopVectorize {
      Pass -> Bool
interleaveOnlyWhenForced :: Bool,
      Pass -> Bool
vectorizeOnlyWhenForced :: Bool
    }
  | SuperwordLevelParallelismVectorize

  -- here begin the instrumentation passes
  | GCOVProfiler {
      Pass -> Bool
emitNotes :: Bool,
      Pass -> Bool
emitData :: Bool,
      Pass -> GCOVVersion
version :: GCOVVersion, 
      Pass -> Bool
useCfgChecksum :: Bool,
      Pass -> Bool
noRedZone :: Bool,
      Pass -> Bool
functionNamesInData :: Bool
    }
  | AddressSanitizer
  | AddressSanitizerModule
  | MemorySanitizer {
      Pass -> Bool
trackOrigins :: Bool,
      Pass -> Bool
recover :: Bool,
      Pass -> Bool
kernel :: Bool
    }
  | ThreadSanitizer
  | BoundsChecking
  deriving (Pass -> Pass -> Bool
(Pass -> Pass -> Bool) -> (Pass -> Pass -> Bool) -> Eq Pass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pass -> Pass -> Bool
$c/= :: Pass -> Pass -> Bool
== :: Pass -> Pass -> Bool
$c== :: Pass -> Pass -> Bool
Eq, Eq Pass
Eq Pass =>
(Pass -> Pass -> Ordering)
-> (Pass -> Pass -> Bool)
-> (Pass -> Pass -> Bool)
-> (Pass -> Pass -> Bool)
-> (Pass -> Pass -> Bool)
-> (Pass -> Pass -> Pass)
-> (Pass -> Pass -> Pass)
-> Ord Pass
Pass -> Pass -> Bool
Pass -> Pass -> Ordering
Pass -> Pass -> Pass
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Pass -> Pass -> Pass
$cmin :: Pass -> Pass -> Pass
max :: Pass -> Pass -> Pass
$cmax :: Pass -> Pass -> Pass
>= :: Pass -> Pass -> Bool
$c>= :: Pass -> Pass -> Bool
> :: Pass -> Pass -> Bool
$c> :: Pass -> Pass -> Bool
<= :: Pass -> Pass -> Bool
$c<= :: Pass -> Pass -> Bool
< :: Pass -> Pass -> Bool
$c< :: Pass -> Pass -> Bool
compare :: Pass -> Pass -> Ordering
$ccompare :: Pass -> Pass -> Ordering
$cp1Ord :: Eq Pass
Ord, ReadPrec [Pass]
ReadPrec Pass
Int -> ReadS Pass
ReadS [Pass]
(Int -> ReadS Pass)
-> ReadS [Pass] -> ReadPrec Pass -> ReadPrec [Pass] -> Read Pass
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Pass]
$creadListPrec :: ReadPrec [Pass]
readPrec :: ReadPrec Pass
$creadPrec :: ReadPrec Pass
readList :: ReadS [Pass]
$creadList :: ReadS [Pass]
readsPrec :: Int -> ReadS Pass
$creadsPrec :: Int -> ReadS Pass
Read, Int -> Pass -> ShowS
[Pass] -> ShowS
Pass -> String
(Int -> Pass -> ShowS)
-> (Pass -> String) -> ([Pass] -> ShowS) -> Show Pass
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Pass] -> ShowS
$cshowList :: [Pass] -> ShowS
show :: Pass -> String
$cshow :: Pass -> String
showsPrec :: Int -> Pass -> ShowS
$cshowsPrec :: Int -> Pass -> ShowS
Show, Typeable, Typeable Pass
DataType
Constr
Typeable Pass =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Pass -> c Pass)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pass)
-> (Pass -> Constr)
-> (Pass -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pass))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pass))
-> ((forall b. Data b => b -> b) -> Pass -> Pass)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pass -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Pass -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pass -> m Pass)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pass -> m Pass)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pass -> m Pass)
-> Data Pass
Pass -> DataType
Pass -> Constr
(forall b. Data b => b -> b) -> Pass -> Pass
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pass -> c Pass
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pass
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Pass -> u
forall u. (forall d. Data d => d -> u) -> Pass -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pass -> m Pass
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pass -> m Pass
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pass
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pass -> c Pass
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pass)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pass)
$cBoundsChecking :: Constr
$cThreadSanitizer :: Constr
$cMemorySanitizer :: Constr
$cAddressSanitizerModule :: Constr
$cAddressSanitizer :: Constr
$cGCOVProfiler :: Constr
$cSuperwordLevelParallelismVectorize :: Constr
$cLoopVectorize :: Constr
$cStripSymbols :: Constr
$cStripNonDebugSymbols :: Constr
$cStripDebugDeclare :: Constr
$cStripDeadDebugInfo :: Constr
$cPruneExceptionHandling :: Constr
$cPartialInlining :: Constr
$cMergeFunctions :: Constr
$cInterproceduralSparseConditionalConstantPropagation :: Constr
$cInterproceduralConstantPropagation :: Constr
$cInternalizeFunctions :: Constr
$cGlobalDeadCodeElimination :: Constr
$cFunctionInlining :: Constr
$cFunctionAttributes :: Constr
$cConstantMerge :: Constr
$cArgumentPromotion :: Constr
$cAlwaysInline :: Constr
$cTailCallElimination :: Constr
$cSinking :: Constr
$cSimplifyControlFlowGraph :: Constr
$cSimplifyLibCalls :: Constr
$cSparseConditionalConstantPropagation :: Constr
$cOldScalarReplacementOfAggregates :: Constr
$cScalarReplacementOfAggregates :: Constr
$cReassociate :: Constr
$cPromoteMemoryToRegister :: Constr
$cMemcpyOptimization :: Constr
$cLowerExpectIntrinsic :: Constr
$cLowerSwitch :: Constr
$cLowerInvoke :: Constr
$cLowerAtomic :: Constr
$cLoopUnswitch :: Constr
$cLoopUnroll :: Constr
$cLoopStrengthReduce :: Constr
$cLoopRotate :: Constr
$cLoopInstructionSimplify :: Constr
$cLoopIdiom :: Constr
$cLoopDeletion :: Constr
$cLoopInvariantCodeMotion :: Constr
$cLoopClosedSingleStaticAssignment :: Constr
$cJumpThreading :: Constr
$cInstructionCombining :: Constr
$cInductionVariableSimplify :: Constr
$cGlobalValueNumbering :: Constr
$cEarlyCommonSubexpressionElimination :: Constr
$cDemoteRegisterToMemory :: Constr
$cDeadStoreElimination :: Constr
$cDeadInstructionElimination :: Constr
$cDeadCodeElimination :: Constr
$cCorrelatedValuePropagation :: Constr
$cConstantPropagation :: Constr
$cCodeGenPrepare :: Constr
$cBreakCriticalEdges :: Constr
$cAggressiveDeadCodeElimination :: Constr
$tPass :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Pass -> m Pass
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pass -> m Pass
gmapMp :: (forall d. Data d => d -> m d) -> Pass -> m Pass
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pass -> m Pass
gmapM :: (forall d. Data d => d -> m d) -> Pass -> m Pass
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pass -> m Pass
gmapQi :: Int -> (forall d. Data d => d -> u) -> Pass -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pass -> u
gmapQ :: (forall d. Data d => d -> u) -> Pass -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pass -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r
gmapT :: (forall b. Data b => b -> b) -> Pass -> Pass
$cgmapT :: (forall b. Data b => b -> b) -> Pass -> Pass
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pass)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pass)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Pass)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pass)
dataTypeOf :: Pass -> DataType
$cdataTypeOf :: Pass -> DataType
toConstr :: Pass -> Constr
$ctoConstr :: Pass -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pass
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pass
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pass -> c Pass
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pass -> c Pass
$cp1Data :: Typeable Pass
Data, (forall x. Pass -> Rep Pass x)
-> (forall x. Rep Pass x -> Pass) -> Generic Pass
forall x. Rep Pass x -> Pass
forall x. Pass -> Rep Pass x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Pass x -> Pass
$cfrom :: forall x. Pass -> Rep Pass x
Generic)

-- | Defaults for the 'LoopVectorize' pass
defaultLoopVectorize :: Pass
defaultLoopVectorize :: Pass
defaultLoopVectorize = LoopVectorize :: Bool -> Bool -> Pass
LoopVectorize {
    interleaveOnlyWhenForced :: Bool
interleaveOnlyWhenForced = Bool
False,
    vectorizeOnlyWhenForced :: Bool
vectorizeOnlyWhenForced = Bool
False
  }

-- | See <http://gcc.gnu.org/viewcvs/gcc/trunk/gcc/gcov-io.h?view=markup>.
newtype GCOVVersion = GCOVVersion ShortByteString
  deriving (GCOVVersion -> GCOVVersion -> Bool
(GCOVVersion -> GCOVVersion -> Bool)
-> (GCOVVersion -> GCOVVersion -> Bool) -> Eq GCOVVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GCOVVersion -> GCOVVersion -> Bool
$c/= :: GCOVVersion -> GCOVVersion -> Bool
== :: GCOVVersion -> GCOVVersion -> Bool
$c== :: GCOVVersion -> GCOVVersion -> Bool
Eq, Eq GCOVVersion
Eq GCOVVersion =>
(GCOVVersion -> GCOVVersion -> Ordering)
-> (GCOVVersion -> GCOVVersion -> Bool)
-> (GCOVVersion -> GCOVVersion -> Bool)
-> (GCOVVersion -> GCOVVersion -> Bool)
-> (GCOVVersion -> GCOVVersion -> Bool)
-> (GCOVVersion -> GCOVVersion -> GCOVVersion)
-> (GCOVVersion -> GCOVVersion -> GCOVVersion)
-> Ord GCOVVersion
GCOVVersion -> GCOVVersion -> Bool
GCOVVersion -> GCOVVersion -> Ordering
GCOVVersion -> GCOVVersion -> GCOVVersion
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GCOVVersion -> GCOVVersion -> GCOVVersion
$cmin :: GCOVVersion -> GCOVVersion -> GCOVVersion
max :: GCOVVersion -> GCOVVersion -> GCOVVersion
$cmax :: GCOVVersion -> GCOVVersion -> GCOVVersion
>= :: GCOVVersion -> GCOVVersion -> Bool
$c>= :: GCOVVersion -> GCOVVersion -> Bool
> :: GCOVVersion -> GCOVVersion -> Bool
$c> :: GCOVVersion -> GCOVVersion -> Bool
<= :: GCOVVersion -> GCOVVersion -> Bool
$c<= :: GCOVVersion -> GCOVVersion -> Bool
< :: GCOVVersion -> GCOVVersion -> Bool
$c< :: GCOVVersion -> GCOVVersion -> Bool
compare :: GCOVVersion -> GCOVVersion -> Ordering
$ccompare :: GCOVVersion -> GCOVVersion -> Ordering
$cp1Ord :: Eq GCOVVersion
Ord, ReadPrec [GCOVVersion]
ReadPrec GCOVVersion
Int -> ReadS GCOVVersion
ReadS [GCOVVersion]
(Int -> ReadS GCOVVersion)
-> ReadS [GCOVVersion]
-> ReadPrec GCOVVersion
-> ReadPrec [GCOVVersion]
-> Read GCOVVersion
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GCOVVersion]
$creadListPrec :: ReadPrec [GCOVVersion]
readPrec :: ReadPrec GCOVVersion
$creadPrec :: ReadPrec GCOVVersion
readList :: ReadS [GCOVVersion]
$creadList :: ReadS [GCOVVersion]
readsPrec :: Int -> ReadS GCOVVersion
$creadsPrec :: Int -> ReadS GCOVVersion
Read, Int -> GCOVVersion -> ShowS
[GCOVVersion] -> ShowS
GCOVVersion -> String
(Int -> GCOVVersion -> ShowS)
-> (GCOVVersion -> String)
-> ([GCOVVersion] -> ShowS)
-> Show GCOVVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GCOVVersion] -> ShowS
$cshowList :: [GCOVVersion] -> ShowS
show :: GCOVVersion -> String
$cshow :: GCOVVersion -> String
showsPrec :: Int -> GCOVVersion -> ShowS
$cshowsPrec :: Int -> GCOVVersion -> ShowS
Show, Typeable, Typeable GCOVVersion
DataType
Constr
Typeable GCOVVersion =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GCOVVersion -> c GCOVVersion)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GCOVVersion)
-> (GCOVVersion -> Constr)
-> (GCOVVersion -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GCOVVersion))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GCOVVersion))
-> ((forall b. Data b => b -> b) -> GCOVVersion -> GCOVVersion)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GCOVVersion -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GCOVVersion -> r)
-> (forall u. (forall d. Data d => d -> u) -> GCOVVersion -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GCOVVersion -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GCOVVersion -> m GCOVVersion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GCOVVersion -> m GCOVVersion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GCOVVersion -> m GCOVVersion)
-> Data GCOVVersion
GCOVVersion -> DataType
GCOVVersion -> Constr
(forall b. Data b => b -> b) -> GCOVVersion -> GCOVVersion
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GCOVVersion -> c GCOVVersion
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GCOVVersion
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GCOVVersion -> u
forall u. (forall d. Data d => d -> u) -> GCOVVersion -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GCOVVersion -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GCOVVersion -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GCOVVersion -> m GCOVVersion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GCOVVersion -> m GCOVVersion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GCOVVersion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GCOVVersion -> c GCOVVersion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GCOVVersion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GCOVVersion)
$cGCOVVersion :: Constr
$tGCOVVersion :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> GCOVVersion -> m GCOVVersion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GCOVVersion -> m GCOVVersion
gmapMp :: (forall d. Data d => d -> m d) -> GCOVVersion -> m GCOVVersion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GCOVVersion -> m GCOVVersion
gmapM :: (forall d. Data d => d -> m d) -> GCOVVersion -> m GCOVVersion
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GCOVVersion -> m GCOVVersion
gmapQi :: Int -> (forall d. Data d => d -> u) -> GCOVVersion -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GCOVVersion -> u
gmapQ :: (forall d. Data d => d -> u) -> GCOVVersion -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GCOVVersion -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GCOVVersion -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GCOVVersion -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GCOVVersion -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GCOVVersion -> r
gmapT :: (forall b. Data b => b -> b) -> GCOVVersion -> GCOVVersion
$cgmapT :: (forall b. Data b => b -> b) -> GCOVVersion -> GCOVVersion
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GCOVVersion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GCOVVersion)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c GCOVVersion)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GCOVVersion)
dataTypeOf :: GCOVVersion -> DataType
$cdataTypeOf :: GCOVVersion -> DataType
toConstr :: GCOVVersion -> Constr
$ctoConstr :: GCOVVersion -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GCOVVersion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GCOVVersion
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GCOVVersion -> c GCOVVersion
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GCOVVersion -> c GCOVVersion
$cp1Data :: Typeable GCOVVersion
Data, (forall x. GCOVVersion -> Rep GCOVVersion x)
-> (forall x. Rep GCOVVersion x -> GCOVVersion)
-> Generic GCOVVersion
forall x. Rep GCOVVersion x -> GCOVVersion
forall x. GCOVVersion -> Rep GCOVVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GCOVVersion x -> GCOVVersion
$cfrom :: forall x. GCOVVersion -> Rep GCOVVersion x
Generic)

-- | Defaults for 'GCOVProfiler'.
defaultGCOVProfiler :: Pass
defaultGCOVProfiler :: Pass
defaultGCOVProfiler = GCOVProfiler :: Bool -> Bool -> GCOVVersion -> Bool -> Bool -> Bool -> Pass
GCOVProfiler {
    emitNotes :: Bool
emitNotes = Bool
True,
    emitData :: Bool
emitData = Bool
True,
    version :: GCOVVersion
version = ShortByteString -> GCOVVersion
GCOVVersion "402*", 
    useCfgChecksum :: Bool
useCfgChecksum = Bool
False,
    noRedZone :: Bool
noRedZone = Bool
False,
    functionNamesInData :: Bool
functionNamesInData = Bool
True
  }

-- | Defaults for 'AddressSanitizer'.
defaultAddressSanitizer :: Pass
defaultAddressSanitizer :: Pass
defaultAddressSanitizer = Pass
AddressSanitizer

-- | Defaults for 'AddressSanitizerModule'.
defaultAddressSanitizerModule :: Pass
defaultAddressSanitizerModule :: Pass
defaultAddressSanitizerModule = Pass
AddressSanitizerModule

-- | Defaults for 'MemorySanitizer'.
defaultMemorySanitizer :: Pass
defaultMemorySanitizer :: Pass
defaultMemorySanitizer = MemorySanitizer :: Bool -> Bool -> Bool -> Pass
MemorySanitizer {
  trackOrigins :: Bool
trackOrigins = Bool
False,
  recover :: Bool
recover = Bool
False,
  kernel :: Bool
kernel = Bool
False
}

-- | Defaults for 'ThreadSanitizer'.
defaultThreadSanitizer :: Pass
defaultThreadSanitizer :: Pass
defaultThreadSanitizer = Pass
ThreadSanitizer