Safe Haskell	None
Language	Haskell2010

DynFlags

Contents

Dynamic flags and associated configuration types
Compiler configuration suitable for display to the user
SSE and AVX
Linker/compiler information

Description

Dynamic flags

Most flags are dynamic flags, which means they can change from compilation to compilation using OPTIONS_GHC pragmas, and in a multi-session GHC each session can be using different dynamic flags. Dynamic flags can also be set at the prompt in GHCi.

(c) The University of Glasgow 2005

Synopsis

Dynamic flags and associated configuration types

data DumpFlag Source #

Constructors

Opt_D_dump_cmm
Opt_D_dump_cmm_from_stg
Opt_D_dump_cmm_raw
Opt_D_dump_cmm_verbose
Opt_D_dump_cmm_cfg
Opt_D_dump_cmm_cbe
Opt_D_dump_cmm_switch
Opt_D_dump_cmm_proc
Opt_D_dump_cmm_sp
Opt_D_dump_cmm_sink
Opt_D_dump_cmm_caf
Opt_D_dump_cmm_procmap
Opt_D_dump_cmm_split
Opt_D_dump_cmm_info
Opt_D_dump_cmm_cps
Opt_D_dump_asm
Opt_D_dump_asm_native
Opt_D_dump_asm_liveness
Opt_D_dump_asm_regalloc
Opt_D_dump_asm_regalloc_stages
Opt_D_dump_asm_conflicts
Opt_D_dump_asm_stats
Opt_D_dump_asm_expanded
Opt_D_dump_llvm
Opt_D_dump_core_stats
Opt_D_dump_deriv
Opt_D_dump_ds
Opt_D_dump_foreign
Opt_D_dump_inlinings
Opt_D_dump_rule_firings
Opt_D_dump_rule_rewrites
Opt_D_dump_simpl_trace
Opt_D_dump_occur_anal
Opt_D_dump_parsed
Opt_D_dump_parsed_ast
Opt_D_dump_rn
Opt_D_dump_rn_ast
Opt_D_dump_shape
Opt_D_dump_simpl
Opt_D_dump_simpl_iterations
Opt_D_dump_spec
Opt_D_dump_prep
Opt_D_dump_stg
Opt_D_dump_call_arity
Opt_D_dump_stranal
Opt_D_dump_str_signatures
Opt_D_dump_tc
Opt_D_dump_tc_ast
Opt_D_dump_types
Opt_D_dump_rules
Opt_D_dump_cse
Opt_D_dump_worker_wrapper
Opt_D_dump_rn_trace
Opt_D_dump_rn_stats
Opt_D_dump_opt_cmm
Opt_D_dump_simpl_stats
Opt_D_dump_cs_trace
Opt_D_dump_tc_trace
Opt_D_dump_ec_trace
Opt_D_dump_if_trace
Opt_D_dump_vt_trace
Opt_D_dump_splices
Opt_D_th_dec_file
Opt_D_dump_BCOs
Opt_D_dump_vect
Opt_D_dump_ticked
Opt_D_dump_rtti
Opt_D_source_stats
Opt_D_verbose_stg2stg
Opt_D_dump_hi
Opt_D_dump_hi_diffs
Opt_D_dump_mod_cycles
Opt_D_dump_mod_map
Opt_D_dump_view_pattern_commoning
Opt_D_verbose_core2core
Opt_D_dump_debug
Opt_D_dump_json
Opt_D_ppr_debug
Opt_D_no_debug_output

Instances

Enum DumpFlag Source #
Methods succ :: DumpFlag -> DumpFlag # pred :: DumpFlag -> DumpFlag # toEnum :: Int -> DumpFlag # fromEnum :: DumpFlag -> Int # enumFrom :: DumpFlag -> [DumpFlag] # enumFromThen :: DumpFlag -> DumpFlag -> [DumpFlag] # enumFromTo :: DumpFlag -> DumpFlag -> [DumpFlag] # enumFromThenTo :: DumpFlag -> DumpFlag -> DumpFlag -> [DumpFlag] #
Eq DumpFlag Source #
Methods (==) :: DumpFlag -> DumpFlag -> Bool # (/=) :: DumpFlag -> DumpFlag -> Bool #
Show DumpFlag Source #
Methods showsPrec :: Int -> DumpFlag -> ShowS # show :: DumpFlag -> String # showList :: [DumpFlag] -> ShowS #

data GeneralFlag Source #

Enumerates the simple on-or-off dynamic flags

Constructors

Opt_DumpToFile	Append dump output to files instead of stdout.
Opt_D_faststring_stats
Opt_D_dump_minimal_imports
Opt_DoCoreLinting
Opt_DoStgLinting
Opt_DoCmmLinting
Opt_DoAsmLinting
Opt_DoAnnotationLinting
Opt_NoLlvmMangler
Opt_WarnIsError
Opt_ShowWarnGroups
Opt_HideSourcePaths
Opt_PrintExplicitForalls
Opt_PrintExplicitKinds
Opt_PrintExplicitCoercions
Opt_PrintExplicitRuntimeReps
Opt_PrintEqualityRelations
Opt_PrintUnicodeSyntax
Opt_PrintExpandedSynonyms
Opt_PrintPotentialInstances
Opt_PrintTypecheckerElaboration
Opt_CallArity
Opt_Strictness
Opt_LateDmdAnal
Opt_KillAbsence
Opt_KillOneShot
Opt_FullLaziness
Opt_FloatIn
Opt_Specialise
Opt_SpecialiseAggressively
Opt_CrossModuleSpecialise
Opt_StaticArgumentTransformation
Opt_CSE
Opt_StgCSE
Opt_LiberateCase
Opt_SpecConstr
Opt_SpecConstrKeen
Opt_DoLambdaEtaExpansion
Opt_IgnoreAsserts
Opt_DoEtaReduction
Opt_CaseMerge
Opt_CaseFolding
Opt_UnboxStrictFields
Opt_UnboxSmallStrictFields
Opt_DictsCheap
Opt_EnableRewriteRules
Opt_Vectorise
Opt_VectorisationAvoidance
Opt_RegsGraph
Opt_RegsIterative
Opt_PedanticBottoms
Opt_LlvmTBAA
Opt_LlvmPassVectorsInRegisters
Opt_LlvmFillUndefWithGarbage
Opt_IrrefutableTuples
Opt_CmmSink
Opt_CmmElimCommonBlocks
Opt_OmitYields
Opt_FunToThunk
Opt_DictsStrict
Opt_DmdTxDictSel
Opt_Loopification
Opt_CprAnal
Opt_WorkerWrapper
Opt_SolveConstantDicts
Opt_IgnoreInterfacePragmas
Opt_OmitInterfacePragmas
Opt_ExposeAllUnfoldings
Opt_WriteInterface
Opt_AutoSccsOnIndividualCafs
Opt_ProfCountEntries
Opt_Pp
Opt_ForceRecomp
Opt_ExcessPrecision
Opt_EagerBlackHoling
Opt_NoHsMain
Opt_SplitObjs
Opt_SplitSections
Opt_StgStats
Opt_HideAllPackages
Opt_HideAllPluginPackages
Opt_PrintBindResult
Opt_Haddock
Opt_HaddockOptions
Opt_BreakOnException
Opt_BreakOnError
Opt_PrintEvldWithShow
Opt_PrintBindContents
Opt_GenManifest
Opt_EmbedManifest
Opt_SharedImplib
Opt_BuildingCabalPackage
Opt_IgnoreDotGhci
Opt_GhciSandbox
Opt_GhciHistory
Opt_LocalGhciHistory
Opt_HelpfulErrors
Opt_DeferTypeErrors
Opt_DeferTypedHoles
Opt_DeferOutOfScopeVariables
Opt_PIC	-fPIC
Opt_PIE	-fPIE
Opt_PICExecutable	-pie
Opt_SccProfilingOn
Opt_Ticky
Opt_Ticky_Allocd
Opt_Ticky_LNE
Opt_Ticky_Dyn_Thunk
Opt_RPath
Opt_RelativeDynlibPaths
Opt_Hpc
Opt_FlatCache
Opt_ExternalInterpreter
Opt_OptimalApplicativeDo
Opt_VersionMacros
Opt_WholeArchiveHsLibs
Opt_SimplPreInlining
Opt_ErrorSpans
Opt_DiagnosticsShowCaret
Opt_PprCaseAsLet
Opt_PprShowTicks
Opt_ShowHoleConstraints
Opt_ShowLoadedModules
Opt_SuppressCoercions
Opt_SuppressVarKinds
Opt_SuppressModulePrefixes
Opt_SuppressTypeApplications
Opt_SuppressIdInfo
Opt_SuppressUnfoldings
Opt_SuppressTypeSignatures
Opt_SuppressUniques
Opt_SuppressTicks
Opt_AutoLinkPackages
Opt_ImplicitImportQualified
Opt_KeepHiDiffs
Opt_KeepHcFiles
Opt_KeepSFiles
Opt_KeepTmpFiles
Opt_KeepRawTokenStream
Opt_KeepLlvmFiles
Opt_KeepHiFiles
Opt_KeepOFiles
Opt_BuildDynamicToo
Opt_DistrustAllPackages
Opt_PackageTrust
Opt_G_NoStateHack
Opt_G_NoOptCoercion

Instances

Enum GeneralFlag Source #
Methods succ :: GeneralFlag -> GeneralFlag # pred :: GeneralFlag -> GeneralFlag # toEnum :: Int -> GeneralFlag # fromEnum :: GeneralFlag -> Int # enumFrom :: GeneralFlag -> [GeneralFlag] # enumFromThen :: GeneralFlag -> GeneralFlag -> [GeneralFlag] # enumFromTo :: GeneralFlag -> GeneralFlag -> [GeneralFlag] # enumFromThenTo :: GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag] #
Eq GeneralFlag Source #
Methods (==) :: GeneralFlag -> GeneralFlag -> Bool # (/=) :: GeneralFlag -> GeneralFlag -> Bool #
Show GeneralFlag Source #
Methods showsPrec :: Int -> GeneralFlag -> ShowS # show :: GeneralFlag -> String # showList :: [GeneralFlag] -> ShowS #

data WarningFlag Source #

Constructors

Opt_WarnDuplicateExports
Opt_WarnDuplicateConstraints
Opt_WarnRedundantConstraints
Opt_WarnHiShadows
Opt_WarnImplicitPrelude
Opt_WarnIncompletePatterns
Opt_WarnIncompleteUniPatterns
Opt_WarnIncompletePatternsRecUpd
Opt_WarnOverflowedLiterals
Opt_WarnEmptyEnumerations
Opt_WarnMissingFields
Opt_WarnMissingImportList
Opt_WarnMissingMethods
Opt_WarnMissingSignatures
Opt_WarnMissingLocalSignatures
Opt_WarnNameShadowing
Opt_WarnOverlappingPatterns
Opt_WarnTypeDefaults
Opt_WarnMonomorphism
Opt_WarnUnusedTopBinds
Opt_WarnUnusedLocalBinds
Opt_WarnUnusedPatternBinds
Opt_WarnUnusedImports
Opt_WarnUnusedMatches
Opt_WarnUnusedTypePatterns
Opt_WarnUnusedForalls
Opt_WarnWarningsDeprecations
Opt_WarnDeprecatedFlags
Opt_WarnAMP
Opt_WarnMissingMonadFailInstances
Opt_WarnSemigroup
Opt_WarnDodgyExports
Opt_WarnDodgyImports
Opt_WarnOrphans
Opt_WarnAutoOrphans
Opt_WarnIdentities
Opt_WarnTabs
Opt_WarnUnrecognisedPragmas
Opt_WarnDodgyForeignImports
Opt_WarnUnusedDoBind
Opt_WarnWrongDoBind
Opt_WarnAlternativeLayoutRuleTransitional
Opt_WarnUnsafe
Opt_WarnSafe
Opt_WarnTrustworthySafe
Opt_WarnMissedSpecs
Opt_WarnAllMissedSpecs
Opt_WarnUnsupportedCallingConventions
Opt_WarnUnsupportedLlvmVersion
Opt_WarnInlineRuleShadowing
Opt_WarnTypedHoles
Opt_WarnPartialTypeSignatures
Opt_WarnMissingExportedSignatures
Opt_WarnUntickedPromotedConstructors
Opt_WarnDerivingTypeable
Opt_WarnDeferredTypeErrors
Opt_WarnDeferredOutOfScopeVariables
Opt_WarnNonCanonicalMonadInstances
Opt_WarnNonCanonicalMonadFailInstances
Opt_WarnNonCanonicalMonoidInstances
Opt_WarnMissingPatternSynonymSignatures
Opt_WarnUnrecognisedWarningFlags
Opt_WarnSimplifiableClassConstraints
Opt_WarnCPPUndef
Opt_WarnUnbangedStrictPatterns
Opt_WarnMissingHomeModules

Instances

Enum WarningFlag Source #
Methods succ :: WarningFlag -> WarningFlag # pred :: WarningFlag -> WarningFlag # toEnum :: Int -> WarningFlag # fromEnum :: WarningFlag -> Int # enumFrom :: WarningFlag -> [WarningFlag] # enumFromThen :: WarningFlag -> WarningFlag -> [WarningFlag] # enumFromTo :: WarningFlag -> WarningFlag -> [WarningFlag] # enumFromThenTo :: WarningFlag -> WarningFlag -> WarningFlag -> [WarningFlag] #
Eq WarningFlag Source #
Methods (==) :: WarningFlag -> WarningFlag -> Bool # (/=) :: WarningFlag -> WarningFlag -> Bool #
Show WarningFlag Source #
Methods showsPrec :: Int -> WarningFlag -> ShowS # show :: WarningFlag -> String # showList :: [WarningFlag] -> ShowS #

data WarnReason Source #

Used when outputting warnings: if a reason is given, it is displayed. If a warning isn't controlled by a flag, this is made explicit at the point of use.

Constructors

NoReason
Reason !WarningFlag

Instances

Show WarnReason Source #
Methods showsPrec :: Int -> WarnReason -> ShowS # show :: WarnReason -> String # showList :: [WarnReason] -> ShowS #
Outputable WarnReason Source #
Methods ppr :: WarnReason -> SDoc Source # pprPrec :: Rational -> WarnReason -> SDoc Source #
ToJson WarnReason Source #
Methods json :: WarnReason -> JsonDoc Source #

data Language Source #

Constructors

Haskell98
Haskell2010

Instances

Enum Language Source #
Methods succ :: Language -> Language # pred :: Language -> Language # toEnum :: Int -> Language # fromEnum :: Language -> Int # enumFrom :: Language -> [Language] # enumFromThen :: Language -> Language -> [Language] # enumFromTo :: Language -> Language -> [Language] # enumFromThenTo :: Language -> Language -> Language -> [Language] #
Eq Language Source #
Methods (==) :: Language -> Language -> Bool # (/=) :: Language -> Language -> Bool #
Show Language Source #
Methods showsPrec :: Int -> Language -> ShowS # show :: Language -> String # showList :: [Language] -> ShowS #
Outputable Language Source #
Methods ppr :: Language -> SDoc Source # pprPrec :: Rational -> Language -> SDoc Source #

data PlatformConstants Source #

Constructors

PlatformConstants

Fields

pc_platformConstants :: ()
pc_CONTROL_GROUP_CONST_291 :: Int
pc_STD_HDR_SIZE :: Int
pc_PROF_HDR_SIZE :: Int
pc_BLOCK_SIZE :: Int
pc_BLOCKS_PER_MBLOCK :: Int
pc_TICKY_BIN_COUNT :: Int
pc_OFFSET_StgRegTable_rR1 :: Int
pc_OFFSET_StgRegTable_rR2 :: Int
pc_OFFSET_StgRegTable_rR3 :: Int
pc_OFFSET_StgRegTable_rR4 :: Int
pc_OFFSET_StgRegTable_rR5 :: Int
pc_OFFSET_StgRegTable_rR6 :: Int
pc_OFFSET_StgRegTable_rR7 :: Int
pc_OFFSET_StgRegTable_rR8 :: Int
pc_OFFSET_StgRegTable_rR9 :: Int
pc_OFFSET_StgRegTable_rR10 :: Int
pc_OFFSET_StgRegTable_rF1 :: Int
pc_OFFSET_StgRegTable_rF2 :: Int
pc_OFFSET_StgRegTable_rF3 :: Int
pc_OFFSET_StgRegTable_rF4 :: Int
pc_OFFSET_StgRegTable_rF5 :: Int
pc_OFFSET_StgRegTable_rF6 :: Int
pc_OFFSET_StgRegTable_rD1 :: Int
pc_OFFSET_StgRegTable_rD2 :: Int
pc_OFFSET_StgRegTable_rD3 :: Int
pc_OFFSET_StgRegTable_rD4 :: Int
pc_OFFSET_StgRegTable_rD5 :: Int
pc_OFFSET_StgRegTable_rD6 :: Int
pc_OFFSET_StgRegTable_rXMM1 :: Int
pc_OFFSET_StgRegTable_rXMM2 :: Int
pc_OFFSET_StgRegTable_rXMM3 :: Int
pc_OFFSET_StgRegTable_rXMM4 :: Int
pc_OFFSET_StgRegTable_rXMM5 :: Int
pc_OFFSET_StgRegTable_rXMM6 :: Int
pc_OFFSET_StgRegTable_rYMM1 :: Int
pc_OFFSET_StgRegTable_rYMM2 :: Int
pc_OFFSET_StgRegTable_rYMM3 :: Int
pc_OFFSET_StgRegTable_rYMM4 :: Int
pc_OFFSET_StgRegTable_rYMM5 :: Int
pc_OFFSET_StgRegTable_rYMM6 :: Int
pc_OFFSET_StgRegTable_rZMM1 :: Int
pc_OFFSET_StgRegTable_rZMM2 :: Int
pc_OFFSET_StgRegTable_rZMM3 :: Int
pc_OFFSET_StgRegTable_rZMM4 :: Int
pc_OFFSET_StgRegTable_rZMM5 :: Int
pc_OFFSET_StgRegTable_rZMM6 :: Int
pc_OFFSET_StgRegTable_rL1 :: Int
pc_OFFSET_StgRegTable_rSp :: Int
pc_OFFSET_StgRegTable_rSpLim :: Int
pc_OFFSET_StgRegTable_rHp :: Int
pc_OFFSET_StgRegTable_rHpLim :: Int
pc_OFFSET_StgRegTable_rCCCS :: Int
pc_OFFSET_StgRegTable_rCurrentTSO :: Int
pc_OFFSET_StgRegTable_rCurrentNursery :: Int
pc_OFFSET_StgRegTable_rHpAlloc :: Int
pc_OFFSET_stgEagerBlackholeInfo :: Int
pc_OFFSET_stgGCEnter1 :: Int
pc_OFFSET_stgGCFun :: Int
pc_OFFSET_Capability_r :: Int
pc_OFFSET_bdescr_start :: Int
pc_OFFSET_bdescr_free :: Int
pc_OFFSET_bdescr_blocks :: Int
pc_OFFSET_bdescr_flags :: Int
pc_SIZEOF_CostCentreStack :: Int
pc_OFFSET_CostCentreStack_mem_alloc :: Int
pc_REP_CostCentreStack_mem_alloc :: Int
pc_OFFSET_CostCentreStack_scc_count :: Int
pc_REP_CostCentreStack_scc_count :: Int
pc_OFFSET_StgHeader_ccs :: Int
pc_OFFSET_StgHeader_ldvw :: Int
pc_SIZEOF_StgSMPThunkHeader :: Int
pc_OFFSET_StgEntCounter_allocs :: Int
pc_REP_StgEntCounter_allocs :: Int
pc_OFFSET_StgEntCounter_allocd :: Int
pc_REP_StgEntCounter_allocd :: Int
pc_OFFSET_StgEntCounter_registeredp :: Int
pc_OFFSET_StgEntCounter_link :: Int
pc_OFFSET_StgEntCounter_entry_count :: Int
pc_SIZEOF_StgUpdateFrame_NoHdr :: Int
pc_SIZEOF_StgMutArrPtrs_NoHdr :: Int
pc_OFFSET_StgMutArrPtrs_ptrs :: Int
pc_OFFSET_StgMutArrPtrs_size :: Int
pc_SIZEOF_StgSmallMutArrPtrs_NoHdr :: Int
pc_OFFSET_StgSmallMutArrPtrs_ptrs :: Int
pc_SIZEOF_StgArrBytes_NoHdr :: Int
pc_OFFSET_StgArrBytes_bytes :: Int
pc_OFFSET_StgTSO_alloc_limit :: Int
pc_OFFSET_StgTSO_cccs :: Int
pc_OFFSET_StgTSO_stackobj :: Int
pc_OFFSET_StgStack_sp :: Int
pc_OFFSET_StgStack_stack :: Int
pc_OFFSET_StgUpdateFrame_updatee :: Int
pc_OFFSET_StgFunInfoExtraFwd_arity :: Int
pc_REP_StgFunInfoExtraFwd_arity :: Int
pc_SIZEOF_StgFunInfoExtraRev :: Int
pc_OFFSET_StgFunInfoExtraRev_arity :: Int
pc_REP_StgFunInfoExtraRev_arity :: Int
pc_MAX_SPEC_SELECTEE_SIZE :: Int
pc_MAX_SPEC_AP_SIZE :: Int
pc_MIN_PAYLOAD_SIZE :: Int
pc_MIN_INTLIKE :: Int
pc_MAX_INTLIKE :: Int
pc_MIN_CHARLIKE :: Int
pc_MAX_CHARLIKE :: Int
pc_MUT_ARR_PTRS_CARD_BITS :: Int
pc_MAX_Vanilla_REG :: Int
pc_MAX_Float_REG :: Int
pc_MAX_Double_REG :: Int
pc_MAX_Long_REG :: Int
pc_MAX_XMM_REG :: Int
pc_MAX_Real_Vanilla_REG :: Int
pc_MAX_Real_Float_REG :: Int
pc_MAX_Real_Double_REG :: Int
pc_MAX_Real_XMM_REG :: Int
pc_MAX_Real_Long_REG :: Int
pc_RESERVED_C_STACK_BYTES :: Int
pc_RESERVED_STACK_WORDS :: Int
pc_AP_STACK_SPLIM :: Int
pc_WORD_SIZE :: Int
pc_DOUBLE_SIZE :: Int
pc_CINT_SIZE :: Int
pc_CLONG_SIZE :: Int
pc_CLONG_LONG_SIZE :: Int
pc_BITMAP_BITS_SHIFT :: Int
pc_TAG_BITS :: Int
pc_WORDS_BIGENDIAN :: Bool
pc_DYNAMIC_BY_DEFAULT :: Bool
pc_LDV_SHIFT :: Int
pc_ILDV_CREATE_MASK :: Integer
pc_ILDV_STATE_CREATE :: Integer
pc_ILDV_STATE_USE :: Integer

Instances

Read PlatformConstants Source #
Methods readsPrec :: Int -> ReadS PlatformConstants # readList :: ReadS [PlatformConstants] # readPrec :: ReadPrec PlatformConstants # readListPrec :: ReadPrec [PlatformConstants] #

type FatalMessager = String -> IO () Source #

type LogAction = DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO () Source #

type LogFinaliser = DynFlags -> IO () Source #

newtype FlushOut Source #

Constructors

FlushOut (IO ())

newtype FlushErr Source #

Constructors

FlushErr (IO ())

data ProfAuto Source #

Constructors

NoProfAuto	no SCC annotations added
ProfAutoAll	top-level and nested functions are annotated
ProfAutoTop	top-level functions annotated only
ProfAutoExports	exported functions annotated only
ProfAutoCalls	annotate call-sites

Instances

Enum ProfAuto Source #
Methods succ :: ProfAuto -> ProfAuto # pred :: ProfAuto -> ProfAuto # toEnum :: Int -> ProfAuto # fromEnum :: ProfAuto -> Int # enumFrom :: ProfAuto -> [ProfAuto] # enumFromThen :: ProfAuto -> ProfAuto -> [ProfAuto] # enumFromTo :: ProfAuto -> ProfAuto -> [ProfAuto] # enumFromThenTo :: ProfAuto -> ProfAuto -> ProfAuto -> [ProfAuto] #
Eq ProfAuto Source #
Methods (==) :: ProfAuto -> ProfAuto -> Bool # (/=) :: ProfAuto -> ProfAuto -> Bool #

glasgowExtsFlags :: [Extension] Source #

warningGroups :: [(String, [WarningFlag])] Source #

Warning groups.

As all warnings are in the Weverything set, it is ignored when displaying to the user which group a warning is in.

warningHierarchies :: [[String]] Source #

Warning group hierarchies, where there is an explicit inclusion relation.

Each inner list is a hierarchy of warning groups, ordered from smallest to largest, where each group is a superset of the one before it.

Separating this from warningGroups allows for multiple hierarchies with no inherent relation to be defined.

The special-case Weverything group is not included.

hasPprDebug :: DynFlags -> Bool Source #

hasNoDebugOutput :: DynFlags -> Bool Source #

hasNoStateHack :: DynFlags -> Bool Source #

hasNoOptCoercion :: DynFlags -> Bool Source #

dopt :: DumpFlag -> DynFlags -> Bool Source #

Test whether a DumpFlag is set

dopt_set :: DynFlags -> DumpFlag -> DynFlags Source #

Set a DumpFlag

dopt_unset :: DynFlags -> DumpFlag -> DynFlags Source #

Unset a DumpFlag

gopt :: GeneralFlag -> DynFlags -> Bool Source #

Test whether a GeneralFlag is set

gopt_set :: DynFlags -> GeneralFlag -> DynFlags Source #

Set a GeneralFlag

gopt_unset :: DynFlags -> GeneralFlag -> DynFlags Source #

Unset a GeneralFlag

setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags Source #

unSetGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags Source #

wopt :: WarningFlag -> DynFlags -> Bool Source #

Test whether a WarningFlag is set

wopt_set :: DynFlags -> WarningFlag -> DynFlags Source #

Set a WarningFlag

wopt_unset :: DynFlags -> WarningFlag -> DynFlags Source #

Unset a WarningFlag

wopt_fatal :: WarningFlag -> DynFlags -> Bool Source #

Test whether a WarningFlag is set as fatal

xopt :: Extension -> DynFlags -> Bool Source #

Test whether a Extension is set

xopt_set :: DynFlags -> Extension -> DynFlags Source #

Set a Extension

xopt_unset :: DynFlags -> Extension -> DynFlags Source #

Unset a Extension

lang_set :: DynFlags -> Maybe Language -> DynFlags Source #

useUnicodeSyntax :: DynFlags -> Bool Source #

An internal helper to check whether to use unicode syntax for output.

Note: You should very likely be using unicodeSyntax instead of this function.

whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m () Source #

ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a Source #

whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m () Source #

dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags Source #

data DynFlags Source #

Contains not only a collection of GeneralFlags but also a plethora of information relating to the compilation of a single file or GHC session

Constructors

DynFlags

Fields

ghcMode :: GhcMode
ghcLink :: GhcLink
hscTarget :: HscTarget
settings :: Settings
verbosity :: Int
Verbosity level: see Note [Verbosity levels]
optLevel :: Int
Optimisation level
debugLevel :: Int
How much debug information to produce
simplPhases :: Int
Number of simplifier phases
maxSimplIterations :: Int
Max simplifier iterations
maxPmCheckIterations :: Int
Max no iterations for pm checking
ruleCheck :: Maybe String
strictnessBefore :: [Int]
Additional demand analysis
parMakeCount :: Maybe Int
The number of modules to compile in parallel in --make mode, where Nothing ==> compile as many in parallel as there are CPUs.
enableTimeStats :: Bool
Enable RTS timing statistics?
ghcHeapSize :: Maybe Int
The heap size to set.
maxRelevantBinds :: Maybe Int
Maximum number of bindings from the type envt to show in type error messages
maxUncoveredPatterns :: Int
Maximum number of unmatched patterns to show in non-exhaustiveness warnings
simplTickFactor :: Int
Multiplier for simplifier ticks
specConstrThreshold :: Maybe Int
Threshold for SpecConstr
specConstrCount :: Maybe Int
Max number of specialisations for any one function
specConstrRecursive :: Int
Max number of specialisations for recursive types Not optional; otherwise ForceSpecConstr can diverge.
liberateCaseThreshold :: Maybe Int
Threshold for LiberateCase
floatLamArgs :: Maybe Int
Arg count for lambda floating See CoreMonad.FloatOutSwitches
historySize :: Int
Simplification history size
importPaths :: [FilePath]
mainModIs :: Module
mainFunIs :: Maybe String
reductionDepth :: IntWithInf
Typechecker maximum stack depth
solverIterations :: IntWithInf
Number of iterations in the constraints solver Typically only 1 is needed
thisInstalledUnitId :: InstalledUnitId
thisComponentId_ :: Maybe ComponentId
thisUnitIdInsts_ :: Maybe [(ModuleName, Module)]
ways :: [Way]
Way flags from the command line
buildTag :: String
The global "way" (e.g. "p" for prof)
rtsBuildTag :: String
The RTS "way"
splitInfo :: Maybe (String, Int)
objectDir :: Maybe String
dylibInstallName :: Maybe String
hiDir :: Maybe String
stubDir :: Maybe String
dumpDir :: Maybe String
objectSuf :: String
hcSuf :: String
hiSuf :: String
canGenerateDynamicToo :: IORef Bool
dynObjectSuf :: String
dynHiSuf :: String
dllSplitFile :: Maybe FilePath
dllSplit :: Maybe [Set String]
outputFile :: Maybe String
dynOutputFile :: Maybe String
outputHi :: Maybe String
dynLibLoader :: DynLibLoader
dumpPrefix :: Maybe FilePath
This is set by runPipeline based on where its output is going.
dumpPrefixForce :: Maybe FilePath
Override the dumpPrefix set by runPipeline. Set by -ddump-file-prefix
ldInputs :: [Option]
includePaths :: [String]
libraryPaths :: [String]
frameworkPaths :: [String]
cmdlineFrameworks :: [String]
rtsOpts :: Maybe String
rtsOptsEnabled :: RtsOptsEnabled
rtsOptsSuggestions :: Bool
hpcDir :: String
Path to store the .mix files
pluginModNames :: [ModuleName]
pluginModNameOpts :: [(ModuleName, String)]
frontendPluginOpts :: [String]
the -ffrontend-opt flags given on the command line, in *reverse* order that they're specified on the command line.
hooks :: Hooks
depMakefile :: FilePath
depIncludePkgDeps :: Bool
depExcludeMods :: [ModuleName]
depSuffixes :: [String]
packageDBFlags :: [PackageDBFlag]
The -package-db flags given on the command line, In *reverse* order that they're specified on the command line. This is intended to be applied with the list of "initial" package databases derived from GHC_PACKAGE_PATH; see getPackageConfRefs.
ignorePackageFlags :: [IgnorePackageFlag]
The -ignore-package flags from the command line. In *reverse* order that they're specified on the command line.
packageFlags :: [PackageFlag]
The -package and -hide-package flags from the command-line. In *reverse* order that they're specified on the command line.
pluginPackageFlags :: [PackageFlag]
The -plugin-package-id flags from command line. In *reverse* order that they're specified on the command line.
trustFlags :: [TrustFlag]
The -trust and -distrust flags. In *reverse* order that they're specified on the command line.
packageEnv :: Maybe FilePath
Filepath to the package environment file (if overriding default)
pkgDatabase :: Maybe [(FilePath, [PackageConfig])]
pkgState :: PackageState
filesToClean :: IORef [FilePath]
dirsToClean :: IORef (Map FilePath FilePath)
filesToNotIntermediateClean :: IORef [FilePath]
nextTempSuffix :: IORef Int
generatedDumps :: IORef (Set FilePath)
dumpFlags :: IntSet
generalFlags :: IntSet
warningFlags :: IntSet
fatalWarningFlags :: IntSet
language :: Maybe Language
safeHaskell :: SafeHaskellMode
Safe Haskell mode
safeInfer :: Bool
safeInferred :: Bool
thOnLoc :: SrcSpan
newDerivOnLoc :: SrcSpan
overlapInstLoc :: SrcSpan
incoherentOnLoc :: SrcSpan
pkgTrustOnLoc :: SrcSpan
warnSafeOnLoc :: SrcSpan
warnUnsafeOnLoc :: SrcSpan
trustworthyOnLoc :: SrcSpan
extensions :: [OnOff Extension]
extensionFlags :: IntSet
ufCreationThreshold :: Int
ufUseThreshold :: Int
ufFunAppDiscount :: Int
ufDictDiscount :: Int
ufKeenessFactor :: Float
ufDearOp :: Int
ufVeryAggressive :: Bool
maxWorkerArgs :: Int
ghciHistSize :: Int
initLogAction :: IO (Maybe LogOutput)
MsgDoc output action: use ErrUtils instead of this if you can
log_action :: LogAction
log_finaliser :: LogFinaliser
flushOut :: FlushOut
flushErr :: FlushErr
haddockOptions :: Maybe String
ghciScripts :: [String]
GHCi scripts specified by -ghci-script, in reverse order
pprUserLength :: Int
pprCols :: Int
useUnicode :: Bool
useColor :: OverridingBool
canUseColor :: Bool
colScheme :: Scheme
profAuto :: ProfAuto
what kind of {--} to add automatically
interactivePrint :: Maybe String
nextWrapperNum :: IORef (ModuleEnv Int)
sseVersion :: Maybe SseVersion
Machine dependent flags (-mblah stuff)
avx :: Bool
avx2 :: Bool
avx512cd :: Bool
avx512er :: Bool
avx512f :: Bool
avx512pf :: Bool
rtldInfo :: IORef (Maybe LinkerInfo)
Run-time linker information (what options we need, etc.)
rtccInfo :: IORef (Maybe CompilerInfo)
Run-time compiler information
maxInlineAllocSize :: Int
Max size, in bytes, of inline array allocations.
maxInlineMemcpyInsns :: Int
Only inline memcpy if it generates no more than this many pseudo (roughly: Cmm) instructions.
maxInlineMemsetInsns :: Int
Only inline memset if it generates no more than this many pseudo (roughly: Cmm) instructions.
reverseErrors :: Bool
Reverse the order of error messages in GHC/GHCi
maxErrors :: Maybe Int
Limit the maximum number of errors to show
initialUnique :: Int
Unique supply configuration for testing build determinism
uniqueIncrement :: Int

data FlagSpec flag Source #

Constructors

FlagSpec
Fields flagSpecName :: String Flag in string form flagSpecFlag :: flag Flag in internal form flagSpecAction :: TurnOnFlag -> DynP () Extra action to run when the flag is found Typically, emit a warning or error flagSpecGhcMode :: GhcFlagMode In which ghc mode the flag has effect

class HasDynFlags m where Source #

Minimal complete definition

getDynFlags

Methods

getDynFlags :: m DynFlags Source #

Instances

HasDynFlags PD Source #
Methods getDynFlags :: PD DynFlags Source #
HasDynFlags LlvmM Source #
Methods getDynFlags :: LlvmM DynFlags Source #
HasDynFlags FCode Source #
Methods getDynFlags :: FCode DynFlags Source #
HasDynFlags CmmParse Source #
Methods getDynFlags :: CmmParse DynFlags Source #
HasDynFlags Hsc Source #
Methods getDynFlags :: Hsc DynFlags Source #
HasDynFlags CompPipeline Source #
Methods getDynFlags :: CompPipeline DynFlags Source #
HasDynFlags Ghc Source #
Methods getDynFlags :: Ghc DynFlags Source #
HasDynFlags CoreM Source #
Methods getDynFlags :: CoreM DynFlags Source #
HasDynFlags SimplM Source #
Methods getDynFlags :: SimplM DynFlags Source #
HasDynFlags TcS Source #
Methods getDynFlags :: TcS DynFlags Source #
HasDynFlags VM Source #
Methods getDynFlags :: VM DynFlags Source #
HasDynFlags NatM Source #
Methods getDynFlags :: NatM DynFlags Source #
(Monad m, HasDynFlags m) => HasDynFlags (MaybeT m) Source #
Methods getDynFlags :: MaybeT m DynFlags Source #
ContainsDynFlags env => HasDynFlags (IOEnv env) Source #
Methods getDynFlags :: IOEnv env DynFlags Source #
HasDynFlags (RegM a) Source #
Methods getDynFlags :: RegM a DynFlags Source #
MonadIO m => HasDynFlags (GhcT m) Source #
Methods getDynFlags :: GhcT m DynFlags Source #
(Monoid a, Monad m, HasDynFlags m) => HasDynFlags (WriterT a m) Source #
Methods getDynFlags :: WriterT a m DynFlags Source #
(Monad m, HasDynFlags m) => HasDynFlags (ExceptT e m) Source #
Methods getDynFlags :: ExceptT e m DynFlags Source #
(Monad m, HasDynFlags m) => HasDynFlags (ReaderT * a m) Source #
Methods getDynFlags :: ReaderT * a m DynFlags Source #

class ContainsDynFlags t where Source #

Minimal complete definition

extractDynFlags

Methods

extractDynFlags :: t -> DynFlags Source #

Instances

ContainsDynFlags (Env gbl lcl) Source #
Methods extractDynFlags :: Env gbl lcl -> DynFlags Source #

data RtsOptsEnabled Source #

Constructors

RtsOptsNone
RtsOptsSafeOnly
RtsOptsAll

Instances

Show RtsOptsEnabled Source #
Methods showsPrec :: Int -> RtsOptsEnabled -> ShowS # show :: RtsOptsEnabled -> String # showList :: [RtsOptsEnabled] -> ShowS #

data HscTarget Source #

The target code type of the compilation (if any).

Whenever you change the target, also make sure to set ghcLink to something sensible.

HscNothing can be used to avoid generating any output, however, note that:

If a program uses Template Haskell the typechecker may try to run code from an imported module. This will fail if no code has been generated for this module. You can use needsTemplateHaskell to detect whether this might be the case and choose to either switch to a different target or avoid typechecking such modules. (The latter may be preferable for security reasons.)

Constructors

HscC	Generate C code.
HscAsm	Generate assembly using the native code generator.
HscLlvm	Generate assembly using the llvm code generator.
HscInterpreted	Generate bytecode. (Requires `LinkInMemory`)
HscNothing	Don't generate any code. See notes above.

Instances

Eq HscTarget Source #
Methods (==) :: HscTarget -> HscTarget -> Bool # (/=) :: HscTarget -> HscTarget -> Bool #
Show HscTarget Source #
Methods showsPrec :: Int -> HscTarget -> ShowS # show :: HscTarget -> String # showList :: [HscTarget] -> ShowS #

isObjectTarget :: HscTarget -> Bool Source #

Will this target result in an object file on the disk?

defaultObjectTarget :: Platform -> HscTarget Source #

The HscTarget value corresponding to the default way to create object files on the current platform.

targetRetainsAllBindings :: HscTarget -> Bool Source #

Does this target retain *all* top-level bindings for a module, rather than just the exported bindings, in the TypeEnv and compiled code (if any)? In interpreted mode we do this, so that GHCi can call functions inside a module. In HscNothing mode we also do it, so that Haddock can get access to the GlobalRdrEnv for a module after typechecking it.

data GhcMode Source #

The GhcMode tells us whether we're doing multi-module compilation (controlled via the GHC API) or one-shot (single-module) compilation. This makes a difference primarily to the Finder: in one-shot mode we look for interface files for imported modules, but in multi-module mode we look for source files in order to check whether they need to be recompiled.

Constructors

CompManager	`--make`, GHCi, etc.
OneShot	ghc -c Foo.hs
MkDepend	`ghc -M`, see Finder for why we need this

Instances

Eq GhcMode Source #
Methods (==) :: GhcMode -> GhcMode -> Bool # (/=) :: GhcMode -> GhcMode -> Bool #
Outputable GhcMode Source #
Methods ppr :: GhcMode -> SDoc Source # pprPrec :: Rational -> GhcMode -> SDoc Source #

isOneShot :: GhcMode -> Bool Source #

data GhcLink Source #

What to do in the link step, if there is one.

Constructors

NoLink	Don't link at all
LinkBinary	Link object code into a binary
LinkInMemory	Use the in-memory dynamic linker (works for both bytecode and object code).
LinkDynLib	Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
LinkStaticLib	Link objects into a static lib

Instances

Eq GhcLink Source #
Methods (==) :: GhcLink -> GhcLink -> Bool # (/=) :: GhcLink -> GhcLink -> Bool #
Show GhcLink Source #
Methods showsPrec :: Int -> GhcLink -> ShowS # show :: GhcLink -> String # showList :: [GhcLink] -> ShowS #

isNoLink :: GhcLink -> Bool Source #

data PackageFlag Source #

Flags for manipulating packages visibility.

Constructors

ExposePackage String PackageArg ModRenaming	`-package`, `-package-id`
HidePackage String	-hide-package

Instances

Eq PackageFlag Source #
Methods (==) :: PackageFlag -> PackageFlag -> Bool # (/=) :: PackageFlag -> PackageFlag -> Bool #
Outputable PackageFlag Source #
Methods ppr :: PackageFlag -> SDoc Source # pprPrec :: Rational -> PackageFlag -> SDoc Source #

data PackageArg Source #

We accept flags which make packages visible, but how they select the package varies; this data type reflects what selection criterion is used.

Constructors

PackageArg String	`-package`, by `PackageName`
UnitIdArg UnitId	`-package-id`, by `UnitId`

Instances

Eq PackageArg Source #
Methods (==) :: PackageArg -> PackageArg -> Bool # (/=) :: PackageArg -> PackageArg -> Bool #
Show PackageArg Source #
Methods showsPrec :: Int -> PackageArg -> ShowS # show :: PackageArg -> String # showList :: [PackageArg] -> ShowS #
Outputable PackageArg Source #
Methods ppr :: PackageArg -> SDoc Source # pprPrec :: Rational -> PackageArg -> SDoc Source #

data ModRenaming Source #

Represents the renaming that may be associated with an exposed package, e.g. the rns part of -package "foo (rns)".

Here are some example parsings of the package flags (where a string literal is punned to be a ModuleName:

-package foo is ModRenaming True []
-package foo () is ModRenaming False []
-package foo (A) is ModRenaming False [(A, A)]
-package foo (A as B) is ModRenaming False [(A, B)]
-package foo with (A as B) is ModRenaming True [(A, B)]

Constructors

ModRenaming
Fields modRenamingWithImplicit :: Bool Bring all exposed modules into scope? modRenamings :: [(ModuleName, ModuleName)] Bring module `m` into scope under name `n`.

Instances

Eq ModRenaming Source #
Methods (==) :: ModRenaming -> ModRenaming -> Bool # (/=) :: ModRenaming -> ModRenaming -> Bool #
Outputable ModRenaming Source #
Methods ppr :: ModRenaming -> SDoc Source # pprPrec :: Rational -> ModRenaming -> SDoc Source #

packageFlagsChanged :: DynFlags -> DynFlags -> Bool Source #

newtype IgnorePackageFlag Source #

Flags for manipulating the set of non-broken packages.

Constructors

IgnorePackage String

-ignore-package

Instances

Eq IgnorePackageFlag Source #
Methods (==) :: IgnorePackageFlag -> IgnorePackageFlag -> Bool # (/=) :: IgnorePackageFlag -> IgnorePackageFlag -> Bool #

data TrustFlag Source #

Flags for manipulating package trust.

Constructors

TrustPackage String	-trust
DistrustPackage String	-distrust

Instances

Eq TrustFlag Source #
Methods (==) :: TrustFlag -> TrustFlag -> Bool # (/=) :: TrustFlag -> TrustFlag -> Bool #

data PackageDBFlag Source #

Constructors

PackageDB PkgConfRef
NoUserPackageDB
NoGlobalPackageDB
ClearPackageDBs

Instances

Eq PackageDBFlag Source #
Methods (==) :: PackageDBFlag -> PackageDBFlag -> Bool # (/=) :: PackageDBFlag -> PackageDBFlag -> Bool #

data PkgConfRef Source #

Constructors

GlobalPkgConf
UserPkgConf
PkgConfFile FilePath

Instances

Eq PkgConfRef Source #
Methods (==) :: PkgConfRef -> PkgConfRef -> Bool # (/=) :: PkgConfRef -> PkgConfRef -> Bool #

data Option Source #

When invoking external tools as part of the compilation pipeline, we pass these a sequence of options on the command-line. Rather than just using a list of Strings, we use a type that allows us to distinguish between filepaths and 'other stuff'. The reason for this is that this type gives us a handle on transforming filenames, and filenames only, to whatever format they're expected to be on a particular platform.

Constructors

FileOption String String
Option String

Instances

Eq Option Source #
Methods (==) :: Option -> Option -> Bool # (/=) :: Option -> Option -> Bool #

showOpt :: Option -> String Source #

data DynLibLoader Source #

Constructors

Deployable
SystemDependent

Instances

Eq DynLibLoader Source #
Methods (==) :: DynLibLoader -> DynLibLoader -> Bool # (/=) :: DynLibLoader -> DynLibLoader -> Bool #

fFlags :: [FlagSpec GeneralFlag] Source #

These -f<blah> flags can all be reversed with -fno-<blah>

fLangFlags :: [FlagSpec Extension] Source #

These -f<blah> flags can all be reversed with -fno-<blah>

xFlags :: [FlagSpec Extension] Source #

These -Xblah flags can all be reversed with -XNoblah

wWarningFlags :: [FlagSpec WarningFlag] Source #

These -W<blah> flags can all be reversed with -Wno-<blah>

dynFlagDependencies :: DynFlags -> [ModuleName] Source #

Some modules have dependencies on others through the DynFlags rather than textual imports

tablesNextToCode :: DynFlags -> Bool Source #

mkTablesNextToCode :: Bool -> Bool Source #

makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String]) Source #

Resolve any internal inconsistencies in a set of DynFlags. Returns the consistent DynFlags as well as a list of warnings to report to the user.

shouldUseColor :: DynFlags -> Bool Source #

positionIndependent :: DynFlags -> Bool Source #

Are we building with -fPIE or -fPIC enabled?

data Way Source #

Constructors

WayCustom String
WayThreaded
WayDebug
WayProf
WayEventLog
WayDyn

Instances

Eq Way Source #
Methods (==) :: Way -> Way -> Bool # (/=) :: Way -> Way -> Bool #
Ord Way Source #
Methods compare :: Way -> Way -> Ordering # (<) :: Way -> Way -> Bool # (<=) :: Way -> Way -> Bool # (>) :: Way -> Way -> Bool # (>=) :: Way -> Way -> Bool # max :: Way -> Way -> Way # min :: Way -> Way -> Way #
Show Way Source #
Methods showsPrec :: Int -> Way -> ShowS # show :: Way -> String # showList :: [Way] -> ShowS #

mkBuildTag :: [Way] -> String Source #

wayRTSOnly :: Way -> Bool Source #

addWay' :: Way -> DynFlags -> DynFlags Source #

updateWays :: DynFlags -> DynFlags Source #

wayGeneralFlags :: Platform -> Way -> [GeneralFlag] Source #

wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag] Source #

thisPackage :: DynFlags -> UnitId Source #

thisComponentId :: DynFlags -> ComponentId Source #

thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)] Source #

Log output

putLogMsg :: DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO () Source #

Write an error or warning to the LogOutput.

Safe Haskell

data SafeHaskellMode Source #

The various Safe Haskell modes

Constructors

Sf_None
Sf_Unsafe
Sf_Trustworthy
Sf_Safe

Instances

Eq SafeHaskellMode Source #
Methods (==) :: SafeHaskellMode -> SafeHaskellMode -> Bool # (/=) :: SafeHaskellMode -> SafeHaskellMode -> Bool #
Show SafeHaskellMode Source #
Methods showsPrec :: Int -> SafeHaskellMode -> ShowS # show :: SafeHaskellMode -> String # showList :: [SafeHaskellMode] -> ShowS #
Outputable SafeHaskellMode Source #
Methods ppr :: SafeHaskellMode -> SDoc Source # pprPrec :: Rational -> SafeHaskellMode -> SDoc Source #

safeHaskellOn :: DynFlags -> Bool Source #

Is Safe Haskell on in some way (including inference mode)

safeImportsOn :: DynFlags -> Bool Source #

Test if Safe Imports are on in some form

safeLanguageOn :: DynFlags -> Bool Source #

Is the Safe Haskell safe language in use

safeInferOn :: DynFlags -> Bool Source #

Is the Safe Haskell safe inference mode active

packageTrustOn :: DynFlags -> Bool Source #

Is the -fpackage-trust mode on

safeDirectImpsReq :: DynFlags -> Bool Source #

Are all direct imports required to be safe for this Safe Haskell mode? Direct imports are when the code explicitly imports a module

safeImplicitImpsReq :: DynFlags -> Bool Source #

Are all implicit imports required to be safe for this Safe Haskell mode? Implicit imports are things in the prelude. e.g System.IO when print is used.

unsafeFlags :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)] Source #

A list of unsafe flags under Safe Haskell. Tuple elements are: * name of the flag * function to get srcspan that enabled the flag * function to test if the flag is on * function to turn the flag off

unsafeFlagsForInfer :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)] Source #

A list of unsafe flags under Safe Haskell. Tuple elements are: * name of the flag * function to get srcspan that enabled the flag * function to test if the flag is on * function to turn the flag off

System tool settings and locations

data Settings Source #

Constructors

Settings

Fields

targetPlatform :: DynFlags -> Platform Source #

programName :: DynFlags -> String Source #

projectVersion :: DynFlags -> String Source #

ghcUsagePath :: DynFlags -> FilePath Source #

ghciUsagePath :: DynFlags -> FilePath Source #

topDir :: DynFlags -> FilePath Source #

tmpDir :: DynFlags -> String Source #

rawSettings :: DynFlags -> [(String, String)] Source #

versionedAppDir :: DynFlags -> MaybeT IO FilePath Source #

The directory for this version of ghc in the user's app directory (typically something like ~.ghcx86_64-linux-7.6.3)

extraGccViaCFlags :: DynFlags -> [String] Source #

systemPackageConfig :: DynFlags -> FilePath Source #

pgm_L :: DynFlags -> String Source #

pgm_P :: DynFlags -> (String, [Option]) Source #

pgm_F :: DynFlags -> String Source #

pgm_c :: DynFlags -> (String, [Option]) Source #

pgm_s :: DynFlags -> (String, [Option]) Source #

pgm_a :: DynFlags -> (String, [Option]) Source #

pgm_l :: DynFlags -> (String, [Option]) Source #

pgm_dll :: DynFlags -> (String, [Option]) Source #

pgm_T :: DynFlags -> String Source #

pgm_windres :: DynFlags -> String Source #

pgm_libtool :: DynFlags -> String Source #

pgm_lo :: DynFlags -> (String, [Option]) Source #

pgm_lc :: DynFlags -> (String, [Option]) Source #

pgm_i :: DynFlags -> String Source #

opt_L :: DynFlags -> [String] Source #

opt_P :: DynFlags -> [String] Source #

opt_F :: DynFlags -> [String] Source #

opt_c :: DynFlags -> [String] Source #

opt_a :: DynFlags -> [String] Source #

opt_l :: DynFlags -> [String] Source #

opt_i :: DynFlags -> [String] Source #

opt_windres :: DynFlags -> [String] Source #

opt_lo :: DynFlags -> [String] Source #

opt_lc :: DynFlags -> [String] Source #

Manipulating DynFlags

defaultDynFlags :: Settings -> DynFlags Source #

The normal DynFlags. Note that they are not suitable for use in this form and must be fully initialized by runGhc first.

defaultWays :: Settings -> [Way] Source #

interpWays :: [Way] Source #

interpreterProfiled :: DynFlags -> Bool Source #

interpreterDynamic :: DynFlags -> Bool Source #

initDynFlags :: DynFlags -> IO DynFlags Source #

Used by runGhc to partially initialize a new DynFlags value

defaultFatalMessager :: FatalMessager Source #

defaultLogAction :: LogAction Source #

defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO () Source #

Like defaultLogActionHPutStrDoc but appends an extra newline.

defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO () Source #

defaultFlushOut :: FlushOut Source #

defaultFlushErr :: FlushErr Source #

getOpts Source #

Arguments

:: DynFlags	`DynFlags` to retrieve the options from
-> (DynFlags -> [a])	Relevant record accessor: one of the `opt_*` accessors
-> [a]	Correctly ordered extracted options

Retrieve the options corresponding to a particular opt_* field in the correct order

getVerbFlags :: DynFlags -> [String] Source #

Gets the verbosity flag for the current verbosity level. This is fed to other tools, so GHC-specific verbosity flags like -ddump-most are not included

updOptLevel :: Int -> DynFlags -> DynFlags Source #

Sets the DynFlags to be appropriate to the optimisation level

setTmpDir :: FilePath -> DynFlags -> DynFlags Source #

setUnitId :: String -> DynFlags -> DynFlags Source #

interpretPackageEnv :: DynFlags -> IO DynFlags Source #

Find the package environment (if one exists)

We interpret the package environment as a set of package flags; to be specific, if we find a package environment file like

clear-package-db
global-package-db
package-db blah/package.conf.d
package-id id1
package-id id2

we interpret this as

[ -hide-all-packages
, -clear-package-db
, -global-package-db
, -package-db blah/package.conf.d
, -package-id id1
, -package-id id2
]

There's also an older syntax alias for package-id, which is just an unadorned package id

id1
id2

canonicalizeHomeModule :: DynFlags -> ModuleName -> Module Source #

Given a ModuleName of a signature in the home library, find out how it is instantiated. E.g., the canonical form of A in p[A=q[]:A] is q[]:A.

Parsing DynFlags

parseDynamicFlagsCmdLine Source #

Arguments

:: MonadIO m
=> DynFlags
-> [Located String]
-> m (DynFlags, [Located String], [Located String])	Updated `DynFlags`, left-over arguments, and list of warnings.

Parse dynamic flags from a list of command line arguments. Returns the the parsed DynFlags, the left-over arguments, and a list of warnings. Throws a UsageError if errors occurred during parsing (such as unknown flags or missing arguments).

parseDynamicFilePragma Source #

Arguments

:: MonadIO m
=> DynFlags
-> [Located String]
-> m (DynFlags, [Located String], [Located String])	Updated `DynFlags`, left-over arguments, and list of warnings.

Like parseDynamicFlagsCmdLine but does not allow the package flags (-package, -hide-package, -ignore-package, -hide-all-packages, -package-db). Used to parse flags set in a modules pragma.

parseDynamicFlagsFull Source #

Arguments

:: MonadIO m
=> [Flag (CmdLineP DynFlags)]	valid flags to match against
-> Bool	are the arguments from the command line?
-> DynFlags	current dynamic flags
-> [Located String]	arguments to parse
-> m (DynFlags, [Located String], [Located String])

Parses the dynamically set flags for GHC. This is the most general form of the dynamic flag parser that the other methods simply wrap. It allows saying which flags are valid flags and indicating if we are parsing arguments from the command line or from a file pragma.