Overhaul the Overhauled Pattern Match Checker
[ghc.git] / compiler / main / DynFlags.hs
1 {-# LANGUAGE CPP #-}
2 {-# LANGUAGE FlexibleInstances #-}
3
4 -------------------------------------------------------------------------------
5 --
6 -- | Dynamic flags
7 --
8 -- Most flags are dynamic flags, which means they can change from compilation
9 -- to compilation using @OPTIONS_GHC@ pragmas, and in a multi-session GHC each
10 -- session can be using different dynamic flags. Dynamic flags can also be set
11 -- at the prompt in GHCi.
12 --
13 -- (c) The University of Glasgow 2005
14 --
15 -------------------------------------------------------------------------------
16
17 {-# OPTIONS_GHC -fno-cse #-}
18 -- -fno-cse is needed for GLOBAL_VAR's to behave properly
19
20 module DynFlags (
21 -- * Dynamic flags and associated configuration types
22 DumpFlag(..),
23 GeneralFlag(..),
24 WarningFlag(..),
25 Language(..),
26 PlatformConstants(..),
27 FatalMessager, LogAction, FlushOut(..), FlushErr(..),
28 ProfAuto(..),
29 glasgowExtsFlags,
30 dopt, dopt_set, dopt_unset,
31 gopt, gopt_set, gopt_unset, setGeneralFlag', unSetGeneralFlag',
32 wopt, wopt_set, wopt_unset,
33 xopt, xopt_set, xopt_unset,
34 lang_set,
35 useUnicodeSyntax,
36 whenGeneratingDynamicToo, ifGeneratingDynamicToo,
37 whenCannotGenerateDynamicToo,
38 dynamicTooMkDynamicDynFlags,
39 DynFlags(..),
40 FlagSpec(..),
41 HasDynFlags(..), ContainsDynFlags(..),
42 RtsOptsEnabled(..),
43 HscTarget(..), isObjectTarget, defaultObjectTarget,
44 targetRetainsAllBindings,
45 GhcMode(..), isOneShot,
46 GhcLink(..), isNoLink,
47 PackageFlag(..), PackageArg(..), ModRenaming(..),
48 IgnorePackageFlag(..), TrustFlag(..),
49 PkgConfRef(..),
50 Option(..), showOpt,
51 DynLibLoader(..),
52 fFlags, fLangFlags, xFlags,
53 wWarningFlags,
54 dynFlagDependencies,
55 tablesNextToCode, mkTablesNextToCode,
56 SigOf, getSigOf,
57 makeDynFlagsConsistent,
58
59 Way(..), mkBuildTag, wayRTSOnly, addWay', updateWays,
60 wayGeneralFlags, wayUnsetGeneralFlags,
61
62 -- ** Safe Haskell
63 SafeHaskellMode(..),
64 safeHaskellOn, safeImportsOn, safeLanguageOn, safeInferOn,
65 packageTrustOn,
66 safeDirectImpsReq, safeImplicitImpsReq,
67 unsafeFlags, unsafeFlagsForInfer,
68
69 -- ** System tool settings and locations
70 Settings(..),
71 targetPlatform, programName, projectVersion,
72 ghcUsagePath, ghciUsagePath, topDir, tmpDir, rawSettings,
73 versionedAppDir,
74 extraGccViaCFlags, systemPackageConfig,
75 pgm_L, pgm_P, pgm_F, pgm_c, pgm_s, pgm_a, pgm_l, pgm_dll, pgm_T,
76 pgm_windres, pgm_libtool, pgm_lo, pgm_lc, pgm_i,
77 opt_L, opt_P, opt_F, opt_c, opt_a, opt_l, opt_i,
78 opt_windres, opt_lo, opt_lc,
79
80
81 -- ** Manipulating DynFlags
82 defaultDynFlags, -- Settings -> DynFlags
83 defaultWays,
84 interpWays,
85 interpreterProfiled, interpreterDynamic,
86 initDynFlags, -- DynFlags -> IO DynFlags
87 defaultFatalMessager,
88 defaultLogAction,
89 defaultLogActionHPrintDoc,
90 defaultLogActionHPutStrDoc,
91 defaultFlushOut,
92 defaultFlushErr,
93
94 getOpts, -- DynFlags -> (DynFlags -> [a]) -> [a]
95 getVerbFlags,
96 updOptLevel,
97 setTmpDir,
98 setUnitId,
99 interpretPackageEnv,
100
101 -- ** Parsing DynFlags
102 parseDynamicFlagsCmdLine,
103 parseDynamicFilePragma,
104 parseDynamicFlagsFull,
105
106 -- ** Available DynFlags
107 allFlags,
108 flagsAll,
109 flagsDynamic,
110 flagsPackage,
111 flagsForCompletion,
112
113 supportedLanguagesAndExtensions,
114 languageExtensions,
115
116 -- ** DynFlags C compiler options
117 picCCOpts, picPOpts,
118
119 -- * Compiler configuration suitable for display to the user
120 compilerInfo,
121
122 #ifdef GHCI
123 rtsIsProfiled,
124 #endif
125 dynamicGhc,
126
127 #include "../includes/dist-derivedconstants/header/GHCConstantsHaskellExports.hs"
128 bLOCK_SIZE_W,
129 wORD_SIZE_IN_BITS,
130 tAG_MASK,
131 mAX_PTR_TAG,
132 tARGET_MIN_INT, tARGET_MAX_INT, tARGET_MAX_WORD,
133
134 unsafeGlobalDynFlags, setUnsafeGlobalDynFlags,
135
136 -- * SSE and AVX
137 isSseEnabled,
138 isSse2Enabled,
139 isSse4_2Enabled,
140 isAvxEnabled,
141 isAvx2Enabled,
142 isAvx512cdEnabled,
143 isAvx512erEnabled,
144 isAvx512fEnabled,
145 isAvx512pfEnabled,
146
147 -- * Linker/compiler information
148 LinkerInfo(..),
149 CompilerInfo(..),
150 ) where
151
152 #include "HsVersions.h"
153
154 import Platform
155 import PlatformConstants
156 import Module
157 import PackageConfig
158 import {-# SOURCE #-} Hooks
159 import {-# SOURCE #-} PrelNames ( mAIN )
160 import {-# SOURCE #-} Packages (PackageState, emptyPackageState)
161 import DriverPhases ( Phase(..), phaseInputExt )
162 import Config
163 import CmdLineParser
164 import Constants
165 import Panic
166 import Util
167 import Maybes
168 import MonadUtils
169 import qualified Pretty
170 import SrcLoc
171 import BasicTypes ( IntWithInf, treatZeroAsInf )
172 import FastString
173 import Outputable
174 import Foreign.C ( CInt(..) )
175 import System.IO.Unsafe ( unsafeDupablePerformIO )
176 import {-# SOURCE #-} ErrUtils ( Severity(..), MsgDoc, mkLocMessage )
177
178 import System.IO.Unsafe ( unsafePerformIO )
179 import Data.IORef
180 import Control.Arrow ((&&&))
181 import Control.Monad
182 import Control.Monad.Trans.Class
183 import Control.Monad.Trans.Writer
184 import Control.Monad.Trans.Reader
185 import Control.Monad.Trans.Except
186 import Control.Exception (throwIO)
187
188 import Data.Bits
189 import Data.Char
190 import Data.Int
191 import Data.List
192 import Data.Map (Map)
193 import qualified Data.Map as Map
194 import Data.Set (Set)
195 import qualified Data.Set as Set
196 import Data.Word
197 import System.FilePath
198 import System.Directory
199 import System.Environment (getEnv)
200 import System.IO
201 import System.IO.Error
202 import Text.ParserCombinators.ReadP hiding (char)
203 import Text.ParserCombinators.ReadP as R
204
205 import Data.IntSet (IntSet)
206 import qualified Data.IntSet as IntSet
207
208 import GHC.Foreign (withCString, peekCString)
209 import qualified GHC.LanguageExtensions as LangExt
210
211 -- Note [Updating flag description in the User's Guide]
212 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
213 --
214 -- If you modify anything in this file please make sure that your changes are
215 -- described in the User's Guide. Usually at least two sections need to be
216 -- updated:
217 --
218 -- * Flag Reference section generated from the modules in
219 -- utils/mkUserGuidePart/Options
220 --
221 -- * Flag description in docs/users_guide/using.rst provides a detailed
222 -- explanation of flags' usage.
223
224 -- Note [Supporting CLI completion]
225 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
226 --
227 -- The command line interface completion (in for example bash) is an easy way
228 -- for the developer to learn what flags are available from GHC.
229 -- GHC helps by separating which flags are available when compiling with GHC,
230 -- and which flags are available when using GHCi.
231 -- A flag is assumed to either work in both these modes, or only in one of them.
232 -- When adding or changing a flag, please consider for which mode the flag will
233 -- have effect, and annotate it accordingly. For Flags use defFlag, defGhcFlag,
234 -- defGhciFlag, and for FlagSpec use flagSpec or flagGhciSpec.
235
236 -- Note [Adding a language extension]
237 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
238 --
239 -- There are a few steps to adding (or removing) a language extension,
240 --
241 -- * Adding the extension to GHC.LanguageExtensions
242 --
243 -- The Extension type in libraries/ghc-boot/GHC/LanguageExtensions.hs is
244 -- the canonical list of language extensions known by GHC.
245 --
246 -- * Adding a flag to DynFlags.xFlags
247 --
248 -- This is fairly self-explanatory. The name should be concise, memorable,
249 -- and consistent with any previous implementations of the similar idea in
250 -- other Haskell compilers.
251 --
252 -- * Adding the flag to the documentation
253 --
254 -- This is the same as any other flag. See
255 -- Note [Updating flag description in the User's Guide]
256 --
257 -- * Adding the flag to Cabal
258 --
259 -- The Cabal library has its own list of all language extensions supported
260 -- by all major compilers. This is the list that user code being uploaded
261 -- to Hackage is checked against to ensure language extension validity.
262 -- Consequently, it is very important that this list remains up-to-date.
263 --
264 -- To this end, there is a testsuite test (testsuite/tests/driver/T4437.hs)
265 -- whose job it is to ensure these GHC's extensions are consistent with
266 -- Cabal.
267 --
268 -- The recommended workflow is,
269 --
270 -- 1. Temporarily add your new language extension to the
271 -- expectedGhcOnlyExtensions list in T4437 to ensure the test doesn't
272 -- break while Cabal is updated.
273 --
274 -- 2. After your GHC change is accepted, submit a Cabal pull request adding
275 -- your new extension to Cabal's list (found in
276 -- Cabal/Language/Haskell/Extension.hs).
277 --
278 -- 3. After your Cabal change is accepted, let the GHC developers know so
279 -- they can update the Cabal submodule and remove the extensions from
280 -- expectedGhcOnlyExtensions.
281 --
282 -- * Adding the flag to the GHC Wiki
283 --
284 -- There is a change log tracking language extension additions and removals
285 -- on the GHC wiki: https://ghc.haskell.org/trac/ghc/wiki/LanguagePragmaHistory
286 --
287 -- See Trac #4437 and #8176.
288
289 -- -----------------------------------------------------------------------------
290 -- DynFlags
291
292 data DumpFlag
293 -- See Note [Updating flag description in the User's Guide]
294
295 -- debugging flags
296 = Opt_D_dump_cmm
297 | Opt_D_dump_cmm_raw
298 -- All of the cmm subflags (there are a lot!) Automatically
299 -- enabled if you run -ddump-cmm
300 | Opt_D_dump_cmm_cfg
301 | Opt_D_dump_cmm_cbe
302 | Opt_D_dump_cmm_switch
303 | Opt_D_dump_cmm_proc
304 | Opt_D_dump_cmm_sink
305 | Opt_D_dump_cmm_sp
306 | Opt_D_dump_cmm_procmap
307 | Opt_D_dump_cmm_split
308 | Opt_D_dump_cmm_info
309 | Opt_D_dump_cmm_cps
310 -- end cmm subflags
311 | Opt_D_dump_asm
312 | Opt_D_dump_asm_native
313 | Opt_D_dump_asm_liveness
314 | Opt_D_dump_asm_regalloc
315 | Opt_D_dump_asm_regalloc_stages
316 | Opt_D_dump_asm_conflicts
317 | Opt_D_dump_asm_stats
318 | Opt_D_dump_asm_expanded
319 | Opt_D_dump_llvm
320 | Opt_D_dump_core_stats
321 | Opt_D_dump_deriv
322 | Opt_D_dump_ds
323 | Opt_D_dump_foreign
324 | Opt_D_dump_inlinings
325 | Opt_D_dump_rule_firings
326 | Opt_D_dump_rule_rewrites
327 | Opt_D_dump_simpl_trace
328 | Opt_D_dump_occur_anal
329 | Opt_D_dump_parsed
330 | Opt_D_dump_rn
331 | Opt_D_dump_simpl
332 | Opt_D_dump_simpl_iterations
333 | Opt_D_dump_spec
334 | Opt_D_dump_prep
335 | Opt_D_dump_stg
336 | Opt_D_dump_call_arity
337 | Opt_D_dump_stranal
338 | Opt_D_dump_strsigs
339 | Opt_D_dump_tc
340 | Opt_D_dump_types
341 | Opt_D_dump_rules
342 | Opt_D_dump_cse
343 | Opt_D_dump_worker_wrapper
344 | Opt_D_dump_rn_trace
345 | Opt_D_dump_rn_stats
346 | Opt_D_dump_opt_cmm
347 | Opt_D_dump_simpl_stats
348 | Opt_D_dump_cs_trace -- Constraint solver in type checker
349 | Opt_D_dump_tc_trace
350 | Opt_D_dump_if_trace
351 | Opt_D_dump_vt_trace
352 | Opt_D_dump_splices
353 | Opt_D_th_dec_file
354 | Opt_D_dump_BCOs
355 | Opt_D_dump_vect
356 | Opt_D_dump_ticked
357 | Opt_D_dump_rtti
358 | Opt_D_source_stats
359 | Opt_D_verbose_stg2stg
360 | Opt_D_dump_hi
361 | Opt_D_dump_hi_diffs
362 | Opt_D_dump_mod_cycles
363 | Opt_D_dump_mod_map
364 | Opt_D_dump_view_pattern_commoning
365 | Opt_D_verbose_core2core
366 | Opt_D_dump_debug
367
368 deriving (Eq, Show, Enum)
369
370 -- | Enumerates the simple on-or-off dynamic flags
371 data GeneralFlag
372 -- See Note [Updating flag description in the User's Guide]
373
374 = Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
375 | Opt_D_faststring_stats
376 | Opt_D_dump_minimal_imports
377 | Opt_DoCoreLinting
378 | Opt_DoStgLinting
379 | Opt_DoCmmLinting
380 | Opt_DoAsmLinting
381 | Opt_DoAnnotationLinting
382 | Opt_NoLlvmMangler -- hidden flag
383
384 | Opt_WarnIsError -- -Werror; makes warnings fatal
385
386 | Opt_PrintExplicitForalls
387 | Opt_PrintExplicitKinds
388 | Opt_PrintExplicitCoercions
389 | Opt_PrintEqualityRelations
390 | Opt_PrintUnicodeSyntax
391 | Opt_PrintExpandedSynonyms
392 | Opt_PrintPotentialInstances
393 | Opt_PrintTypecheckerElaboration
394
395 -- optimisation opts
396 | Opt_CallArity
397 | Opt_Strictness
398 | Opt_LateDmdAnal
399 | Opt_KillAbsence
400 | Opt_KillOneShot
401 | Opt_FullLaziness
402 | Opt_FloatIn
403 | Opt_Specialise
404 | Opt_SpecialiseAggressively
405 | Opt_CrossModuleSpecialise
406 | Opt_StaticArgumentTransformation
407 | Opt_CSE
408 | Opt_LiberateCase
409 | Opt_SpecConstr
410 | Opt_DoLambdaEtaExpansion
411 | Opt_IgnoreAsserts
412 | Opt_DoEtaReduction
413 | Opt_CaseMerge
414 | Opt_UnboxStrictFields
415 | Opt_UnboxSmallStrictFields
416 | Opt_DictsCheap
417 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
418 | Opt_Vectorise
419 | Opt_VectorisationAvoidance
420 | Opt_RegsGraph -- do graph coloring register allocation
421 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
422 | Opt_PedanticBottoms -- Be picky about how we treat bottom
423 | Opt_LlvmTBAA -- Use LLVM TBAA infastructure for improving AA (hidden flag)
424 | Opt_LlvmPassVectorsInRegisters -- Pass SIMD vectors in registers (requires a patched LLVM) (hidden flag)
425 | Opt_LlvmFillUndefWithGarbage -- Testing for undef bugs (hidden flag)
426 | Opt_IrrefutableTuples
427 | Opt_CmmSink
428 | Opt_CmmElimCommonBlocks
429 | Opt_OmitYields
430 | Opt_SimpleListLiterals
431 | Opt_FunToThunk -- allow WwLib.mkWorkerArgs to remove all value lambdas
432 | Opt_DictsStrict -- be strict in argument dictionaries
433 | Opt_DmdTxDictSel -- use a special demand transformer for dictionary selectors
434 | Opt_Loopification -- See Note [Self-recursive tail calls]
435 | Opt_CprAnal
436 | Opt_WorkerWrapper
437
438 -- Interface files
439 | Opt_IgnoreInterfacePragmas
440 | Opt_OmitInterfacePragmas
441 | Opt_ExposeAllUnfoldings
442 | Opt_WriteInterface -- forces .hi files to be written even with -fno-code
443
444 -- profiling opts
445 | Opt_AutoSccsOnIndividualCafs
446 | Opt_ProfCountEntries
447
448 -- misc opts
449 | Opt_Pp
450 | Opt_ForceRecomp
451 | Opt_ExcessPrecision
452 | Opt_EagerBlackHoling
453 | Opt_NoHsMain
454 | Opt_SplitObjs
455 | Opt_SplitSections
456 | Opt_StgStats
457 | Opt_HideAllPackages
458 | Opt_HideAllPluginPackages
459 | Opt_PrintBindResult
460 | Opt_Haddock
461 | Opt_HaddockOptions
462 | Opt_BreakOnException
463 | Opt_BreakOnError
464 | Opt_PrintEvldWithShow
465 | Opt_PrintBindContents
466 | Opt_GenManifest
467 | Opt_EmbedManifest
468 | Opt_SharedImplib
469 | Opt_BuildingCabalPackage
470 | Opt_IgnoreDotGhci
471 | Opt_GhciSandbox
472 | Opt_GhciHistory
473 | Opt_HelpfulErrors
474 | Opt_DeferTypeErrors
475 | Opt_DeferTypedHoles
476 | Opt_PIC
477 | Opt_SccProfilingOn
478 | Opt_Ticky
479 | Opt_Ticky_Allocd
480 | Opt_Ticky_LNE
481 | Opt_Ticky_Dyn_Thunk
482 | Opt_RPath
483 | Opt_RelativeDynlibPaths
484 | Opt_Hpc
485 | Opt_FlatCache
486 | Opt_ExternalInterpreter
487
488 -- PreInlining is on by default. The option is there just to see how
489 -- bad things get if you turn it off!
490 | Opt_SimplPreInlining
491
492 -- output style opts
493 | Opt_ErrorSpans -- Include full span info in error messages,
494 -- instead of just the start position.
495 | Opt_PprCaseAsLet
496 | Opt_PprShowTicks
497
498 -- Suppress all coercions, them replacing with '...'
499 | Opt_SuppressCoercions
500 | Opt_SuppressVarKinds
501 -- Suppress module id prefixes on variables.
502 | Opt_SuppressModulePrefixes
503 -- Suppress type applications.
504 | Opt_SuppressTypeApplications
505 -- Suppress info such as arity and unfoldings on identifiers.
506 | Opt_SuppressIdInfo
507 -- Suppress separate type signatures in core, but leave types on
508 -- lambda bound vars
509 | Opt_SuppressUnfoldings
510 -- Suppress the details of even stable unfoldings
511 | Opt_SuppressTypeSignatures
512 -- Suppress unique ids on variables.
513 -- Except for uniques, as some simplifier phases introduce new
514 -- variables that have otherwise identical names.
515 | Opt_SuppressUniques
516
517 -- temporary flags
518 | Opt_AutoLinkPackages
519 | Opt_ImplicitImportQualified
520
521 -- keeping stuff
522 | Opt_KeepHiDiffs
523 | Opt_KeepHcFiles
524 | Opt_KeepSFiles
525 | Opt_KeepTmpFiles
526 | Opt_KeepRawTokenStream
527 | Opt_KeepLlvmFiles
528
529 | Opt_BuildDynamicToo
530
531 -- safe haskell flags
532 | Opt_DistrustAllPackages
533 | Opt_PackageTrust
534 deriving (Eq, Show, Enum)
535
536 data WarningFlag =
537 -- See Note [Updating flag description in the User's Guide]
538 Opt_WarnDuplicateExports
539 | Opt_WarnDuplicateConstraints
540 | Opt_WarnRedundantConstraints
541 | Opt_WarnHiShadows
542 | Opt_WarnImplicitPrelude
543 | Opt_WarnIncompletePatterns
544 | Opt_WarnIncompleteUniPatterns
545 | Opt_WarnIncompletePatternsRecUpd
546 | Opt_WarnOverflowedLiterals
547 | Opt_WarnEmptyEnumerations
548 | Opt_WarnMissingFields
549 | Opt_WarnMissingImportList
550 | Opt_WarnMissingMethods
551 | Opt_WarnMissingSigs
552 | Opt_WarnMissingLocalSigs
553 | Opt_WarnNameShadowing
554 | Opt_WarnOverlappingPatterns
555 | Opt_WarnTypeDefaults
556 | Opt_WarnMonomorphism
557 | Opt_WarnUnusedTopBinds
558 | Opt_WarnUnusedLocalBinds
559 | Opt_WarnUnusedPatternBinds
560 | Opt_WarnUnusedImports
561 | Opt_WarnUnusedMatches
562 | Opt_WarnUnusedTypePatterns
563 | Opt_WarnUnusedForalls
564 | Opt_WarnContextQuantification -- remove in 8.2
565 | Opt_WarnWarningsDeprecations
566 | Opt_WarnDeprecatedFlags
567 | Opt_WarnAMP -- Introduced in GHC 7.8, obsolete since 7.10
568 | Opt_WarnMissingMonadFailInstances -- since 8.0
569 | Opt_WarnSemigroup -- since 8.0
570 | Opt_WarnDodgyExports
571 | Opt_WarnDodgyImports
572 | Opt_WarnOrphans
573 | Opt_WarnAutoOrphans
574 | Opt_WarnIdentities
575 | Opt_WarnTabs
576 | Opt_WarnUnrecognisedPragmas
577 | Opt_WarnDodgyForeignImports
578 | Opt_WarnUnusedDoBind
579 | Opt_WarnWrongDoBind
580 | Opt_WarnAlternativeLayoutRuleTransitional
581 | Opt_WarnUnsafe
582 | Opt_WarnSafe
583 | Opt_WarnTrustworthySafe
584 | Opt_WarnMissedSpecs
585 | Opt_WarnAllMissedSpecs
586 | Opt_WarnUnsupportedCallingConventions
587 | Opt_WarnUnsupportedLlvmVersion
588 | Opt_WarnInlineRuleShadowing
589 | Opt_WarnTypedHoles
590 | Opt_WarnPartialTypeSignatures
591 | Opt_WarnMissingExportedSigs
592 | Opt_WarnUntickedPromotedConstructors
593 | Opt_WarnDerivingTypeable
594 | Opt_WarnDeferredTypeErrors
595 | Opt_WarnNonCanonicalMonadInstances -- since 8.0
596 | Opt_WarnNonCanonicalMonadFailInstances -- since 8.0
597 | Opt_WarnNonCanonicalMonoidInstances -- since 8.0
598 | Opt_WarnMissingPatSynSigs -- since 8.0
599 | Opt_WarnUnrecognisedWarningFlags -- since 8.0
600 deriving (Eq, Show, Enum)
601
602 data Language = Haskell98 | Haskell2010
603 deriving (Eq, Enum, Show)
604
605 instance Outputable Language where
606 ppr = text . show
607
608 -- | The various Safe Haskell modes
609 data SafeHaskellMode
610 = Sf_None
611 | Sf_Unsafe
612 | Sf_Trustworthy
613 | Sf_Safe
614 deriving (Eq)
615
616 instance Show SafeHaskellMode where
617 show Sf_None = "None"
618 show Sf_Unsafe = "Unsafe"
619 show Sf_Trustworthy = "Trustworthy"
620 show Sf_Safe = "Safe"
621
622 instance Outputable SafeHaskellMode where
623 ppr = text . show
624
625 type SigOf = Map ModuleName Module
626
627 getSigOf :: DynFlags -> ModuleName -> Maybe Module
628 getSigOf dflags n = Map.lookup n (sigOf dflags)
629
630 -- | Contains not only a collection of 'GeneralFlag's but also a plethora of
631 -- information relating to the compilation of a single file or GHC session
632 data DynFlags = DynFlags {
633 ghcMode :: GhcMode,
634 ghcLink :: GhcLink,
635 hscTarget :: HscTarget,
636 settings :: Settings,
637 -- See Note [Signature parameters in TcGblEnv and DynFlags]
638 sigOf :: SigOf, -- ^ Compiling an hs-boot against impl.
639 verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels]
640 optLevel :: Int, -- ^ Optimisation level
641 debugLevel :: Int, -- ^ How much debug information to produce
642 simplPhases :: Int, -- ^ Number of simplifier phases
643 maxSimplIterations :: Int, -- ^ Max simplifier iterations
644 maxPmCheckIterations :: Int, -- ^ Max no iterations for pm checking
645 ruleCheck :: Maybe String,
646 strictnessBefore :: [Int], -- ^ Additional demand analysis
647
648 parMakeCount :: Maybe Int, -- ^ The number of modules to compile in parallel
649 -- in --make mode, where Nothing ==> compile as
650 -- many in parallel as there are CPUs.
651
652 enableTimeStats :: Bool, -- ^ Enable RTS timing statistics?
653 ghcHeapSize :: Maybe Int, -- ^ The heap size to set.
654
655 maxRelevantBinds :: Maybe Int, -- ^ Maximum number of bindings from the type envt
656 -- to show in type error messages
657 simplTickFactor :: Int, -- ^ Multiplier for simplifier ticks
658 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
659 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
660 specConstrRecursive :: Int, -- ^ Max number of specialisations for recursive types
661 -- Not optional; otherwise ForceSpecConstr can diverge.
662 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
663 floatLamArgs :: Maybe Int, -- ^ Arg count for lambda floating
664 -- See CoreMonad.FloatOutSwitches
665
666 historySize :: Int,
667
668 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
669 importPaths :: [FilePath],
670 mainModIs :: Module,
671 mainFunIs :: Maybe String,
672 reductionDepth :: IntWithInf, -- ^ Typechecker maximum stack depth
673 solverIterations :: IntWithInf, -- ^ Number of iterations in the constraints solver
674 -- Typically only 1 is needed
675
676 thisPackage :: UnitId, -- ^ key of package currently being compiled
677
678 -- ways
679 ways :: [Way], -- ^ Way flags from the command line
680 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
681 rtsBuildTag :: String, -- ^ The RTS \"way\"
682
683 -- For object splitting
684 splitInfo :: Maybe (String,Int),
685
686 -- paths etc.
687 objectDir :: Maybe String,
688 dylibInstallName :: Maybe String,
689 hiDir :: Maybe String,
690 stubDir :: Maybe String,
691 dumpDir :: Maybe String,
692
693 objectSuf :: String,
694 hcSuf :: String,
695 hiSuf :: String,
696
697 canGenerateDynamicToo :: IORef Bool,
698 dynObjectSuf :: String,
699 dynHiSuf :: String,
700
701 -- Packages.isDllName needs to know whether a call is within a
702 -- single DLL or not. Normally it does this by seeing if the call
703 -- is to the same package, but for the ghc package, we split the
704 -- package between 2 DLLs. The dllSplit tells us which sets of
705 -- modules are in which package.
706 dllSplitFile :: Maybe FilePath,
707 dllSplit :: Maybe [Set String],
708
709 outputFile :: Maybe String,
710 dynOutputFile :: Maybe String,
711 outputHi :: Maybe String,
712 dynLibLoader :: DynLibLoader,
713
714 -- | This is set by 'DriverPipeline.runPipeline' based on where
715 -- its output is going.
716 dumpPrefix :: Maybe FilePath,
717
718 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
719 -- Set by @-ddump-file-prefix@
720 dumpPrefixForce :: Maybe FilePath,
721
722 ldInputs :: [Option],
723
724 includePaths :: [String],
725 libraryPaths :: [String],
726 frameworkPaths :: [String], -- used on darwin only
727 cmdlineFrameworks :: [String], -- ditto
728
729 rtsOpts :: Maybe String,
730 rtsOptsEnabled :: RtsOptsEnabled,
731 rtsOptsSuggestions :: Bool,
732
733 hpcDir :: String, -- ^ Path to store the .mix files
734
735 -- Plugins
736 pluginModNames :: [ModuleName],
737 pluginModNameOpts :: [(ModuleName,String)],
738 frontendPluginOpts :: [String],
739
740 -- GHC API hooks
741 hooks :: Hooks,
742
743 -- For ghc -M
744 depMakefile :: FilePath,
745 depIncludePkgDeps :: Bool,
746 depExcludeMods :: [ModuleName],
747 depSuffixes :: [String],
748
749 -- Package flags
750 extraPkgConfs :: [PkgConfRef] -> [PkgConfRef],
751 -- ^ The @-package-db@ flags given on the command line, in the order
752 -- they appeared.
753
754 ignorePackageFlags :: [IgnorePackageFlag],
755 -- ^ The @-ignore-package@ flags from the command line
756 packageFlags :: [PackageFlag],
757 -- ^ The @-package@ and @-hide-package@ flags from the command-line
758 pluginPackageFlags :: [PackageFlag],
759 -- ^ The @-plugin-package-id@ flags from command line
760 trustFlags :: [TrustFlag],
761 -- ^ The @-trust@ and @-distrust@ flags
762 packageEnv :: Maybe FilePath,
763 -- ^ Filepath to the package environment file (if overriding default)
764
765 -- Package state
766 -- NB. do not modify this field, it is calculated by
767 -- Packages.initPackages
768 pkgDatabase :: Maybe [(FilePath, [PackageConfig])],
769 pkgState :: PackageState,
770
771 -- Temporary files
772 -- These have to be IORefs, because the defaultCleanupHandler needs to
773 -- know what to clean when an exception happens
774 filesToClean :: IORef [FilePath],
775 dirsToClean :: IORef (Map FilePath FilePath),
776 filesToNotIntermediateClean :: IORef [FilePath],
777 -- The next available suffix to uniquely name a temp file, updated atomically
778 nextTempSuffix :: IORef Int,
779
780 -- Names of files which were generated from -ddump-to-file; used to
781 -- track which ones we need to truncate because it's our first run
782 -- through
783 generatedDumps :: IORef (Set FilePath),
784
785 -- hsc dynamic flags
786 dumpFlags :: IntSet,
787 generalFlags :: IntSet,
788 warningFlags :: IntSet,
789 -- Don't change this without updating extensionFlags:
790 language :: Maybe Language,
791 -- | Safe Haskell mode
792 safeHaskell :: SafeHaskellMode,
793 safeInfer :: Bool,
794 safeInferred :: Bool,
795 -- We store the location of where some extension and flags were turned on so
796 -- we can produce accurate error messages when Safe Haskell fails due to
797 -- them.
798 thOnLoc :: SrcSpan,
799 newDerivOnLoc :: SrcSpan,
800 overlapInstLoc :: SrcSpan,
801 incoherentOnLoc :: SrcSpan,
802 pkgTrustOnLoc :: SrcSpan,
803 warnSafeOnLoc :: SrcSpan,
804 warnUnsafeOnLoc :: SrcSpan,
805 trustworthyOnLoc :: SrcSpan,
806 -- Don't change this without updating extensionFlags:
807 extensions :: [OnOff LangExt.Extension],
808 -- extensionFlags should always be equal to
809 -- flattenExtensionFlags language extensions
810 -- LangExt.Extension is defined in libraries/ghc-boot so that it can be used
811 -- by template-haskell
812 extensionFlags :: IntSet,
813
814 -- Unfolding control
815 -- See Note [Discounts and thresholds] in CoreUnfold
816 ufCreationThreshold :: Int,
817 ufUseThreshold :: Int,
818 ufFunAppDiscount :: Int,
819 ufDictDiscount :: Int,
820 ufKeenessFactor :: Float,
821 ufDearOp :: Int,
822
823 maxWorkerArgs :: Int,
824
825 ghciHistSize :: Int,
826
827 -- | MsgDoc output action: use "ErrUtils" instead of this if you can
828 log_action :: LogAction,
829 flushOut :: FlushOut,
830 flushErr :: FlushErr,
831
832 haddockOptions :: Maybe String,
833
834 -- | GHCi scripts specified by -ghci-script, in reverse order
835 ghciScripts :: [String],
836
837 -- Output style options
838 pprUserLength :: Int,
839 pprCols :: Int,
840 traceLevel :: Int, -- Standard level is 1. Less verbose is 0.
841
842 useUnicode :: Bool,
843
844 -- | what kind of {-# SCC #-} to add automatically
845 profAuto :: ProfAuto,
846
847 interactivePrint :: Maybe String,
848
849 nextWrapperNum :: IORef (ModuleEnv Int),
850
851 -- | Machine dependant flags (-m<blah> stuff)
852 sseVersion :: Maybe SseVersion,
853 avx :: Bool,
854 avx2 :: Bool,
855 avx512cd :: Bool, -- Enable AVX-512 Conflict Detection Instructions.
856 avx512er :: Bool, -- Enable AVX-512 Exponential and Reciprocal Instructions.
857 avx512f :: Bool, -- Enable AVX-512 instructions.
858 avx512pf :: Bool, -- Enable AVX-512 PreFetch Instructions.
859
860 -- | Run-time linker information (what options we need, etc.)
861 rtldInfo :: IORef (Maybe LinkerInfo),
862
863 -- | Run-time compiler information
864 rtccInfo :: IORef (Maybe CompilerInfo),
865
866 -- Constants used to control the amount of optimization done.
867
868 -- | Max size, in bytes, of inline array allocations.
869 maxInlineAllocSize :: Int,
870
871 -- | Only inline memcpy if it generates no more than this many
872 -- pseudo (roughly: Cmm) instructions.
873 maxInlineMemcpyInsns :: Int,
874
875 -- | Only inline memset if it generates no more than this many
876 -- pseudo (roughly: Cmm) instructions.
877 maxInlineMemsetInsns :: Int,
878
879 -- | Reverse the order of error messages in GHC/GHCi
880 reverseErrors :: Bool,
881
882 -- | Unique supply configuration for testing build determinism
883 initialUnique :: Int,
884 uniqueIncrement :: Int
885 }
886
887 class HasDynFlags m where
888 getDynFlags :: m DynFlags
889
890 {- It would be desirable to have the more generalised
891
892 instance (MonadTrans t, Monad m, HasDynFlags m) => HasDynFlags (t m) where
893 getDynFlags = lift getDynFlags
894
895 instance definition. However, that definition would overlap with the
896 `HasDynFlags (GhcT m)` instance. Instead we define instances for a
897 couple of common Monad transformers explicitly. -}
898
899 instance (Monoid a, Monad m, HasDynFlags m) => HasDynFlags (WriterT a m) where
900 getDynFlags = lift getDynFlags
901
902 instance (Monad m, HasDynFlags m) => HasDynFlags (ReaderT a m) where
903 getDynFlags = lift getDynFlags
904
905 instance (Monad m, HasDynFlags m) => HasDynFlags (MaybeT m) where
906 getDynFlags = lift getDynFlags
907
908 instance (Monad m, HasDynFlags m) => HasDynFlags (ExceptT e m) where
909 getDynFlags = lift getDynFlags
910
911 class ContainsDynFlags t where
912 extractDynFlags :: t -> DynFlags
913
914 data ProfAuto
915 = NoProfAuto -- ^ no SCC annotations added
916 | ProfAutoAll -- ^ top-level and nested functions are annotated
917 | ProfAutoTop -- ^ top-level functions annotated only
918 | ProfAutoExports -- ^ exported functions annotated only
919 | ProfAutoCalls -- ^ annotate call-sites
920 deriving (Eq,Enum)
921
922 data Settings = Settings {
923 sTargetPlatform :: Platform, -- Filled in by SysTools
924 sGhcUsagePath :: FilePath, -- Filled in by SysTools
925 sGhciUsagePath :: FilePath, -- ditto
926 sTopDir :: FilePath,
927 sTmpDir :: String, -- no trailing '/'
928 sProgramName :: String,
929 sProjectVersion :: String,
930 -- You shouldn't need to look things up in rawSettings directly.
931 -- They should have their own fields instead.
932 sRawSettings :: [(String, String)],
933 sExtraGccViaCFlags :: [String],
934 sSystemPackageConfig :: FilePath,
935 sLdSupportsCompactUnwind :: Bool,
936 sLdSupportsBuildId :: Bool,
937 sLdSupportsFilelist :: Bool,
938 sLdIsGnuLd :: Bool,
939 -- commands for particular phases
940 sPgm_L :: String,
941 sPgm_P :: (String,[Option]),
942 sPgm_F :: String,
943 sPgm_c :: (String,[Option]),
944 sPgm_s :: (String,[Option]),
945 sPgm_a :: (String,[Option]),
946 sPgm_l :: (String,[Option]),
947 sPgm_dll :: (String,[Option]),
948 sPgm_T :: String,
949 sPgm_windres :: String,
950 sPgm_libtool :: String,
951 sPgm_lo :: (String,[Option]), -- LLVM: opt llvm optimiser
952 sPgm_lc :: (String,[Option]), -- LLVM: llc static compiler
953 sPgm_i :: String,
954 -- options for particular phases
955 sOpt_L :: [String],
956 sOpt_P :: [String],
957 sOpt_F :: [String],
958 sOpt_c :: [String],
959 sOpt_a :: [String],
960 sOpt_l :: [String],
961 sOpt_windres :: [String],
962 sOpt_lo :: [String], -- LLVM: llvm optimiser
963 sOpt_lc :: [String], -- LLVM: llc static compiler
964 sOpt_i :: [String], -- iserv options
965
966 sPlatformConstants :: PlatformConstants
967 }
968
969 targetPlatform :: DynFlags -> Platform
970 targetPlatform dflags = sTargetPlatform (settings dflags)
971 programName :: DynFlags -> String
972 programName dflags = sProgramName (settings dflags)
973 projectVersion :: DynFlags -> String
974 projectVersion dflags = sProjectVersion (settings dflags)
975 ghcUsagePath :: DynFlags -> FilePath
976 ghcUsagePath dflags = sGhcUsagePath (settings dflags)
977 ghciUsagePath :: DynFlags -> FilePath
978 ghciUsagePath dflags = sGhciUsagePath (settings dflags)
979 topDir :: DynFlags -> FilePath
980 topDir dflags = sTopDir (settings dflags)
981 tmpDir :: DynFlags -> String
982 tmpDir dflags = sTmpDir (settings dflags)
983 rawSettings :: DynFlags -> [(String, String)]
984 rawSettings dflags = sRawSettings (settings dflags)
985 extraGccViaCFlags :: DynFlags -> [String]
986 extraGccViaCFlags dflags = sExtraGccViaCFlags (settings dflags)
987 systemPackageConfig :: DynFlags -> FilePath
988 systemPackageConfig dflags = sSystemPackageConfig (settings dflags)
989 pgm_L :: DynFlags -> String
990 pgm_L dflags = sPgm_L (settings dflags)
991 pgm_P :: DynFlags -> (String,[Option])
992 pgm_P dflags = sPgm_P (settings dflags)
993 pgm_F :: DynFlags -> String
994 pgm_F dflags = sPgm_F (settings dflags)
995 pgm_c :: DynFlags -> (String,[Option])
996 pgm_c dflags = sPgm_c (settings dflags)
997 pgm_s :: DynFlags -> (String,[Option])
998 pgm_s dflags = sPgm_s (settings dflags)
999 pgm_a :: DynFlags -> (String,[Option])
1000 pgm_a dflags = sPgm_a (settings dflags)
1001 pgm_l :: DynFlags -> (String,[Option])
1002 pgm_l dflags = sPgm_l (settings dflags)
1003 pgm_dll :: DynFlags -> (String,[Option])
1004 pgm_dll dflags = sPgm_dll (settings dflags)
1005 pgm_T :: DynFlags -> String
1006 pgm_T dflags = sPgm_T (settings dflags)
1007 pgm_windres :: DynFlags -> String
1008 pgm_windres dflags = sPgm_windres (settings dflags)
1009 pgm_libtool :: DynFlags -> String
1010 pgm_libtool dflags = sPgm_libtool (settings dflags)
1011 pgm_lo :: DynFlags -> (String,[Option])
1012 pgm_lo dflags = sPgm_lo (settings dflags)
1013 pgm_lc :: DynFlags -> (String,[Option])
1014 pgm_lc dflags = sPgm_lc (settings dflags)
1015 pgm_i :: DynFlags -> String
1016 pgm_i dflags = sPgm_i (settings dflags)
1017 opt_L :: DynFlags -> [String]
1018 opt_L dflags = sOpt_L (settings dflags)
1019 opt_P :: DynFlags -> [String]
1020 opt_P dflags = concatMap (wayOptP (targetPlatform dflags)) (ways dflags)
1021 ++ sOpt_P (settings dflags)
1022 opt_F :: DynFlags -> [String]
1023 opt_F dflags = sOpt_F (settings dflags)
1024 opt_c :: DynFlags -> [String]
1025 opt_c dflags = concatMap (wayOptc (targetPlatform dflags)) (ways dflags)
1026 ++ sOpt_c (settings dflags)
1027 opt_a :: DynFlags -> [String]
1028 opt_a dflags = sOpt_a (settings dflags)
1029 opt_l :: DynFlags -> [String]
1030 opt_l dflags = concatMap (wayOptl (targetPlatform dflags)) (ways dflags)
1031 ++ sOpt_l (settings dflags)
1032 opt_windres :: DynFlags -> [String]
1033 opt_windres dflags = sOpt_windres (settings dflags)
1034 opt_lo :: DynFlags -> [String]
1035 opt_lo dflags = sOpt_lo (settings dflags)
1036 opt_lc :: DynFlags -> [String]
1037 opt_lc dflags = sOpt_lc (settings dflags)
1038 opt_i :: DynFlags -> [String]
1039 opt_i dflags = sOpt_i (settings dflags)
1040
1041 -- | The directory for this version of ghc in the user's app directory
1042 -- (typically something like @~/.ghc/x86_64-linux-7.6.3@)
1043 --
1044 versionedAppDir :: DynFlags -> IO FilePath
1045 versionedAppDir dflags = do
1046 appdir <- getAppUserDataDirectory (programName dflags)
1047 return $ appdir </> versionedFilePath dflags
1048
1049 -- | A filepath like @x86_64-linux-7.6.3@ with the platform string to use when
1050 -- constructing platform-version-dependent files that need to co-exist.
1051 --
1052 versionedFilePath :: DynFlags -> FilePath
1053 versionedFilePath dflags = TARGET_ARCH
1054 ++ '-':TARGET_OS
1055 ++ '-':projectVersion dflags
1056 -- NB: This functionality is reimplemented in Cabal, so if you
1057 -- change it, be sure to update Cabal.
1058
1059 -- | The target code type of the compilation (if any).
1060 --
1061 -- Whenever you change the target, also make sure to set 'ghcLink' to
1062 -- something sensible.
1063 --
1064 -- 'HscNothing' can be used to avoid generating any output, however, note
1065 -- that:
1066 --
1067 -- * If a program uses Template Haskell the typechecker may try to run code
1068 -- from an imported module. This will fail if no code has been generated
1069 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
1070 -- whether this might be the case and choose to either switch to a
1071 -- different target or avoid typechecking such modules. (The latter may be
1072 -- preferable for security reasons.)
1073 --
1074 data HscTarget
1075 = HscC -- ^ Generate C code.
1076 | HscAsm -- ^ Generate assembly using the native code generator.
1077 | HscLlvm -- ^ Generate assembly using the llvm code generator.
1078 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
1079 | HscNothing -- ^ Don't generate any code. See notes above.
1080 deriving (Eq, Show)
1081
1082 -- | Will this target result in an object file on the disk?
1083 isObjectTarget :: HscTarget -> Bool
1084 isObjectTarget HscC = True
1085 isObjectTarget HscAsm = True
1086 isObjectTarget HscLlvm = True
1087 isObjectTarget _ = False
1088
1089 -- | Does this target retain *all* top-level bindings for a module,
1090 -- rather than just the exported bindings, in the TypeEnv and compiled
1091 -- code (if any)? In interpreted mode we do this, so that GHCi can
1092 -- call functions inside a module. In HscNothing mode we also do it,
1093 -- so that Haddock can get access to the GlobalRdrEnv for a module
1094 -- after typechecking it.
1095 targetRetainsAllBindings :: HscTarget -> Bool
1096 targetRetainsAllBindings HscInterpreted = True
1097 targetRetainsAllBindings HscNothing = True
1098 targetRetainsAllBindings _ = False
1099
1100 -- | The 'GhcMode' tells us whether we're doing multi-module
1101 -- compilation (controlled via the "GHC" API) or one-shot
1102 -- (single-module) compilation. This makes a difference primarily to
1103 -- the "Finder": in one-shot mode we look for interface files for
1104 -- imported modules, but in multi-module mode we look for source files
1105 -- in order to check whether they need to be recompiled.
1106 data GhcMode
1107 = CompManager -- ^ @\-\-make@, GHCi, etc.
1108 | OneShot -- ^ @ghc -c Foo.hs@
1109 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
1110 deriving Eq
1111
1112 instance Outputable GhcMode where
1113 ppr CompManager = text "CompManager"
1114 ppr OneShot = text "OneShot"
1115 ppr MkDepend = text "MkDepend"
1116
1117 isOneShot :: GhcMode -> Bool
1118 isOneShot OneShot = True
1119 isOneShot _other = False
1120
1121 -- | What to do in the link step, if there is one.
1122 data GhcLink
1123 = NoLink -- ^ Don't link at all
1124 | LinkBinary -- ^ Link object code into a binary
1125 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
1126 -- bytecode and object code).
1127 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
1128 | LinkStaticLib -- ^ Link objects into a static lib
1129 deriving (Eq, Show)
1130
1131 isNoLink :: GhcLink -> Bool
1132 isNoLink NoLink = True
1133 isNoLink _ = False
1134
1135 -- | We accept flags which make packages visible, but how they select
1136 -- the package varies; this data type reflects what selection criterion
1137 -- is used.
1138 data PackageArg =
1139 PackageArg String -- ^ @-package@, by 'PackageName'
1140 | UnitIdArg String -- ^ @-package-id@, by 'UnitId'
1141 deriving (Eq, Show)
1142
1143 -- | Represents the renaming that may be associated with an exposed
1144 -- package, e.g. the @rns@ part of @-package "foo (rns)"@.
1145 --
1146 -- Here are some example parsings of the package flags (where
1147 -- a string literal is punned to be a 'ModuleName':
1148 --
1149 -- * @-package foo@ is @ModRenaming True []@
1150 -- * @-package foo ()@ is @ModRenaming False []@
1151 -- * @-package foo (A)@ is @ModRenaming False [("A", "A")]@
1152 -- * @-package foo (A as B)@ is @ModRenaming False [("A", "B")]@
1153 -- * @-package foo with (A as B)@ is @ModRenaming True [("A", "B")]@
1154 data ModRenaming = ModRenaming {
1155 modRenamingWithImplicit :: Bool, -- ^ Bring all exposed modules into scope?
1156 modRenamings :: [(ModuleName, ModuleName)] -- ^ Bring module @m@ into scope
1157 -- under name @n@.
1158 } deriving (Eq)
1159
1160 -- | Flags for manipulating the set of non-broken packages.
1161 newtype IgnorePackageFlag = IgnorePackage String -- ^ @-ignore-package@
1162 deriving (Eq)
1163
1164 -- | Flags for manipulating package trust.
1165 data TrustFlag
1166 = TrustPackage String -- ^ @-trust@
1167 | DistrustPackage String -- ^ @-distrust@
1168 deriving (Eq)
1169
1170 -- | Flags for manipulating packages visibility.
1171 data PackageFlag
1172 = ExposePackage String PackageArg ModRenaming -- ^ @-package@, @-package-id@
1173 | HidePackage String -- ^ @-hide-package@
1174 deriving (Eq)
1175 -- NB: equality instance is used by InteractiveUI to test if
1176 -- package flags have changed.
1177
1178 defaultHscTarget :: Platform -> HscTarget
1179 defaultHscTarget = defaultObjectTarget
1180
1181 -- | The 'HscTarget' value corresponding to the default way to create
1182 -- object files on the current platform.
1183 defaultObjectTarget :: Platform -> HscTarget
1184 defaultObjectTarget platform
1185 | platformUnregisterised platform = HscC
1186 | cGhcWithNativeCodeGen == "YES" = HscAsm
1187 | otherwise = HscLlvm
1188
1189 tablesNextToCode :: DynFlags -> Bool
1190 tablesNextToCode dflags
1191 = mkTablesNextToCode (platformUnregisterised (targetPlatform dflags))
1192
1193 -- Determines whether we will be compiling
1194 -- info tables that reside just before the entry code, or with an
1195 -- indirection to the entry code. See TABLES_NEXT_TO_CODE in
1196 -- includes/rts/storage/InfoTables.h.
1197 mkTablesNextToCode :: Bool -> Bool
1198 mkTablesNextToCode unregisterised
1199 = not unregisterised && cGhcEnableTablesNextToCode == "YES"
1200
1201 data DynLibLoader
1202 = Deployable
1203 | SystemDependent
1204 deriving Eq
1205
1206 data RtsOptsEnabled = RtsOptsNone | RtsOptsSafeOnly | RtsOptsAll
1207 deriving (Show)
1208
1209 -----------------------------------------------------------------------------
1210 -- Ways
1211
1212 -- The central concept of a "way" is that all objects in a given
1213 -- program must be compiled in the same "way". Certain options change
1214 -- parameters of the virtual machine, eg. profiling adds an extra word
1215 -- to the object header, so profiling objects cannot be linked with
1216 -- non-profiling objects.
1217
1218 -- After parsing the command-line options, we determine which "way" we
1219 -- are building - this might be a combination way, eg. profiling+threaded.
1220
1221 -- We then find the "build-tag" associated with this way, and this
1222 -- becomes the suffix used to find .hi files and libraries used in
1223 -- this compilation.
1224
1225 data Way
1226 = WayCustom String -- for GHC API clients building custom variants
1227 | WayThreaded
1228 | WayDebug
1229 | WayProf
1230 | WayEventLog
1231 | WayDyn
1232 deriving (Eq, Ord, Show)
1233
1234 allowed_combination :: [Way] -> Bool
1235 allowed_combination way = and [ x `allowedWith` y
1236 | x <- way, y <- way, x < y ]
1237 where
1238 -- Note ordering in these tests: the left argument is
1239 -- <= the right argument, according to the Ord instance
1240 -- on Way above.
1241
1242 -- dyn is allowed with everything
1243 _ `allowedWith` WayDyn = True
1244 WayDyn `allowedWith` _ = True
1245
1246 -- debug is allowed with everything
1247 _ `allowedWith` WayDebug = True
1248 WayDebug `allowedWith` _ = True
1249
1250 (WayCustom {}) `allowedWith` _ = True
1251 WayThreaded `allowedWith` WayProf = True
1252 WayThreaded `allowedWith` WayEventLog = True
1253 _ `allowedWith` _ = False
1254
1255 mkBuildTag :: [Way] -> String
1256 mkBuildTag ways = concat (intersperse "_" (map wayTag ways))
1257
1258 wayTag :: Way -> String
1259 wayTag (WayCustom xs) = xs
1260 wayTag WayThreaded = "thr"
1261 wayTag WayDebug = "debug"
1262 wayTag WayDyn = "dyn"
1263 wayTag WayProf = "p"
1264 wayTag WayEventLog = "l"
1265
1266 wayRTSOnly :: Way -> Bool
1267 wayRTSOnly (WayCustom {}) = False
1268 wayRTSOnly WayThreaded = True
1269 wayRTSOnly WayDebug = True
1270 wayRTSOnly WayDyn = False
1271 wayRTSOnly WayProf = False
1272 wayRTSOnly WayEventLog = True
1273
1274 wayDesc :: Way -> String
1275 wayDesc (WayCustom xs) = xs
1276 wayDesc WayThreaded = "Threaded"
1277 wayDesc WayDebug = "Debug"
1278 wayDesc WayDyn = "Dynamic"
1279 wayDesc WayProf = "Profiling"
1280 wayDesc WayEventLog = "RTS Event Logging"
1281
1282 -- Turn these flags on when enabling this way
1283 wayGeneralFlags :: Platform -> Way -> [GeneralFlag]
1284 wayGeneralFlags _ (WayCustom {}) = []
1285 wayGeneralFlags _ WayThreaded = []
1286 wayGeneralFlags _ WayDebug = []
1287 wayGeneralFlags _ WayDyn = [Opt_PIC]
1288 -- We could get away without adding -fPIC when compiling the
1289 -- modules of a program that is to be linked with -dynamic; the
1290 -- program itself does not need to be position-independent, only
1291 -- the libraries need to be. HOWEVER, GHCi links objects into a
1292 -- .so before loading the .so using the system linker. Since only
1293 -- PIC objects can be linked into a .so, we have to compile even
1294 -- modules of the main program with -fPIC when using -dynamic.
1295 wayGeneralFlags _ WayProf = [Opt_SccProfilingOn]
1296 wayGeneralFlags _ WayEventLog = []
1297
1298 -- Turn these flags off when enabling this way
1299 wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]
1300 wayUnsetGeneralFlags _ (WayCustom {}) = []
1301 wayUnsetGeneralFlags _ WayThreaded = []
1302 wayUnsetGeneralFlags _ WayDebug = []
1303 wayUnsetGeneralFlags _ WayDyn = [-- There's no point splitting objects
1304 -- when we're going to be dynamically
1305 -- linking. Plus it breaks compilation
1306 -- on OSX x86.
1307 Opt_SplitObjs,
1308 -- If splitobjs wasn't useful for this,
1309 -- assume sections aren't either.
1310 Opt_SplitSections]
1311 wayUnsetGeneralFlags _ WayProf = []
1312 wayUnsetGeneralFlags _ WayEventLog = []
1313
1314 wayOptc :: Platform -> Way -> [String]
1315 wayOptc _ (WayCustom {}) = []
1316 wayOptc platform WayThreaded = case platformOS platform of
1317 OSOpenBSD -> ["-pthread"]
1318 OSNetBSD -> ["-pthread"]
1319 _ -> []
1320 wayOptc _ WayDebug = []
1321 wayOptc _ WayDyn = []
1322 wayOptc _ WayProf = ["-DPROFILING"]
1323 wayOptc _ WayEventLog = ["-DTRACING"]
1324
1325 wayOptl :: Platform -> Way -> [String]
1326 wayOptl _ (WayCustom {}) = []
1327 wayOptl platform WayThreaded =
1328 case platformOS platform of
1329 -- FreeBSD's default threading library is the KSE-based M:N libpthread,
1330 -- which GHC has some problems with. It's currently not clear whether
1331 -- the problems are our fault or theirs, but it seems that using the
1332 -- alternative 1:1 threading library libthr works around it:
1333 OSFreeBSD -> ["-lthr"]
1334 OSOpenBSD -> ["-pthread"]
1335 OSNetBSD -> ["-pthread"]
1336 _ -> []
1337 wayOptl _ WayDebug = []
1338 wayOptl _ WayDyn = []
1339 wayOptl _ WayProf = []
1340 wayOptl _ WayEventLog = []
1341
1342 wayOptP :: Platform -> Way -> [String]
1343 wayOptP _ (WayCustom {}) = []
1344 wayOptP _ WayThreaded = []
1345 wayOptP _ WayDebug = []
1346 wayOptP _ WayDyn = []
1347 wayOptP _ WayProf = ["-DPROFILING"]
1348 wayOptP _ WayEventLog = ["-DTRACING"]
1349
1350 whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m ()
1351 whenGeneratingDynamicToo dflags f = ifGeneratingDynamicToo dflags f (return ())
1352
1353 ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a
1354 ifGeneratingDynamicToo dflags f g = generateDynamicTooConditional dflags f g g
1355
1356 whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m ()
1357 whenCannotGenerateDynamicToo dflags f
1358 = ifCannotGenerateDynamicToo dflags f (return ())
1359
1360 ifCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a
1361 ifCannotGenerateDynamicToo dflags f g
1362 = generateDynamicTooConditional dflags g f g
1363
1364 generateDynamicTooConditional :: MonadIO m
1365 => DynFlags -> m a -> m a -> m a -> m a
1366 generateDynamicTooConditional dflags canGen cannotGen notTryingToGen
1367 = if gopt Opt_BuildDynamicToo dflags
1368 then do let ref = canGenerateDynamicToo dflags
1369 b <- liftIO $ readIORef ref
1370 if b then canGen else cannotGen
1371 else notTryingToGen
1372
1373 dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags
1374 dynamicTooMkDynamicDynFlags dflags0
1375 = let dflags1 = addWay' WayDyn dflags0
1376 dflags2 = dflags1 {
1377 outputFile = dynOutputFile dflags1,
1378 hiSuf = dynHiSuf dflags1,
1379 objectSuf = dynObjectSuf dflags1
1380 }
1381 dflags3 = updateWays dflags2
1382 dflags4 = gopt_unset dflags3 Opt_BuildDynamicToo
1383 in dflags4
1384
1385 -----------------------------------------------------------------------------
1386
1387 -- | Used by 'GHC.runGhc' to partially initialize a new 'DynFlags' value
1388 initDynFlags :: DynFlags -> IO DynFlags
1389 initDynFlags dflags = do
1390 let -- We can't build with dynamic-too on Windows, as labels before
1391 -- the fork point are different depending on whether we are
1392 -- building dynamically or not.
1393 platformCanGenerateDynamicToo
1394 = platformOS (targetPlatform dflags) /= OSMinGW32
1395 refCanGenerateDynamicToo <- newIORef platformCanGenerateDynamicToo
1396 refNextTempSuffix <- newIORef 0
1397 refFilesToClean <- newIORef []
1398 refDirsToClean <- newIORef Map.empty
1399 refFilesToNotIntermediateClean <- newIORef []
1400 refGeneratedDumps <- newIORef Set.empty
1401 refRtldInfo <- newIORef Nothing
1402 refRtccInfo <- newIORef Nothing
1403 wrapperNum <- newIORef emptyModuleEnv
1404 canUseUnicode <- do let enc = localeEncoding
1405 str = "‘’"
1406 (withCString enc str $ \cstr ->
1407 do str' <- peekCString enc cstr
1408 return (str == str'))
1409 `catchIOError` \_ -> return False
1410 return dflags{
1411 canGenerateDynamicToo = refCanGenerateDynamicToo,
1412 nextTempSuffix = refNextTempSuffix,
1413 filesToClean = refFilesToClean,
1414 dirsToClean = refDirsToClean,
1415 filesToNotIntermediateClean = refFilesToNotIntermediateClean,
1416 generatedDumps = refGeneratedDumps,
1417 nextWrapperNum = wrapperNum,
1418 useUnicode = canUseUnicode,
1419 rtldInfo = refRtldInfo,
1420 rtccInfo = refRtccInfo
1421 }
1422
1423 -- | The normal 'DynFlags'. Note that they are not suitable for use in this form
1424 -- and must be fully initialized by 'GHC.runGhc' first.
1425 defaultDynFlags :: Settings -> DynFlags
1426 defaultDynFlags mySettings =
1427 -- See Note [Updating flag description in the User's Guide]
1428 DynFlags {
1429 ghcMode = CompManager,
1430 ghcLink = LinkBinary,
1431 hscTarget = defaultHscTarget (sTargetPlatform mySettings),
1432 sigOf = Map.empty,
1433 verbosity = 0,
1434 optLevel = 0,
1435 debugLevel = 0,
1436 simplPhases = 2,
1437 maxSimplIterations = 4,
1438 maxPmCheckIterations = 10000000,
1439 ruleCheck = Nothing,
1440 maxRelevantBinds = Just 6,
1441 simplTickFactor = 100,
1442 specConstrThreshold = Just 2000,
1443 specConstrCount = Just 3,
1444 specConstrRecursive = 3,
1445 liberateCaseThreshold = Just 2000,
1446 floatLamArgs = Just 0, -- Default: float only if no fvs
1447
1448 historySize = 20,
1449 strictnessBefore = [],
1450
1451 parMakeCount = Just 1,
1452
1453 enableTimeStats = False,
1454 ghcHeapSize = Nothing,
1455
1456 cmdlineHcIncludes = [],
1457 importPaths = ["."],
1458 mainModIs = mAIN,
1459 mainFunIs = Nothing,
1460 reductionDepth = treatZeroAsInf mAX_REDUCTION_DEPTH,
1461 solverIterations = treatZeroAsInf mAX_SOLVER_ITERATIONS,
1462
1463 thisPackage = mainUnitId,
1464
1465 objectDir = Nothing,
1466 dylibInstallName = Nothing,
1467 hiDir = Nothing,
1468 stubDir = Nothing,
1469 dumpDir = Nothing,
1470
1471 objectSuf = phaseInputExt StopLn,
1472 hcSuf = phaseInputExt HCc,
1473 hiSuf = "hi",
1474
1475 canGenerateDynamicToo = panic "defaultDynFlags: No canGenerateDynamicToo",
1476 dynObjectSuf = "dyn_" ++ phaseInputExt StopLn,
1477 dynHiSuf = "dyn_hi",
1478
1479 dllSplitFile = Nothing,
1480 dllSplit = Nothing,
1481
1482 pluginModNames = [],
1483 pluginModNameOpts = [],
1484 frontendPluginOpts = [],
1485 hooks = emptyHooks,
1486
1487 outputFile = Nothing,
1488 dynOutputFile = Nothing,
1489 outputHi = Nothing,
1490 dynLibLoader = SystemDependent,
1491 dumpPrefix = Nothing,
1492 dumpPrefixForce = Nothing,
1493 ldInputs = [],
1494 includePaths = [],
1495 libraryPaths = [],
1496 frameworkPaths = [],
1497 cmdlineFrameworks = [],
1498 rtsOpts = Nothing,
1499 rtsOptsEnabled = RtsOptsSafeOnly,
1500 rtsOptsSuggestions = True,
1501
1502 hpcDir = ".hpc",
1503
1504 extraPkgConfs = id,
1505 packageFlags = [],
1506 pluginPackageFlags = [],
1507 ignorePackageFlags = [],
1508 trustFlags = [],
1509 packageEnv = Nothing,
1510 pkgDatabase = Nothing,
1511 -- This gets filled in with GHC.setSessionDynFlags
1512 pkgState = emptyPackageState,
1513 ways = defaultWays mySettings,
1514 buildTag = mkBuildTag (defaultWays mySettings),
1515 rtsBuildTag = mkBuildTag (defaultWays mySettings),
1516 splitInfo = Nothing,
1517 settings = mySettings,
1518 -- ghc -M values
1519 depMakefile = "Makefile",
1520 depIncludePkgDeps = False,
1521 depExcludeMods = [],
1522 depSuffixes = [],
1523 -- end of ghc -M values
1524 nextTempSuffix = panic "defaultDynFlags: No nextTempSuffix",
1525 filesToClean = panic "defaultDynFlags: No filesToClean",
1526 dirsToClean = panic "defaultDynFlags: No dirsToClean",
1527 filesToNotIntermediateClean = panic "defaultDynFlags: No filesToNotIntermediateClean",
1528 generatedDumps = panic "defaultDynFlags: No generatedDumps",
1529 haddockOptions = Nothing,
1530 dumpFlags = IntSet.empty,
1531 generalFlags = IntSet.fromList (map fromEnum (defaultFlags mySettings)),
1532 warningFlags = IntSet.fromList (map fromEnum standardWarnings),
1533 ghciScripts = [],
1534 language = Nothing,
1535 safeHaskell = Sf_None,
1536 safeInfer = True,
1537 safeInferred = True,
1538 thOnLoc = noSrcSpan,
1539 newDerivOnLoc = noSrcSpan,
1540 overlapInstLoc = noSrcSpan,
1541 incoherentOnLoc = noSrcSpan,
1542 pkgTrustOnLoc = noSrcSpan,
1543 warnSafeOnLoc = noSrcSpan,
1544 warnUnsafeOnLoc = noSrcSpan,
1545 trustworthyOnLoc = noSrcSpan,
1546 extensions = [],
1547 extensionFlags = flattenExtensionFlags Nothing [],
1548
1549 -- The ufCreationThreshold threshold must be reasonably high to
1550 -- take account of possible discounts.
1551 -- E.g. 450 is not enough in 'fulsom' for Interval.sqr to inline
1552 -- into Csg.calc (The unfolding for sqr never makes it into the
1553 -- interface file.)
1554 ufCreationThreshold = 750,
1555 ufUseThreshold = 60,
1556 ufFunAppDiscount = 60,
1557 -- Be fairly keen to inline a function if that means
1558 -- we'll be able to pick the right method from a dictionary
1559 ufDictDiscount = 30,
1560 ufKeenessFactor = 1.5,
1561 ufDearOp = 40,
1562
1563 maxWorkerArgs = 10,
1564
1565 ghciHistSize = 50, -- keep a log of length 50 by default
1566
1567 log_action = defaultLogAction,
1568 flushOut = defaultFlushOut,
1569 flushErr = defaultFlushErr,
1570 pprUserLength = 5,
1571 pprCols = 100,
1572 useUnicode = False,
1573 traceLevel = 1,
1574 profAuto = NoProfAuto,
1575 interactivePrint = Nothing,
1576 nextWrapperNum = panic "defaultDynFlags: No nextWrapperNum",
1577 sseVersion = Nothing,
1578 avx = False,
1579 avx2 = False,
1580 avx512cd = False,
1581 avx512er = False,
1582 avx512f = False,
1583 avx512pf = False,
1584 rtldInfo = panic "defaultDynFlags: no rtldInfo",
1585 rtccInfo = panic "defaultDynFlags: no rtccInfo",
1586
1587 maxInlineAllocSize = 128,
1588 maxInlineMemcpyInsns = 32,
1589 maxInlineMemsetInsns = 32,
1590
1591 initialUnique = 0,
1592 uniqueIncrement = 1,
1593
1594 reverseErrors = False
1595 }
1596
1597 defaultWays :: Settings -> [Way]
1598 defaultWays settings = if pc_DYNAMIC_BY_DEFAULT (sPlatformConstants settings)
1599 then [WayDyn]
1600 else []
1601
1602 interpWays :: [Way]
1603 interpWays
1604 | dynamicGhc = [WayDyn]
1605 | rtsIsProfiled = [WayProf]
1606 | otherwise = []
1607
1608 interpreterProfiled :: DynFlags -> Bool
1609 interpreterProfiled dflags
1610 | gopt Opt_ExternalInterpreter dflags = gopt Opt_SccProfilingOn dflags
1611 | otherwise = rtsIsProfiled
1612
1613 interpreterDynamic :: DynFlags -> Bool
1614 interpreterDynamic dflags
1615 | gopt Opt_ExternalInterpreter dflags = WayDyn `elem` ways dflags
1616 | otherwise = dynamicGhc
1617
1618 --------------------------------------------------------------------------
1619
1620 type FatalMessager = String -> IO ()
1621 type LogAction = DynFlags -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO ()
1622
1623 defaultFatalMessager :: FatalMessager
1624 defaultFatalMessager = hPutStrLn stderr
1625
1626 defaultLogAction :: LogAction
1627 defaultLogAction dflags severity srcSpan style msg
1628 = case severity of
1629 SevOutput -> printSDoc msg style
1630 SevDump -> printSDoc (msg $$ blankLine) style
1631 SevInteractive -> putStrSDoc msg style
1632 SevInfo -> printErrs msg style
1633 SevFatal -> printErrs msg style
1634 _ -> do hPutChar stderr '\n'
1635 printErrs (mkLocMessage severity srcSpan msg) style
1636 -- careful (#2302): printErrs prints in UTF-8,
1637 -- whereas converting to string first and using
1638 -- hPutStr would just emit the low 8 bits of
1639 -- each unicode char.
1640 where printSDoc = defaultLogActionHPrintDoc dflags stdout
1641 printErrs = defaultLogActionHPrintDoc dflags stderr
1642 putStrSDoc = defaultLogActionHPutStrDoc dflags stdout
1643
1644 defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
1645 defaultLogActionHPrintDoc dflags h d sty
1646 = defaultLogActionHPutStrDoc dflags h (d $$ text "") sty
1647 -- Adds a newline
1648
1649 defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
1650 defaultLogActionHPutStrDoc dflags h d sty
1651 = Pretty.printDoc_ Pretty.PageMode (pprCols dflags) h doc
1652 where -- Don't add a newline at the end, so that successive
1653 -- calls to this log-action can output all on the same line
1654 doc = runSDoc d (initSDocContext dflags sty)
1655
1656 newtype FlushOut = FlushOut (IO ())
1657
1658 defaultFlushOut :: FlushOut
1659 defaultFlushOut = FlushOut $ hFlush stdout
1660
1661 newtype FlushErr = FlushErr (IO ())
1662
1663 defaultFlushErr :: FlushErr
1664 defaultFlushErr = FlushErr $ hFlush stderr
1665
1666 {-
1667 Note [Verbosity levels]
1668 ~~~~~~~~~~~~~~~~~~~~~~~
1669 0 | print errors & warnings only
1670 1 | minimal verbosity: print "compiling M ... done." for each module.
1671 2 | equivalent to -dshow-passes
1672 3 | equivalent to existing "ghc -v"
1673 4 | "ghc -v -ddump-most"
1674 5 | "ghc -v -ddump-all"
1675 -}
1676
1677 data OnOff a = On a
1678 | Off a
1679 deriving (Eq, Show)
1680
1681 instance Outputable a => Outputable (OnOff a) where
1682 ppr (On x) = text "On" <+> ppr x
1683 ppr (Off x) = text "Off" <+> ppr x
1684
1685 -- OnOffs accumulate in reverse order, so we use foldr in order to
1686 -- process them in the right order
1687 flattenExtensionFlags :: Maybe Language -> [OnOff LangExt.Extension] -> IntSet
1688 flattenExtensionFlags ml = foldr f defaultExtensionFlags
1689 where f (On f) flags = IntSet.insert (fromEnum f) flags
1690 f (Off f) flags = IntSet.delete (fromEnum f) flags
1691 defaultExtensionFlags = IntSet.fromList (map fromEnum (languageExtensions ml))
1692
1693 languageExtensions :: Maybe Language -> [LangExt.Extension]
1694
1695 languageExtensions Nothing
1696 -- Nothing => the default case
1697 = LangExt.NondecreasingIndentation -- This has been on by default for some time
1698 : delete LangExt.DatatypeContexts -- The Haskell' committee decided to
1699 -- remove datatype contexts from the
1700 -- language:
1701 -- http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html
1702 (languageExtensions (Just Haskell2010))
1703
1704 -- NB: MonoPatBinds is no longer the default
1705
1706 languageExtensions (Just Haskell98)
1707 = [LangExt.ImplicitPrelude,
1708 LangExt.MonomorphismRestriction,
1709 LangExt.NPlusKPatterns,
1710 LangExt.DatatypeContexts,
1711 LangExt.TraditionalRecordSyntax,
1712 LangExt.NondecreasingIndentation
1713 -- strictly speaking non-standard, but we always had this
1714 -- on implicitly before the option was added in 7.1, and
1715 -- turning it off breaks code, so we're keeping it on for
1716 -- backwards compatibility. Cabal uses -XHaskell98 by
1717 -- default unless you specify another language.
1718 ]
1719
1720 languageExtensions (Just Haskell2010)
1721 = [LangExt.ImplicitPrelude,
1722 LangExt.MonomorphismRestriction,
1723 LangExt.DatatypeContexts,
1724 LangExt.TraditionalRecordSyntax,
1725 LangExt.EmptyDataDecls,
1726 LangExt.ForeignFunctionInterface,
1727 LangExt.PatternGuards,
1728 LangExt.DoAndIfThenElse,
1729 LangExt.RelaxedPolyRec]
1730
1731 -- | Test whether a 'DumpFlag' is set
1732 dopt :: DumpFlag -> DynFlags -> Bool
1733 dopt f dflags = (fromEnum f `IntSet.member` dumpFlags dflags)
1734 || (verbosity dflags >= 4 && enableIfVerbose f)
1735 where enableIfVerbose Opt_D_dump_tc_trace = False
1736 enableIfVerbose Opt_D_dump_rn_trace = False
1737 enableIfVerbose Opt_D_dump_cs_trace = False
1738 enableIfVerbose Opt_D_dump_if_trace = False
1739 enableIfVerbose Opt_D_dump_vt_trace = False
1740 enableIfVerbose Opt_D_dump_tc = False
1741 enableIfVerbose Opt_D_dump_rn = False
1742 enableIfVerbose Opt_D_dump_rn_stats = False
1743 enableIfVerbose Opt_D_dump_hi_diffs = False
1744 enableIfVerbose Opt_D_verbose_core2core = False
1745 enableIfVerbose Opt_D_verbose_stg2stg = False
1746 enableIfVerbose Opt_D_dump_splices = False
1747 enableIfVerbose Opt_D_th_dec_file = False
1748 enableIfVerbose Opt_D_dump_rule_firings = False
1749 enableIfVerbose Opt_D_dump_rule_rewrites = False
1750 enableIfVerbose Opt_D_dump_simpl_trace = False
1751 enableIfVerbose Opt_D_dump_rtti = False
1752 enableIfVerbose Opt_D_dump_inlinings = False
1753 enableIfVerbose Opt_D_dump_core_stats = False
1754 enableIfVerbose Opt_D_dump_asm_stats = False
1755 enableIfVerbose Opt_D_dump_types = False
1756 enableIfVerbose Opt_D_dump_simpl_iterations = False
1757 enableIfVerbose Opt_D_dump_ticked = False
1758 enableIfVerbose Opt_D_dump_view_pattern_commoning = False
1759 enableIfVerbose Opt_D_dump_mod_cycles = False
1760 enableIfVerbose Opt_D_dump_mod_map = False
1761 enableIfVerbose _ = True
1762
1763 -- | Set a 'DumpFlag'
1764 dopt_set :: DynFlags -> DumpFlag -> DynFlags
1765 dopt_set dfs f = dfs{ dumpFlags = IntSet.insert (fromEnum f) (dumpFlags dfs) }
1766
1767 -- | Unset a 'DumpFlag'
1768 dopt_unset :: DynFlags -> DumpFlag -> DynFlags
1769 dopt_unset dfs f = dfs{ dumpFlags = IntSet.delete (fromEnum f) (dumpFlags dfs) }
1770
1771 -- | Test whether a 'GeneralFlag' is set
1772 gopt :: GeneralFlag -> DynFlags -> Bool
1773 gopt f dflags = fromEnum f `IntSet.member` generalFlags dflags
1774
1775 -- | Set a 'GeneralFlag'
1776 gopt_set :: DynFlags -> GeneralFlag -> DynFlags
1777 gopt_set dfs f = dfs{ generalFlags = IntSet.insert (fromEnum f) (generalFlags dfs) }
1778
1779 -- | Unset a 'GeneralFlag'
1780 gopt_unset :: DynFlags -> GeneralFlag -> DynFlags
1781 gopt_unset dfs f = dfs{ generalFlags = IntSet.delete (fromEnum f) (generalFlags dfs) }
1782
1783 -- | Test whether a 'WarningFlag' is set
1784 wopt :: WarningFlag -> DynFlags -> Bool
1785 wopt f dflags = fromEnum f `IntSet.member` warningFlags dflags
1786
1787 -- | Set a 'WarningFlag'
1788 wopt_set :: DynFlags -> WarningFlag -> DynFlags
1789 wopt_set dfs f = dfs{ warningFlags = IntSet.insert (fromEnum f) (warningFlags dfs) }
1790
1791 -- | Unset a 'WarningFlag'
1792 wopt_unset :: DynFlags -> WarningFlag -> DynFlags
1793 wopt_unset dfs f = dfs{ warningFlags = IntSet.delete (fromEnum f) (warningFlags dfs) }
1794
1795 -- | Test whether a 'LangExt.Extension' is set
1796 xopt :: LangExt.Extension -> DynFlags -> Bool
1797 xopt f dflags = fromEnum f `IntSet.member` extensionFlags dflags
1798
1799 -- | Set a 'LangExt.Extension'
1800 xopt_set :: DynFlags -> LangExt.Extension -> DynFlags
1801 xopt_set dfs f
1802 = let onoffs = On f : extensions dfs
1803 in dfs { extensions = onoffs,
1804 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
1805
1806 -- | Unset a 'LangExt.Extension'
1807 xopt_unset :: DynFlags -> LangExt.Extension -> DynFlags
1808 xopt_unset dfs f
1809 = let onoffs = Off f : extensions dfs
1810 in dfs { extensions = onoffs,
1811 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
1812
1813 lang_set :: DynFlags -> Maybe Language -> DynFlags
1814 lang_set dflags lang =
1815 dflags {
1816 language = lang,
1817 extensionFlags = flattenExtensionFlags lang (extensions dflags)
1818 }
1819
1820 -- | Check whether to use unicode syntax for output
1821 useUnicodeSyntax :: DynFlags -> Bool
1822 useUnicodeSyntax = gopt Opt_PrintUnicodeSyntax
1823
1824 -- | Set the Haskell language standard to use
1825 setLanguage :: Language -> DynP ()
1826 setLanguage l = upd (`lang_set` Just l)
1827
1828 -- | Some modules have dependencies on others through the DynFlags rather than textual imports
1829 dynFlagDependencies :: DynFlags -> [ModuleName]
1830 dynFlagDependencies = pluginModNames
1831
1832 -- | Is the -fpackage-trust mode on
1833 packageTrustOn :: DynFlags -> Bool
1834 packageTrustOn = gopt Opt_PackageTrust
1835
1836 -- | Is Safe Haskell on in some way (including inference mode)
1837 safeHaskellOn :: DynFlags -> Bool
1838 safeHaskellOn dflags = safeHaskell dflags /= Sf_None || safeInferOn dflags
1839
1840 -- | Is the Safe Haskell safe language in use
1841 safeLanguageOn :: DynFlags -> Bool
1842 safeLanguageOn dflags = safeHaskell dflags == Sf_Safe
1843
1844 -- | Is the Safe Haskell safe inference mode active
1845 safeInferOn :: DynFlags -> Bool
1846 safeInferOn = safeInfer
1847
1848 -- | Test if Safe Imports are on in some form
1849 safeImportsOn :: DynFlags -> Bool
1850 safeImportsOn dflags = safeHaskell dflags == Sf_Unsafe ||
1851 safeHaskell dflags == Sf_Trustworthy ||
1852 safeHaskell dflags == Sf_Safe
1853
1854 -- | Set a 'Safe Haskell' flag
1855 setSafeHaskell :: SafeHaskellMode -> DynP ()
1856 setSafeHaskell s = updM f
1857 where f dfs = do
1858 let sf = safeHaskell dfs
1859 safeM <- combineSafeFlags sf s
1860 case s of
1861 Sf_Safe -> return $ dfs { safeHaskell = safeM, safeInfer = False }
1862 -- leave safe inferrence on in Trustworthy mode so we can warn
1863 -- if it could have been inferred safe.
1864 Sf_Trustworthy -> do
1865 l <- getCurLoc
1866 return $ dfs { safeHaskell = safeM, trustworthyOnLoc = l }
1867 -- leave safe inference on in Unsafe mode as well.
1868 _ -> return $ dfs { safeHaskell = safeM }
1869
1870 -- | Are all direct imports required to be safe for this Safe Haskell mode?
1871 -- Direct imports are when the code explicitly imports a module
1872 safeDirectImpsReq :: DynFlags -> Bool
1873 safeDirectImpsReq d = safeLanguageOn d
1874
1875 -- | Are all implicit imports required to be safe for this Safe Haskell mode?
1876 -- Implicit imports are things in the prelude. e.g System.IO when print is used.
1877 safeImplicitImpsReq :: DynFlags -> Bool
1878 safeImplicitImpsReq d = safeLanguageOn d
1879
1880 -- | Combine two Safe Haskell modes correctly. Used for dealing with multiple flags.
1881 -- This makes Safe Haskell very much a monoid but for now I prefer this as I don't
1882 -- want to export this functionality from the module but do want to export the
1883 -- type constructors.
1884 combineSafeFlags :: SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
1885 combineSafeFlags a b | a == Sf_None = return b
1886 | b == Sf_None = return a
1887 | a == b = return a
1888 | otherwise = addErr errm >> return (panic errm)
1889 where errm = "Incompatible Safe Haskell flags! ("
1890 ++ show a ++ ", " ++ show b ++ ")"
1891
1892 -- | A list of unsafe flags under Safe Haskell. Tuple elements are:
1893 -- * name of the flag
1894 -- * function to get srcspan that enabled the flag
1895 -- * function to test if the flag is on
1896 -- * function to turn the flag off
1897 unsafeFlags, unsafeFlagsForInfer
1898 :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]
1899 unsafeFlags = [ ("-XGeneralizedNewtypeDeriving", newDerivOnLoc,
1900 xopt LangExt.GeneralizedNewtypeDeriving,
1901 flip xopt_unset LangExt.GeneralizedNewtypeDeriving)
1902 , ("-XTemplateHaskell", thOnLoc,
1903 xopt LangExt.TemplateHaskell,
1904 flip xopt_unset LangExt.TemplateHaskell)
1905 ]
1906 unsafeFlagsForInfer = unsafeFlags
1907
1908
1909 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
1910 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
1911 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
1912 -> [a] -- ^ Correctly ordered extracted options
1913 getOpts dflags opts = reverse (opts dflags)
1914 -- We add to the options from the front, so we need to reverse the list
1915
1916 -- | Gets the verbosity flag for the current verbosity level. This is fed to
1917 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
1918 getVerbFlags :: DynFlags -> [String]
1919 getVerbFlags dflags
1920 | verbosity dflags >= 4 = ["-v"]
1921 | otherwise = []
1922
1923 setObjectDir, setHiDir, setStubDir, setDumpDir, setOutputDir,
1924 setDynObjectSuf, setDynHiSuf,
1925 setDylibInstallName,
1926 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
1927 setPgmP, addOptl, addOptc, addOptP,
1928 addCmdlineFramework, addHaddockOpts, addGhciScript,
1929 setInteractivePrint
1930 :: String -> DynFlags -> DynFlags
1931 setOutputFile, setDynOutputFile, setOutputHi, setDumpPrefixForce
1932 :: Maybe String -> DynFlags -> DynFlags
1933
1934 setObjectDir f d = d{ objectDir = Just f}
1935 setHiDir f d = d{ hiDir = Just f}
1936 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
1937 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
1938 -- \#included from the .hc file when compiling via C (i.e. unregisterised
1939 -- builds).
1940 setDumpDir f d = d{ dumpDir = Just f}
1941 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f . setDumpDir f
1942 setDylibInstallName f d = d{ dylibInstallName = Just f}
1943
1944 setObjectSuf f d = d{ objectSuf = f}
1945 setDynObjectSuf f d = d{ dynObjectSuf = f}
1946 setHiSuf f d = d{ hiSuf = f}
1947 setDynHiSuf f d = d{ dynHiSuf = f}
1948 setHcSuf f d = d{ hcSuf = f}
1949
1950 setOutputFile f d = d{ outputFile = f}
1951 setDynOutputFile f d = d{ dynOutputFile = f}
1952 setOutputHi f d = d{ outputHi = f}
1953
1954 parseSigOf :: String -> SigOf
1955 parseSigOf str = case filter ((=="").snd) (readP_to_S parse str) of
1956 [(r, "")] -> r
1957 _ -> throwGhcException $ CmdLineError ("Can't parse -sig-of: " ++ str)
1958 where parse = Map.fromList <$> sepBy parseEntry (R.char ',')
1959 parseEntry = do
1960 n <- tok $ parseModuleName
1961 -- ToDo: deprecate this 'is' syntax?
1962 tok $ ((string "is" >> return ()) +++ (R.char '=' >> return ()))
1963 m <- tok $ parseModule
1964 return (n, m)
1965 parseModule = do
1966 pk <- munch1 (\c -> isAlphaNum c || c `elem` "-_.")
1967 _ <- R.char ':'
1968 m <- parseModuleName
1969 return (mkModule (stringToUnitId pk) m)
1970 tok m = skipSpaces >> m
1971
1972 setSigOf :: String -> DynFlags -> DynFlags
1973 setSigOf s d = d { sigOf = parseSigOf s }
1974
1975 addPluginModuleName :: String -> DynFlags -> DynFlags
1976 addPluginModuleName name d = d { pluginModNames = (mkModuleName name) : (pluginModNames d) }
1977
1978 addPluginModuleNameOption :: String -> DynFlags -> DynFlags
1979 addPluginModuleNameOption optflag d = d { pluginModNameOpts = (mkModuleName m, option) : (pluginModNameOpts d) }
1980 where (m, rest) = break (== ':') optflag
1981 option = case rest of
1982 [] -> "" -- should probably signal an error
1983 (_:plug_opt) -> plug_opt -- ignore the ':' from break
1984
1985 addFrontendPluginOption :: String -> DynFlags -> DynFlags
1986 addFrontendPluginOption s d = d { frontendPluginOpts = s : frontendPluginOpts d }
1987
1988 parseDynLibLoaderMode f d =
1989 case splitAt 8 f of
1990 ("deploy", "") -> d{ dynLibLoader = Deployable }
1991 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
1992 _ -> throwGhcException (CmdLineError ("Unknown dynlib loader: " ++ f))
1993
1994 setDumpPrefixForce f d = d { dumpPrefixForce = f}
1995
1996 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
1997 -- Config.hs should really use Option.
1998 setPgmP f = let (pgm:args) = words f in alterSettings (\s -> s { sPgm_P = (pgm, map Option args)})
1999 addOptl f = alterSettings (\s -> s { sOpt_l = f : sOpt_l s})
2000 addOptc f = alterSettings (\s -> s { sOpt_c = f : sOpt_c s})
2001 addOptP f = alterSettings (\s -> s { sOpt_P = f : sOpt_P s})
2002
2003
2004 setDepMakefile :: FilePath -> DynFlags -> DynFlags
2005 setDepMakefile f d = d { depMakefile = f }
2006
2007 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
2008 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
2009
2010 addDepExcludeMod :: String -> DynFlags -> DynFlags
2011 addDepExcludeMod m d
2012 = d { depExcludeMods = mkModuleName m : depExcludeMods d }
2013
2014 addDepSuffix :: FilePath -> DynFlags -> DynFlags
2015 addDepSuffix s d = d { depSuffixes = s : depSuffixes d }
2016
2017 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
2018
2019 addHaddockOpts f d = d{ haddockOptions = Just f}
2020
2021 addGhciScript f d = d{ ghciScripts = f : ghciScripts d}
2022
2023 setInteractivePrint f d = d{ interactivePrint = Just f}
2024
2025 -- -----------------------------------------------------------------------------
2026 -- Command-line options
2027
2028 -- | When invoking external tools as part of the compilation pipeline, we
2029 -- pass these a sequence of options on the command-line. Rather than
2030 -- just using a list of Strings, we use a type that allows us to distinguish
2031 -- between filepaths and 'other stuff'. The reason for this is that
2032 -- this type gives us a handle on transforming filenames, and filenames only,
2033 -- to whatever format they're expected to be on a particular platform.
2034 data Option
2035 = FileOption -- an entry that _contains_ filename(s) / filepaths.
2036 String -- a non-filepath prefix that shouldn't be
2037 -- transformed (e.g., "/out=")
2038 String -- the filepath/filename portion
2039 | Option String
2040 deriving ( Eq )
2041
2042 showOpt :: Option -> String
2043 showOpt (FileOption pre f) = pre ++ f
2044 showOpt (Option s) = s
2045
2046 -----------------------------------------------------------------------------
2047 -- Setting the optimisation level
2048
2049 updOptLevel :: Int -> DynFlags -> DynFlags
2050 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
2051 updOptLevel n dfs
2052 = dfs2{ optLevel = final_n }
2053 where
2054 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
2055 dfs1 = foldr (flip gopt_unset) dfs remove_gopts
2056 dfs2 = foldr (flip gopt_set) dfs1 extra_gopts
2057
2058 extra_gopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
2059 remove_gopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
2060
2061 {- **********************************************************************
2062 %* *
2063 DynFlags parser
2064 %* *
2065 %********************************************************************* -}
2066
2067 -- -----------------------------------------------------------------------------
2068 -- Parsing the dynamic flags.
2069
2070
2071 -- | Parse dynamic flags from a list of command line arguments. Returns the
2072 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
2073 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
2074 -- flags or missing arguments).
2075 parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String]
2076 -> m (DynFlags, [Located String], [Located String])
2077 -- ^ Updated 'DynFlags', left-over arguments, and
2078 -- list of warnings.
2079 parseDynamicFlagsCmdLine = parseDynamicFlagsFull flagsAll True
2080
2081
2082 -- | Like 'parseDynamicFlagsCmdLine' but does not allow the package flags
2083 -- (-package, -hide-package, -ignore-package, -hide-all-packages, -package-db).
2084 -- Used to parse flags set in a modules pragma.
2085 parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String]
2086 -> m (DynFlags, [Located String], [Located String])
2087 -- ^ Updated 'DynFlags', left-over arguments, and
2088 -- list of warnings.
2089 parseDynamicFilePragma = parseDynamicFlagsFull flagsDynamic False
2090
2091
2092 -- | Parses the dynamically set flags for GHC. This is the most general form of
2093 -- the dynamic flag parser that the other methods simply wrap. It allows
2094 -- saying which flags are valid flags and indicating if we are parsing
2095 -- arguments from the command line or from a file pragma.
2096 parseDynamicFlagsFull :: MonadIO m
2097 => [Flag (CmdLineP DynFlags)] -- ^ valid flags to match against
2098 -> Bool -- ^ are the arguments from the command line?
2099 -> DynFlags -- ^ current dynamic flags
2100 -> [Located String] -- ^ arguments to parse
2101 -> m (DynFlags, [Located String], [Located String])
2102 parseDynamicFlagsFull activeFlags cmdline dflags0 args = do
2103 let ((leftover, errs, warns), dflags1)
2104 = runCmdLine (processArgs activeFlags args) dflags0
2105
2106 -- See Note [Handling errors when parsing commandline flags]
2107 unless (null errs) $ liftIO $ throwGhcExceptionIO $
2108 errorsToGhcException . map (showPpr dflags0 . getLoc &&& unLoc) $ errs
2109
2110 -- check for disabled flags in safe haskell
2111 let (dflags2, sh_warns) = safeFlagCheck cmdline dflags1
2112 dflags3 = updateWays dflags2
2113 theWays = ways dflags3
2114
2115 unless (allowed_combination theWays) $ liftIO $
2116 throwGhcExceptionIO (CmdLineError ("combination not supported: " ++
2117 intercalate "/" (map wayDesc theWays)))
2118
2119 let chooseOutput
2120 | isJust (outputFile dflags3) -- Only iff user specified -o ...
2121 , not (isJust (dynOutputFile dflags3)) -- but not -dyno
2122 = return $ dflags3 { dynOutputFile = Just $ dynOut (fromJust $ outputFile dflags3) }
2123 | otherwise
2124 = return dflags3
2125 where
2126 dynOut = flip addExtension (dynObjectSuf dflags3) . dropExtension
2127 dflags4 <- ifGeneratingDynamicToo dflags3 chooseOutput (return dflags3)
2128
2129 let (dflags5, consistency_warnings) = makeDynFlagsConsistent dflags4
2130
2131 dflags6 <- case dllSplitFile dflags5 of
2132 Nothing -> return (dflags5 { dllSplit = Nothing })
2133 Just f ->
2134 case dllSplit dflags5 of
2135 Just _ ->
2136 -- If dllSplit is out of date then it would have
2137 -- been set to Nothing. As it's a Just, it must be
2138 -- up-to-date.
2139 return dflags5
2140 Nothing ->
2141 do xs <- liftIO $ readFile f
2142 let ss = map (Set.fromList . words) (lines xs)
2143 return $ dflags5 { dllSplit = Just ss }
2144
2145 -- Set timer stats & heap size
2146 when (enableTimeStats dflags6) $ liftIO enableTimingStats
2147 case (ghcHeapSize dflags6) of
2148 Just x -> liftIO (setHeapSize x)
2149 _ -> return ()
2150
2151 liftIO $ setUnsafeGlobalDynFlags dflags6
2152
2153 return (dflags6, leftover, consistency_warnings ++ sh_warns ++ warns)
2154
2155 updateWays :: DynFlags -> DynFlags
2156 updateWays dflags
2157 = let theWays = sort $ nub $ ways dflags
2158 in dflags {
2159 ways = theWays,
2160 buildTag = mkBuildTag (filter (not . wayRTSOnly) theWays),
2161 rtsBuildTag = mkBuildTag theWays
2162 }
2163
2164 -- | Check (and potentially disable) any extensions that aren't allowed
2165 -- in safe mode.
2166 --
2167 -- The bool is to indicate if we are parsing command line flags (false means
2168 -- file pragma). This allows us to generate better warnings.
2169 safeFlagCheck :: Bool -> DynFlags -> (DynFlags, [Located String])
2170 safeFlagCheck _ dflags | safeLanguageOn dflags = (dflagsUnset, warns)
2171 where
2172 -- Handle illegal flags under safe language.
2173 (dflagsUnset, warns) = foldl check_method (dflags, []) unsafeFlags
2174
2175 check_method (df, warns) (str,loc,test,fix)
2176 | test df = (fix df, warns ++ safeFailure (loc df) str)
2177 | otherwise = (df, warns)
2178
2179 safeFailure loc str
2180 = [L loc $ str ++ " is not allowed in Safe Haskell; ignoring "
2181 ++ str]
2182
2183 safeFlagCheck cmdl dflags =
2184 case (safeInferOn dflags) of
2185 True | safeFlags -> (dflags', warn)
2186 True -> (dflags' { safeInferred = False }, warn)
2187 False -> (dflags', warn)
2188
2189 where
2190 -- dynflags and warn for when -fpackage-trust by itself with no safe
2191 -- haskell flag
2192 (dflags', warn)
2193 | safeHaskell dflags == Sf_None && not cmdl && packageTrustOn dflags
2194 = (gopt_unset dflags Opt_PackageTrust, pkgWarnMsg)
2195 | otherwise = (dflags, [])
2196
2197 pkgWarnMsg = [L (pkgTrustOnLoc dflags') $
2198 "-fpackage-trust ignored;" ++
2199 " must be specified with a Safe Haskell flag"]
2200
2201 -- Have we inferred Unsafe? See Note [HscMain . Safe Haskell Inference]
2202 safeFlags = all (\(_,_,t,_) -> not $ t dflags) unsafeFlagsForInfer
2203
2204
2205 {- **********************************************************************
2206 %* *
2207 DynFlags specifications
2208 %* *
2209 %********************************************************************* -}
2210
2211 -- | All dynamic flags option strings. These are the user facing strings for
2212 -- enabling and disabling options.
2213 allFlags :: [String]
2214 allFlags = [ '-':flagName flag
2215 | flag <- flagsAll
2216 , ok (flagOptKind flag) ]
2217 where ok (PrefixPred _ _) = False
2218 ok _ = True
2219
2220 {-
2221 - Below we export user facing symbols for GHC dynamic flags for use with the
2222 - GHC API.
2223 -}
2224
2225 -- All dynamic flags present in GHC.
2226 flagsAll :: [Flag (CmdLineP DynFlags)]
2227 flagsAll = package_flags ++ dynamic_flags
2228
2229 -- All dynamic flags, minus package flags, present in GHC.
2230 flagsDynamic :: [Flag (CmdLineP DynFlags)]
2231 flagsDynamic = dynamic_flags
2232
2233 -- ALl package flags present in GHC.
2234 flagsPackage :: [Flag (CmdLineP DynFlags)]
2235 flagsPackage = package_flags
2236
2237 --------------- The main flags themselves ------------------
2238 -- See Note [Updating flag description in the User's Guide]
2239 -- See Note [Supporting CLI completion]
2240 dynamic_flags :: [Flag (CmdLineP DynFlags)]
2241 dynamic_flags = [
2242 defFlag "n"
2243 (NoArg (addWarn "The -n flag is deprecated and no longer has any effect"))
2244 , defFlag "cpp" (NoArg (setExtensionFlag LangExt.Cpp))
2245 , defFlag "F" (NoArg (setGeneralFlag Opt_Pp))
2246 , defFlag "#include"
2247 (HasArg (\s -> do
2248 addCmdlineHCInclude s
2249 addWarn ("-#include and INCLUDE pragmas are " ++
2250 "deprecated: They no longer have any effect")))
2251 , defFlag "v" (OptIntSuffix setVerbosity)
2252
2253 , defGhcFlag "j" (OptIntSuffix (\n -> upd (\d -> d {parMakeCount = n})))
2254 , defFlag "sig-of" (sepArg setSigOf)
2255
2256 -- RTS options -------------------------------------------------------------
2257 , defFlag "H" (HasArg (\s -> upd (\d ->
2258 d { ghcHeapSize = Just $ fromIntegral (decodeSize s)})))
2259
2260 , defFlag "Rghc-timing" (NoArg (upd (\d -> d { enableTimeStats = True })))
2261
2262 ------- ways ---------------------------------------------------------------
2263 , defGhcFlag "prof" (NoArg (addWay WayProf))
2264 , defGhcFlag "eventlog" (NoArg (addWay WayEventLog))
2265 , defGhcFlag "smp"
2266 (NoArg (addWay WayThreaded >> deprecate "Use -threaded instead"))
2267 , defGhcFlag "debug" (NoArg (addWay WayDebug))
2268 , defGhcFlag "threaded" (NoArg (addWay WayThreaded))
2269
2270 , defGhcFlag "ticky"
2271 (NoArg (setGeneralFlag Opt_Ticky >> addWay WayDebug))
2272
2273 -- -ticky enables ticky-ticky code generation, and also implies -debug which
2274 -- is required to get the RTS ticky support.
2275
2276 ----- Linker --------------------------------------------------------
2277 , defGhcFlag "static" (NoArg removeWayDyn)
2278 , defGhcFlag "dynamic" (NoArg (addWay WayDyn))
2279 , defGhcFlag "rdynamic" $ noArg $
2280 #ifdef linux_HOST_OS
2281 addOptl "-rdynamic"
2282 #elif defined (mingw32_HOST_OS)
2283 addOptl "-Wl,--export-all-symbols"
2284 #else
2285 -- ignored for compat w/ gcc:
2286 id
2287 #endif
2288 , defGhcFlag "relative-dynlib-paths"
2289 (NoArg (setGeneralFlag Opt_RelativeDynlibPaths))
2290
2291 ------- Specific phases --------------------------------------------
2292 -- need to appear before -pgmL to be parsed as LLVM flags.
2293 , defFlag "pgmlo"
2294 (hasArg (\f -> alterSettings (\s -> s { sPgm_lo = (f,[])})))
2295 , defFlag "pgmlc"
2296 (hasArg (\f -> alterSettings (\s -> s { sPgm_lc = (f,[])})))
2297 , defFlag "pgmi"
2298 (hasArg (\f -> alterSettings (\s -> s { sPgm_i = f})))
2299 , defFlag "pgmL"
2300 (hasArg (\f -> alterSettings (\s -> s { sPgm_L = f})))
2301 , defFlag "pgmP"
2302 (hasArg setPgmP)
2303 , defFlag "pgmF"
2304 (hasArg (\f -> alterSettings (\s -> s { sPgm_F = f})))
2305 , defFlag "pgmc"
2306 (hasArg (\f -> alterSettings (\s -> s { sPgm_c = (f,[])})))
2307 , defFlag "pgms"
2308 (hasArg (\f -> alterSettings (\s -> s { sPgm_s = (f,[])})))
2309 , defFlag "pgma"
2310 (hasArg (\f -> alterSettings (\s -> s { sPgm_a = (f,[])})))
2311 , defFlag "pgml"
2312 (hasArg (\f -> alterSettings (\s -> s { sPgm_l = (f,[])})))
2313 , defFlag "pgmdll"
2314 (hasArg (\f -> alterSettings (\s -> s { sPgm_dll = (f,[])})))
2315 , defFlag "pgmwindres"
2316 (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f})))
2317 , defFlag "pgmlibtool"
2318 (hasArg (\f -> alterSettings (\s -> s { sPgm_libtool = f})))
2319
2320 -- need to appear before -optl/-opta to be parsed as LLVM flags.
2321 , defFlag "optlo"
2322 (hasArg (\f -> alterSettings (\s -> s { sOpt_lo = f : sOpt_lo s})))
2323 , defFlag "optlc"
2324 (hasArg (\f -> alterSettings (\s -> s { sOpt_lc = f : sOpt_lc s})))
2325 , defFlag "opti"
2326 (hasArg (\f -> alterSettings (\s -> s { sOpt_i = f : sOpt_i s})))
2327 , defFlag "optL"
2328 (hasArg (\f -> alterSettings (\s -> s { sOpt_L = f : sOpt_L s})))
2329 , defFlag "optP"
2330 (hasArg addOptP)
2331 , defFlag "optF"
2332 (hasArg (\f -> alterSettings (\s -> s { sOpt_F = f : sOpt_F s})))
2333 , defFlag "optc"
2334 (hasArg addOptc)
2335 , defFlag "opta"
2336 (hasArg (\f -> alterSettings (\s -> s { sOpt_a = f : sOpt_a s})))
2337 , defFlag "optl"
2338 (hasArg addOptl)
2339 , defFlag "optwindres"
2340 (hasArg (\f ->
2341 alterSettings (\s -> s { sOpt_windres = f : sOpt_windres s})))
2342
2343 , defGhcFlag "split-objs"
2344 (NoArg (if can_split
2345 then setGeneralFlag Opt_SplitObjs
2346 else addWarn "ignoring -fsplit-objs"))
2347
2348 , defGhcFlag "split-sections"
2349 (noArgM (\dflags -> do
2350 if platformHasSubsectionsViaSymbols (targetPlatform dflags)
2351 then do addErr $
2352 "-split-sections is not useful on this platform " ++
2353 "since it always uses subsections via symbols."
2354 return dflags
2355 else return (gopt_set dflags Opt_SplitSections)))
2356
2357 -------- ghc -M -----------------------------------------------------
2358 , defGhcFlag "dep-suffix" (hasArg addDepSuffix)
2359 , defGhcFlag "dep-makefile" (hasArg setDepMakefile)
2360 , defGhcFlag "include-pkg-deps" (noArg (setDepIncludePkgDeps True))
2361 , defGhcFlag "exclude-module" (hasArg addDepExcludeMod)
2362
2363 -------- Linking ----------------------------------------------------
2364 , defGhcFlag "no-link" (noArg (\d -> d{ ghcLink=NoLink }))
2365 , defGhcFlag "shared" (noArg (\d -> d{ ghcLink=LinkDynLib }))
2366 , defGhcFlag "staticlib" (noArg (\d -> d{ ghcLink=LinkStaticLib }))
2367 , defGhcFlag "dynload" (hasArg parseDynLibLoaderMode)
2368 , defGhcFlag "dylib-install-name" (hasArg setDylibInstallName)
2369 -- -dll-split is an internal flag, used only during the GHC build
2370 , defHiddenFlag "dll-split"
2371 (hasArg (\f d -> d{ dllSplitFile = Just f, dllSplit = Nothing }))
2372
2373 ------- Libraries ---------------------------------------------------
2374 , defFlag "L" (Prefix addLibraryPath)
2375 , defFlag "l" (hasArg (addLdInputs . Option . ("-l" ++)))
2376
2377 ------- Frameworks --------------------------------------------------
2378 -- -framework-path should really be -F ...
2379 , defFlag "framework-path" (HasArg addFrameworkPath)
2380 , defFlag "framework" (hasArg addCmdlineFramework)
2381
2382 ------- Output Redirection ------------------------------------------
2383 , defGhcFlag "odir" (hasArg setObjectDir)
2384 , defGhcFlag "o" (sepArg (setOutputFile . Just))
2385 , defGhcFlag "dyno" (sepArg (setDynOutputFile . Just))
2386 , defGhcFlag "ohi" (hasArg (setOutputHi . Just ))
2387 , defGhcFlag "osuf" (hasArg setObjectSuf)
2388 , defGhcFlag "dynosuf" (hasArg setDynObjectSuf)
2389 , defGhcFlag "hcsuf" (hasArg setHcSuf)
2390 , defGhcFlag "hisuf" (hasArg setHiSuf)
2391 , defGhcFlag "dynhisuf" (hasArg setDynHiSuf)
2392 , defGhcFlag "hidir" (hasArg setHiDir)
2393 , defGhcFlag "tmpdir" (hasArg setTmpDir)
2394 , defGhcFlag "stubdir" (hasArg setStubDir)
2395 , defGhcFlag "dumpdir" (hasArg setDumpDir)
2396 , defGhcFlag "outputdir" (hasArg setOutputDir)
2397 , defGhcFlag "ddump-file-prefix" (hasArg (setDumpPrefixForce . Just))
2398
2399 , defGhcFlag "dynamic-too" (NoArg (setGeneralFlag Opt_BuildDynamicToo))
2400
2401 ------- Keeping temporary files -------------------------------------
2402 -- These can be singular (think ghc -c) or plural (think ghc --make)
2403 , defGhcFlag "keep-hc-file" (NoArg (setGeneralFlag Opt_KeepHcFiles))
2404 , defGhcFlag "keep-hc-files" (NoArg (setGeneralFlag Opt_KeepHcFiles))
2405 , defGhcFlag "keep-s-file" (NoArg (setGeneralFlag Opt_KeepSFiles))
2406 , defGhcFlag "keep-s-files" (NoArg (setGeneralFlag Opt_KeepSFiles))
2407 , defGhcFlag "keep-llvm-file" (NoArg (do setObjTarget HscLlvm
2408 setGeneralFlag Opt_KeepLlvmFiles))
2409 , defGhcFlag "keep-llvm-files" (NoArg (do setObjTarget HscLlvm
2410 setGeneralFlag Opt_KeepLlvmFiles))
2411 -- This only makes sense as plural
2412 , defGhcFlag "keep-tmp-files" (NoArg (setGeneralFlag Opt_KeepTmpFiles))
2413
2414 ------- Miscellaneous ----------------------------------------------
2415 , defGhcFlag "no-auto-link-packages"
2416 (NoArg (unSetGeneralFlag Opt_AutoLinkPackages))
2417 , defGhcFlag "no-hs-main" (NoArg (setGeneralFlag Opt_NoHsMain))
2418 , defGhcFlag "with-rtsopts" (HasArg setRtsOpts)
2419 , defGhcFlag "rtsopts" (NoArg (setRtsOptsEnabled RtsOptsAll))
2420 , defGhcFlag "rtsopts=all" (NoArg (setRtsOptsEnabled RtsOptsAll))
2421 , defGhcFlag "rtsopts=some" (NoArg (setRtsOptsEnabled RtsOptsSafeOnly))
2422 , defGhcFlag "rtsopts=none" (NoArg (setRtsOptsEnabled RtsOptsNone))
2423 , defGhcFlag "no-rtsopts" (NoArg (setRtsOptsEnabled RtsOptsNone))
2424 , defGhcFlag "no-rtsopts-suggestions"
2425 (noArg (\d -> d {rtsOptsSuggestions = False} ))
2426
2427 , defGhcFlag "main-is" (SepArg setMainIs)
2428 , defGhcFlag "haddock" (NoArg (setGeneralFlag Opt_Haddock))
2429 , defGhcFlag "haddock-opts" (hasArg addHaddockOpts)
2430 , defGhcFlag "hpcdir" (SepArg setOptHpcDir)
2431 , defGhciFlag "ghci-script" (hasArg addGhciScript)
2432 , defGhciFlag "interactive-print" (hasArg setInteractivePrint)
2433 , defGhcFlag "ticky-allocd" (NoArg (setGeneralFlag Opt_Ticky_Allocd))
2434 , defGhcFlag "ticky-LNE" (NoArg (setGeneralFlag Opt_Ticky_LNE))
2435 , defGhcFlag "ticky-dyn-thunk" (NoArg (setGeneralFlag Opt_Ticky_Dyn_Thunk))
2436 ------- recompilation checker --------------------------------------
2437 , defGhcFlag "recomp" (NoArg (do unSetGeneralFlag Opt_ForceRecomp
2438 deprecate "Use -fno-force-recomp instead"))
2439 , defGhcFlag "no-recomp" (NoArg (do setGeneralFlag Opt_ForceRecomp
2440 deprecate "Use -fforce-recomp instead"))
2441 , defFlag "freverse-errors"
2442 (noArg (\d -> d {reverseErrors = True} ))
2443 , defFlag "fno-reverse-errors"
2444 (noArg (\d -> d {reverseErrors = False} ))
2445
2446 ------ HsCpp opts ---------------------------------------------------
2447 , defFlag "D" (AnySuffix (upd . addOptP))
2448 , defFlag "U" (AnySuffix (upd . addOptP))
2449
2450 ------- Include/Import Paths ----------------------------------------
2451 , defFlag "I" (Prefix addIncludePath)
2452 , defFlag "i" (OptPrefix addImportPath)
2453
2454 ------ Output style options -----------------------------------------
2455 , defFlag "dppr-user-length" (intSuffix (\n d -> d{ pprUserLength = n }))
2456 , defFlag "dppr-cols" (intSuffix (\n d -> d{ pprCols = n }))
2457 , defGhcFlag "dtrace-level" (intSuffix (\n d -> d{ traceLevel = n }))
2458 -- Suppress all that is suppressable in core dumps.
2459 -- Except for uniques, as some simplifier phases introduce new variables that
2460 -- have otherwise identical names.
2461 , defGhcFlag "dsuppress-all"
2462 (NoArg $ do setGeneralFlag Opt_SuppressCoercions
2463 setGeneralFlag Opt_SuppressVarKinds
2464 setGeneralFlag Opt_SuppressModulePrefixes
2465 setGeneralFlag Opt_SuppressTypeApplications
2466 setGeneralFlag Opt_SuppressIdInfo
2467 setGeneralFlag Opt_SuppressTypeSignatures)
2468
2469 ------ Debugging ----------------------------------------------------
2470 , defGhcFlag "dstg-stats" (NoArg (setGeneralFlag Opt_StgStats))
2471
2472 , defGhcFlag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
2473 , defGhcFlag "ddump-cmm-raw" (setDumpFlag Opt_D_dump_cmm_raw)
2474 , defGhcFlag "ddump-cmm-cfg" (setDumpFlag Opt_D_dump_cmm_cfg)
2475 , defGhcFlag "ddump-cmm-cbe" (setDumpFlag Opt_D_dump_cmm_cbe)
2476 , defGhcFlag "ddump-cmm-switch" (setDumpFlag Opt_D_dump_cmm_switch)
2477 , defGhcFlag "ddump-cmm-proc" (setDumpFlag Opt_D_dump_cmm_proc)
2478 , defGhcFlag "ddump-cmm-sink" (setDumpFlag Opt_D_dump_cmm_sink)
2479 , defGhcFlag "ddump-cmm-sp" (setDumpFlag Opt_D_dump_cmm_sp)
2480 , defGhcFlag "ddump-cmm-procmap" (setDumpFlag Opt_D_dump_cmm_procmap)
2481 , defGhcFlag "ddump-cmm-split" (setDumpFlag Opt_D_dump_cmm_split)
2482 , defGhcFlag "ddump-cmm-info" (setDumpFlag Opt_D_dump_cmm_info)
2483 , defGhcFlag "ddump-cmm-cps" (setDumpFlag Opt_D_dump_cmm_cps)
2484 , defGhcFlag "ddump-core-stats" (setDumpFlag Opt_D_dump_core_stats)
2485 , defGhcFlag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
2486 , defGhcFlag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
2487 , defGhcFlag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
2488 , defGhcFlag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
2489 , defGhcFlag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
2490 , defGhcFlag "ddump-asm-regalloc-stages"
2491 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
2492 , defGhcFlag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
2493 , defGhcFlag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
2494 , defGhcFlag "ddump-llvm" (NoArg (do setObjTarget HscLlvm
2495 setDumpFlag' Opt_D_dump_llvm))
2496 , defGhcFlag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
2497 , defGhcFlag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
2498 , defGhcFlag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
2499 , defGhcFlag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
2500 , defGhcFlag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
2501 , defGhcFlag "ddump-rule-rewrites" (setDumpFlag Opt_D_dump_rule_rewrites)
2502 , defGhcFlag "ddump-simpl-trace" (setDumpFlag Opt_D_dump_simpl_trace)
2503 , defGhcFlag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
2504 , defGhcFlag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
2505 , defGhcFlag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
2506 , defGhcFlag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
2507 , defGhcFlag "ddump-simpl-iterations"
2508 (setDumpFlag Opt_D_dump_simpl_iterations)
2509 , defGhcFlag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
2510 , defGhcFlag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
2511 , defGhcFlag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
2512 , defGhcFlag "ddump-call-arity" (setDumpFlag Opt_D_dump_call_arity)
2513 , defGhcFlag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
2514 , defGhcFlag "ddump-strsigs" (setDumpFlag Opt_D_dump_strsigs)
2515 , defGhcFlag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
2516 , defGhcFlag "ddump-types" (setDumpFlag Opt_D_dump_types)
2517 , defGhcFlag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
2518 , defGhcFlag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
2519 , defGhcFlag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
2520 , defGhcFlag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
2521 , defGhcFlag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
2522 , defGhcFlag "ddump-cs-trace" (setDumpFlag Opt_D_dump_cs_trace)
2523 , defGhcFlag "ddump-tc-trace" (NoArg (do
2524 setDumpFlag' Opt_D_dump_tc_trace
2525 setDumpFlag' Opt_D_dump_cs_trace))
2526 , defGhcFlag "ddump-vt-trace" (setDumpFlag Opt_D_dump_vt_trace)
2527 , defGhcFlag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
2528 , defGhcFlag "dth-dec-file" (setDumpFlag Opt_D_th_dec_file)
2529
2530 , defGhcFlag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
2531 , defGhcFlag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
2532 , defGhcFlag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
2533 , defGhcFlag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
2534 , defGhcFlag "dsource-stats" (setDumpFlag Opt_D_source_stats)
2535 , defGhcFlag "dverbose-core2core" (NoArg (do setVerbosity (Just 2)
2536 setVerboseCore2Core))
2537 , defGhcFlag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
2538 , defGhcFlag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
2539 , defGhcFlag "ddump-minimal-imports"
2540 (NoArg (setGeneralFlag Opt_D_dump_minimal_imports))
2541 , defGhcFlag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
2542 , defGhcFlag "ddump-hpc"
2543 (setDumpFlag Opt_D_dump_ticked) -- back compat
2544 , defGhcFlag "ddump-ticked" (setDumpFlag Opt_D_dump_ticked)
2545 , defGhcFlag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
2546 , defGhcFlag "ddump-mod-map" (setDumpFlag Opt_D_dump_mod_map)
2547 , defGhcFlag "ddump-view-pattern-commoning"
2548 (setDumpFlag Opt_D_dump_view_pattern_commoning)
2549 , defGhcFlag "ddump-to-file" (NoArg (setGeneralFlag Opt_DumpToFile))
2550 , defGhcFlag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
2551 , defGhcFlag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
2552 , defGhcFlag "dcore-lint"
2553 (NoArg (setGeneralFlag Opt_DoCoreLinting))
2554 , defGhcFlag "dstg-lint"
2555 (NoArg (setGeneralFlag Opt_DoStgLinting))
2556 , defGhcFlag "dcmm-lint"
2557 (NoArg (setGeneralFlag Opt_DoCmmLinting))
2558 , defGhcFlag "dasm-lint"
2559 (NoArg (setGeneralFlag Opt_DoAsmLinting))
2560 , defGhcFlag "dannot-lint"
2561 (NoArg (setGeneralFlag Opt_DoAnnotationLinting))
2562 , defGhcFlag "dshow-passes" (NoArg (do forceRecompile
2563 setVerbosity $ Just 2))
2564 , defGhcFlag "dfaststring-stats"
2565 (NoArg (setGeneralFlag Opt_D_faststring_stats))
2566 , defGhcFlag "dno-llvm-mangler"
2567 (NoArg (setGeneralFlag Opt_NoLlvmMangler)) -- hidden flag
2568 , defGhcFlag "ddump-debug" (setDumpFlag Opt_D_dump_debug)
2569
2570 ------ Machine dependant (-m<blah>) stuff ---------------------------
2571
2572 , defGhcFlag "msse" (noArg (\d -> d{ sseVersion = Just SSE1 }))
2573 , defGhcFlag "msse2" (noArg (\d -> d{ sseVersion = Just SSE2 }))
2574 , defGhcFlag "msse3" (noArg (\d -> d{ sseVersion = Just SSE3 }))
2575 , defGhcFlag "msse4" (noArg (\d -> d{ sseVersion = Just SSE4 }))
2576 , defGhcFlag "msse4.2" (noArg (\d -> d{ sseVersion = Just SSE42 }))
2577 , defGhcFlag "mavx" (noArg (\d -> d{ avx = True }))
2578 , defGhcFlag "mavx2" (noArg (\d -> d{ avx2 = True }))
2579 , defGhcFlag "mavx512cd" (noArg (\d -> d{ avx512cd = True }))
2580 , defGhcFlag "mavx512er" (noArg (\d -> d{ avx512er = True }))
2581 , defGhcFlag "mavx512f" (noArg (\d -> d{ avx512f = True }))
2582 , defGhcFlag "mavx512pf" (noArg (\d -> d{ avx512pf = True }))
2583
2584 ------ Warning opts -------------------------------------------------
2585 , defFlag "W" (NoArg (mapM_ setWarningFlag minusWOpts))
2586 , defFlag "Werror" (NoArg (setGeneralFlag Opt_WarnIsError))
2587 , defFlag "Wwarn" (NoArg (unSetGeneralFlag Opt_WarnIsError))
2588 , defFlag "Wnot" (NoArg (do upd (\dfs -> dfs {warningFlags = IntSet.empty})
2589 deprecate "Use -w or -Wno-everything instead"))
2590 , defFlag "w" (NoArg (upd (\dfs -> dfs {warningFlags = IntSet.empty})))
2591
2592 -- New-style uniform warning sets
2593 --
2594 -- Note that -Weverything > -Wall > -Wextra > -Wdefault > -Wno-everything
2595 , defFlag "Weverything" (NoArg (mapM_ setWarningFlag minusWeverythingOpts))
2596 , defFlag "Wno-everything"
2597 (NoArg (upd (\dfs -> dfs {warningFlags = IntSet.empty})))
2598
2599 , defFlag "Wall" (NoArg (mapM_ setWarningFlag minusWallOpts))
2600 , defFlag "Wno-all" (NoArg (mapM_ unSetWarningFlag minusWallOpts))
2601
2602 , defFlag "Wextra" (NoArg (mapM_ setWarningFlag minusWOpts))
2603 , defFlag "Wno-extra" (NoArg (mapM_ unSetWarningFlag minusWOpts))
2604
2605 , defFlag "Wdefault" (NoArg (mapM_ setWarningFlag standardWarnings))
2606 , defFlag "Wno-default" (NoArg (mapM_ unSetWarningFlag standardWarnings))
2607
2608 , defFlag "Wcompat" (NoArg (mapM_ setWarningFlag minusWcompatOpts))
2609 , defFlag "Wno-compat" (NoArg (mapM_ unSetWarningFlag minusWcompatOpts))
2610
2611 ------ Plugin flags ------------------------------------------------
2612 , defGhcFlag "fplugin-opt" (hasArg addPluginModuleNameOption)
2613 , defGhcFlag "fplugin" (hasArg addPluginModuleName)
2614 , defGhcFlag "ffrontend-opt" (hasArg addFrontendPluginOption)
2615
2616 ------ Optimisation flags ------------------------------------------
2617 , defGhcFlag "O" (noArgM (setOptLevel 1))
2618 , defGhcFlag "Onot" (noArgM (\dflags -> do deprecate "Use -O0 instead"
2619 setOptLevel 0 dflags))
2620 , defGhcFlag "Odph" (noArgM setDPHOpt)
2621 , defGhcFlag "O" (optIntSuffixM (\mb_n -> setOptLevel (mb_n `orElse` 1)))
2622 -- If the number is missing, use 1
2623
2624
2625 , defFlag "fmax-relevant-binds"
2626 (intSuffix (\n d -> d{ maxRelevantBinds = Just n }))
2627 , defFlag "fno-max-relevant-binds"
2628 (noArg (\d -> d{ maxRelevantBinds = Nothing }))
2629 , defFlag "fsimplifier-phases"
2630 (intSuffix (\n d -> d{ simplPhases = n }))
2631 , defFlag "fmax-simplifier-iterations"
2632 (intSuffix (\n d -> d{ maxSimplIterations = n }))
2633 , defFlag "fmax-pmcheck-iterations"
2634 (intSuffix (\n d -> d{ maxPmCheckIterations = n }))
2635 , defFlag "fsimpl-tick-factor"
2636 (intSuffix (\n d -> d{ simplTickFactor = n }))
2637 , defFlag "fspec-constr-threshold"
2638 (intSuffix (\n d -> d{ specConstrThreshold = Just n }))
2639 , defFlag "fno-spec-constr-threshold"
2640 (noArg (\d -> d{ specConstrThreshold = Nothing }))
2641 , defFlag "fspec-constr-count"
2642 (intSuffix (\n d -> d{ specConstrCount = Just n }))
2643 , defFlag "fno-spec-constr-count"
2644 (noArg (\d -> d{ specConstrCount = Nothing }))
2645 , defFlag "fspec-constr-recursive"
2646 (intSuffix (\n d -> d{ specConstrRecursive = n }))
2647 , defFlag "fliberate-case-threshold"
2648 (intSuffix (\n d -> d{ liberateCaseThreshold = Just n }))
2649 , defFlag "fno-liberate-case-threshold"
2650 (noArg (\d -> d{ liberateCaseThreshold = Nothing }))
2651 , defFlag "frule-check"
2652 (sepArg (\s d -> d{ ruleCheck = Just s }))
2653 , defFlag "freduction-depth"
2654 (intSuffix (\n d -> d{ reductionDepth = treatZeroAsInf n }))
2655 , defFlag "fconstraint-solver-iterations"
2656 (intSuffix (\n d -> d{ solverIterations = treatZeroAsInf n }))
2657 , defFlag "fcontext-stack"
2658 (intSuffixM (\n d ->
2659 do { deprecate $ "use -freduction-depth=" ++ show n ++ " instead"
2660 ; return $ d{ reductionDepth = treatZeroAsInf n } }))
2661 , defFlag "ftype-function-depth"
2662 (intSuffixM (\n d ->
2663 do { deprecate $ "use -freduction-depth=" ++ show n ++ " instead"
2664 ; return $ d{ reductionDepth = treatZeroAsInf n } }))
2665 , defFlag "fstrictness-before"
2666 (intSuffix (\n d -> d{ strictnessBefore = n : strictnessBefore d }))
2667 , defFlag "ffloat-lam-args"
2668 (intSuffix (\n d -> d{ floatLamArgs = Just n }))
2669 , defFlag "ffloat-all-lams"
2670 (noArg (\d -> d{ floatLamArgs = Nothing }))
2671
2672 , defFlag "fhistory-size" (intSuffix (\n d -> d{ historySize = n }))
2673
2674 , defFlag "funfolding-creation-threshold"
2675 (intSuffix (\n d -> d {ufCreationThreshold = n}))
2676 , defFlag "funfolding-use-threshold"
2677 (intSuffix (\n d -> d {ufUseThreshold = n}))
2678 , defFlag "funfolding-fun-discount"
2679 (intSuffix (\n d -> d {ufFunAppDiscount = n}))
2680 , defFlag "funfolding-dict-discount"
2681 (intSuffix (\n d -> d {ufDictDiscount = n}))
2682 , defFlag "funfolding-keeness-factor"
2683 (floatSuffix (\n d -> d {ufKeenessFactor = n}))
2684
2685 , defFlag "fmax-worker-args" (intSuffix (\n d -> d {maxWorkerArgs = n}))
2686
2687 , defGhciFlag "fghci-hist-size" (intSuffix (\n d -> d {ghciHistSize = n}))
2688 , defGhcFlag "fmax-inline-alloc-size"
2689 (intSuffix (\n d -> d{ maxInlineAllocSize = n }))
2690 , defGhcFlag "fmax-inline-memcpy-insns"
2691 (intSuffix (\n d -> d{ maxInlineMemcpyInsns = n }))
2692 , defGhcFlag "fmax-inline-memset-insns"
2693 (intSuffix (\n d -> d{ maxInlineMemsetInsns = n }))
2694
2695 , defGhcFlag "dinitial-unique"
2696 (intSuffix (\n d -> d{ initialUnique = n }))
2697 , defGhcFlag "dunique-increment"
2698 (intSuffix (\n d -> d{ uniqueIncrement = n }))
2699
2700 ------ Profiling ----------------------------------------------------
2701
2702 -- OLD profiling flags
2703 , defGhcFlag "auto-all" (noArg (\d -> d { profAuto = ProfAutoAll } ))
2704 , defGhcFlag "no-auto-all" (noArg (\d -> d { profAuto = NoProfAuto } ))
2705 , defGhcFlag "auto" (noArg (\d -> d { profAuto = ProfAutoExports } ))
2706 , defGhcFlag "no-auto" (noArg (\d -> d { profAuto = NoProfAuto } ))
2707 , defGhcFlag "caf-all"
2708 (NoArg (setGeneralFlag Opt_AutoSccsOnIndividualCafs))
2709 , defGhcFlag "no-caf-all"
2710 (NoArg (unSetGeneralFlag Opt_AutoSccsOnIndividualCafs))
2711
2712 -- NEW profiling flags
2713 , defGhcFlag "fprof-auto"
2714 (noArg (\d -> d { profAuto = ProfAutoAll } ))
2715 , defGhcFlag "fprof-auto-top"
2716 (noArg (\d -> d { profAuto = ProfAutoTop } ))
2717 , defGhcFlag "fprof-auto-exported"
2718 (noArg (\d -> d { profAuto = ProfAutoExports } ))
2719 , defGhcFlag "fprof-auto-calls"
2720 (noArg (\d -> d { profAuto = ProfAutoCalls } ))
2721 , defGhcFlag "fno-prof-auto"
2722 (noArg (\d -> d { profAuto = NoProfAuto } ))
2723
2724 ------ Compiler flags -----------------------------------------------
2725
2726 , defGhcFlag "fasm" (NoArg (setObjTarget HscAsm))
2727 , defGhcFlag "fvia-c" (NoArg
2728 (addWarn $ "The -fvia-c flag does nothing; " ++
2729 "it will be removed in a future GHC release"))
2730 , defGhcFlag "fvia-C" (NoArg
2731 (addWarn $ "The -fvia-C flag does nothing; " ++
2732 "it will be removed in a future GHC release"))
2733 , defGhcFlag "fllvm" (NoArg (setObjTarget HscLlvm))
2734
2735 , defFlag "fno-code" (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
2736 setTarget HscNothing))
2737 , defFlag "fbyte-code" (NoArg (setTarget HscInterpreted))
2738 , defFlag "fobject-code" (NoArg (setTargetWithPlatform defaultHscTarget))
2739 , defFlag "fglasgow-exts"
2740 (NoArg (do enableGlasgowExts
2741 deprecate "Use individual extensions instead"))
2742 , defFlag "fno-glasgow-exts"
2743 (NoArg (do disableGlasgowExts
2744 deprecate "Use individual extensions instead"))
2745 , defFlag "Wunused-binds" (NoArg enableUnusedBinds)
2746 , defFlag "Wno-unused-binds" (NoArg disableUnusedBinds)
2747 , defHiddenFlag "fwarn-unused-binds" (NoArg enableUnusedBinds)
2748 , defHiddenFlag "fno-warn-unused-binds" (NoArg disableUnusedBinds)
2749
2750 ------ Safe Haskell flags -------------------------------------------
2751 , defFlag "fpackage-trust" (NoArg setPackageTrust)
2752 , defFlag "fno-safe-infer" (noArg (\d -> d { safeInfer = False } ))
2753 , defGhcFlag "fPIC" (NoArg (setGeneralFlag Opt_PIC))
2754 , defGhcFlag "fno-PIC" (NoArg (unSetGeneralFlag Opt_PIC))
2755
2756 ------ Debugging flags ----------------------------------------------
2757 , defGhcFlag "g" (OptIntSuffix setDebugLevel)
2758 ]
2759 ++ map (mkFlag turnOn "" setGeneralFlag ) negatableFlags
2760 ++ map (mkFlag turnOff "no-" unSetGeneralFlag ) negatableFlags
2761 ++ map (mkFlag turnOn "d" setGeneralFlag ) dFlags
2762 ++ map (mkFlag turnOff "dno-" unSetGeneralFlag ) dFlags
2763 ++ map (mkFlag turnOn "f" setGeneralFlag ) fFlags
2764 ++ map (mkFlag turnOff "fno-" unSetGeneralFlag ) fFlags
2765 ++ map (mkFlag turnOn "W" setWarningFlag ) wWarningFlags
2766 ++ map (mkFlag turnOff "Wno-" unSetWarningFlag ) wWarningFlags
2767 ++ map (mkFlag turnOn "fwarn-" setWarningFlag . hideFlag) wWarningFlags
2768 ++ map (mkFlag turnOff "fno-warn-" unSetWarningFlag . hideFlag) wWarningFlags
2769 ++ map (mkFlag turnOn "f" setExtensionFlag ) fLangFlags
2770 ++ map (mkFlag turnOff "fno-" unSetExtensionFlag) fLangFlags
2771 ++ map (mkFlag turnOn "X" setExtensionFlag ) xFlags
2772 ++ map (mkFlag turnOff "XNo" unSetExtensionFlag) xFlags
2773 ++ map (mkFlag turnOn "X" setLanguage ) languageFlags
2774 ++ map (mkFlag turnOn "X" setSafeHaskell ) safeHaskellFlags
2775 ++ [ unrecognisedWarning
2776 , defFlag "XGenerics"
2777 (NoArg (deprecate $
2778 "it does nothing; look into -XDefaultSignatures " ++
2779 "and -XDeriveGeneric for generic programming support."))
2780 , defFlag "XNoGenerics"
2781 (NoArg (deprecate $
2782 "it does nothing; look into -XDefaultSignatures and " ++
2783 "-XDeriveGeneric for generic programming support.")) ]
2784
2785 -- | This is where we handle unrecognised warning flags. We only issue a warning
2786 -- if -Wunrecognised-warning-flags is set. See Trac #11429 for context.
2787 unrecognisedWarning :: Flag (CmdLineP DynFlags)
2788 unrecognisedWarning = defFlag "W" (Prefix action)
2789 where
2790 action :: String -> EwM (CmdLineP DynFlags) ()
2791 action flag = do
2792 f <- wopt Opt_WarnUnrecognisedWarningFlags <$> liftEwM getCmdLineState
2793 when f $ addWarn $ "unrecognised warning flag: -W"++flag
2794
2795 -- See Note [Supporting CLI completion]
2796 package_flags :: [Flag (CmdLineP DynFlags)]
2797 package_flags = [
2798 ------- Packages ----------------------------------------------------
2799 defFlag "package-db" (HasArg (addPkgConfRef . PkgConfFile))
2800 , defFlag "clear-package-db" (NoArg clearPkgConf)
2801 , defFlag "no-global-package-db" (NoArg removeGlobalPkgConf)
2802 , defFlag "no-user-package-db" (NoArg removeUserPkgConf)
2803 , defFlag "global-package-db" (NoArg (addPkgConfRef GlobalPkgConf))
2804 , defFlag "user-package-db" (NoArg (addPkgConfRef UserPkgConf))
2805
2806 -- backwards compat with GHC<=7.4 :
2807 , defFlag "package-conf" (HasArg $ \path -> do
2808 addPkgConfRef (PkgConfFile path)
2809 deprecate "Use -package-db instead")
2810 , defFlag "no-user-package-conf"
2811 (NoArg $ do removeUserPkgConf
2812 deprecate "Use -no-user-package-db instead")
2813
2814 , defGhcFlag "package-name" (HasArg $ \name -> do
2815 upd (setUnitId name))
2816 -- TODO: Since we JUST deprecated
2817 -- -this-package-key, let's keep this
2818 -- undeprecated for another cycle.
2819 -- Deprecate this eventually.
2820 -- deprecate "Use -this-unit-id instead")
2821 , defGhcFlag "this-package-key" (HasArg $ \name -> do
2822 upd (setUnitId name)
2823 deprecate "Use -this-unit-id instead")
2824 , defGhcFlag "this-unit-id" (hasArg setUnitId)
2825 , defFlag "package" (HasArg exposePackage)
2826 , defFlag "plugin-package-id" (HasArg exposePluginPackageId)
2827 , defFlag "plugin-package" (HasArg exposePluginPackage)
2828 , defFlag "package-id" (HasArg exposePackageId)
2829 , defFlag "hide-package" (HasArg hidePackage)
2830 , defFlag "hide-all-packages" (NoArg (setGeneralFlag Opt_HideAllPackages))
2831 , defFlag "hide-all-plugin-packages" (NoArg (setGeneralFlag Opt_HideAllPluginPackages))
2832 , defFlag "package-env" (HasArg setPackageEnv)
2833 , defFlag "ignore-package" (HasArg ignorePackage)
2834 , defFlag "syslib"
2835 (HasArg (\s -> do exposePackage s
2836 deprecate "Use -package instead"))
2837 , defFlag "distrust-all-packages"
2838 (NoArg (setGeneralFlag Opt_DistrustAllPackages))
2839 , defFlag "trust" (HasArg trustPackage)
2840 , defFlag "distrust" (HasArg distrustPackage)
2841 ]
2842 where
2843 setPackageEnv env = upd $ \s -> s { packageEnv = Just env }
2844
2845 -- | Make a list of flags for shell completion.
2846 -- Filter all available flags into two groups, for interactive GHC vs all other.
2847 flagsForCompletion :: Bool -> [String]
2848 flagsForCompletion isInteractive
2849 = [ '-':flagName flag
2850 | flag <- flagsAll
2851 , modeFilter (flagGhcMode flag)
2852 ]
2853 where
2854 modeFilter AllModes = True
2855 modeFilter OnlyGhci = isInteractive
2856 modeFilter OnlyGhc = not isInteractive
2857 modeFilter HiddenFlag = False
2858
2859 type TurnOnFlag = Bool -- True <=> we are turning the flag on
2860 -- False <=> we are turning the flag off
2861 turnOn :: TurnOnFlag; turnOn = True
2862 turnOff :: TurnOnFlag; turnOff = False
2863
2864 data FlagSpec flag
2865 = FlagSpec
2866 { flagSpecName :: String -- ^ Flag in string form
2867 , flagSpecFlag :: flag -- ^ Flag in internal form
2868 , flagSpecAction :: (TurnOnFlag -> DynP ())
2869 -- ^ Extra action to run when the flag is found
2870 -- Typically, emit a warning or error
2871 , flagSpecGhcMode :: GhcFlagMode
2872 -- ^ In which ghc mode the flag has effect
2873 }
2874
2875 -- | Define a new flag.
2876 flagSpec :: String -> flag -> FlagSpec flag
2877 flagSpec name flag = flagSpec' name flag nop
2878
2879 -- | Define a new flag with an effect.
2880 flagSpec' :: String -> flag -> (TurnOnFlag -> DynP ()) -> FlagSpec flag
2881 flagSpec' name flag act = FlagSpec name flag act AllModes
2882
2883 -- | Define a new flag for GHCi.
2884 flagGhciSpec :: String -> flag -> FlagSpec flag
2885 flagGhciSpec name flag = flagGhciSpec' name flag nop
2886
2887 -- | Define a new flag for GHCi with an effect.
2888 flagGhciSpec' :: String -> flag -> (TurnOnFlag -> DynP ()) -> FlagSpec flag
2889 flagGhciSpec' name flag act = FlagSpec name flag act OnlyGhci
2890
2891 -- | Define a new flag invisible to CLI completion.
2892 flagHiddenSpec :: String -> flag -> FlagSpec flag
2893 flagHiddenSpec name flag = flagHiddenSpec' name flag nop
2894
2895 -- | Define a new flag invisible to CLI completion with an effect.
2896 flagHiddenSpec' :: String -> flag -> (TurnOnFlag -> DynP ()) -> FlagSpec flag
2897 flagHiddenSpec' name flag act = FlagSpec name flag act HiddenFlag
2898
2899 -- | Hide a 'FlagSpec' from being displayed in @--show-options@.
2900 --
2901 -- This is for example useful for flags that are obsolete, but should not
2902 -- (yet) be deprecated for compatibility reasons.
2903 hideFlag :: FlagSpec a -> FlagSpec a
2904 hideFlag fs = fs { flagSpecGhcMode = HiddenFlag }
2905
2906 mkFlag :: TurnOnFlag -- ^ True <=> it should be turned on
2907 -> String -- ^ The flag prefix
2908 -> (flag -> DynP ()) -- ^ What to do when the flag is found
2909 -> FlagSpec flag -- ^ Specification of this particular flag
2910 -> Flag (CmdLineP DynFlags)
2911 mkFlag turn_on flagPrefix f (FlagSpec name flag extra_action mode)
2912 = Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on)) mode
2913
2914 deprecatedForExtension :: String -> TurnOnFlag -> DynP ()
2915 deprecatedForExtension lang turn_on
2916 = deprecate ("use -X" ++ flag ++
2917 " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
2918 where
2919 flag | turn_on = lang
2920 | otherwise = "No"++lang
2921
2922 useInstead :: String -> TurnOnFlag -> DynP ()
2923 useInstead flag turn_on
2924 = deprecate ("Use -f" ++ no ++ flag ++ " instead")
2925 where
2926 no = if turn_on then "" else "no-"
2927
2928 nop :: TurnOnFlag -> DynP ()
2929 nop _ = return ()
2930
2931 -- | These @-W\<blah\>@ flags can all be reversed with @-Wno-\<blah\>@
2932 wWarningFlags :: [FlagSpec WarningFlag]
2933 wWarningFlags = [
2934 -- See Note [Updating flag description in the User's Guide]
2935 -- See Note [Supporting CLI completion]
2936 -- Please keep the list of flags below sorted alphabetically
2937 flagSpec "alternative-layout-rule-transitional"
2938 Opt_WarnAlternativeLayoutRuleTransitional,
2939 flagSpec' "amp" Opt_WarnAMP
2940 (\_ -> deprecate "it has no effect"),
2941 flagSpec' "auto-orphans" Opt_WarnAutoOrphans
2942 (\_ -> deprecate "it has no effect"),
2943 flagSpec "deferred-type-errors" Opt_WarnDeferredTypeErrors,
2944 flagSpec "deprecations" Opt_WarnWarningsDeprecations,
2945 flagSpec "deprecated-flags" Opt_WarnDeprecatedFlags,
2946 flagSpec "deriving-typeable" Opt_WarnDerivingTypeable,
2947 flagSpec "dodgy-exports" Opt_WarnDodgyExports,
2948 flagSpec "dodgy-foreign-imports" Opt_WarnDodgyForeignImports,
2949 flagSpec "dodgy-imports" Opt_WarnDodgyImports,
2950 flagSpec "empty-enumerations" Opt_WarnEmptyEnumerations,
2951 flagSpec' "context-quantification" Opt_WarnContextQuantification
2952 (\_ -> deprecate "it is subsumed by an error message that cannot be disabled"),
2953 flagSpec' "duplicate-constraints" Opt_WarnDuplicateConstraints
2954 (\_ -> deprecate "it is subsumed by -Wredundant-constraints"),
2955 flagSpec "redundant-constraints" Opt_WarnRedundantConstraints,
2956 flagSpec "duplicate-exports" Opt_WarnDuplicateExports,
2957 flagSpec "hi-shadowing" Opt_WarnHiShadows,
2958 flagSpec "implicit-prelude" Opt_WarnImplicitPrelude,
2959 flagSpec "incomplete-patterns" Opt_WarnIncompletePatterns,
2960 flagSpec "incomplete-record-updates" Opt_WarnIncompletePatternsRecUpd,
2961 flagSpec "incomplete-uni-patterns" Opt_WarnIncompleteUniPatterns,
2962 flagSpec "inline-rule-shadowing" Opt_WarnInlineRuleShadowing,
2963 flagSpec "identities" Opt_WarnIdentities,
2964 flagSpec "missing-fields" Opt_WarnMissingFields,
2965 flagSpec "missing-import-lists" Opt_WarnMissingImportList,
2966 flagSpec "missing-local-sigs" Opt_WarnMissingLocalSigs,
2967 flagSpec "missing-methods" Opt_WarnMissingMethods,
2968 flagSpec "missing-monadfail-instances" Opt_WarnMissingMonadFailInstances,
2969 flagSpec "semigroup" Opt_WarnSemigroup,
2970 flagSpec "missing-signatures" Opt_WarnMissingSigs,
2971 flagSpec "missing-exported-sigs" Opt_WarnMissingExportedSigs,
2972 flagSpec "monomorphism-restriction" Opt_WarnMonomorphism,
2973 flagSpec "name-shadowing" Opt_WarnNameShadowing,
2974 flagSpec "noncanonical-monad-instances"
2975 Opt_WarnNonCanonicalMonadInstances,
2976 flagSpec "noncanonical-monadfail-instances"
2977 Opt_WarnNonCanonicalMonadFailInstances,
2978 flagSpec "noncanonical-monoid-instances"
2979 Opt_WarnNonCanonicalMonoidInstances,
2980 flagSpec "orphans" Opt_WarnOrphans,
2981 flagSpec "overflowed-literals" Opt_WarnOverflowedLiterals,
2982 flagSpec "overlapping-patterns" Opt_WarnOverlappingPatterns,
2983 flagSpec "missed-specialisations" Opt_WarnMissedSpecs,
2984 flagSpec "all-missed-specialisations" Opt_WarnAllMissedSpecs,
2985 flagSpec' "safe" Opt_WarnSafe setWarnSafe,
2986 flagSpec "trustworthy-safe" Opt_WarnTrustworthySafe,
2987 flagSpec "tabs" Opt_WarnTabs,
2988 flagSpec "type-defaults" Opt_WarnTypeDefaults,
2989 flagSpec "typed-holes" Opt_WarnTypedHoles,
2990 flagSpec "partial-type-signatures" Opt_WarnPartialTypeSignatures,
2991 flagSpec "unrecognised-pragmas" Opt_WarnUnrecognisedPragmas,
2992 flagSpec' "unsafe" Opt_WarnUnsafe setWarnUnsafe,
2993 flagSpec "unsupported-calling-conventions"
2994 Opt_WarnUnsupportedCallingConventions,
2995 flagSpec "unsupported-llvm-version" Opt_WarnUnsupportedLlvmVersion,
2996 flagSpec "unticked-promoted-constructors"
2997 Opt_WarnUntickedPromotedConstructors,
2998 flagSpec "unused-do-bind" Opt_WarnUnusedDoBind,
2999 flagSpec "unused-foralls" Opt_WarnUnusedForalls,
3000 flagSpec "unused-imports" Opt_WarnUnusedImports,
3001 flagSpec "unused-local-binds" Opt_WarnUnusedLocalBinds,
3002 flagSpec "unused-matches" Opt_WarnUnusedMatches,
3003 flagSpec "unused-pattern-binds" Opt_WarnUnusedPatternBinds,
3004 flagSpec "unused-top-binds" Opt_WarnUnusedTopBinds,
3005 flagSpec "unused-type-patterns" Opt_WarnUnusedTypePatterns,
3006 flagSpec "warnings-deprecations" Opt_WarnWarningsDeprecations,
3007 flagSpec "wrong-do-bind" Opt_WarnWrongDoBind,
3008 flagSpec "missing-pat-syn-sigs" Opt_WarnMissingPatSynSigs,
3009 flagSpec "unrecognised-warning-flags" Opt_WarnUnrecognisedWarningFlags ]
3010
3011 -- | These @-\<blah\>@ flags can all be reversed with @-no-\<blah\>@
3012 negatableFlags :: [FlagSpec GeneralFlag]
3013 negatableFlags = [
3014 flagGhciSpec "ignore-dot-ghci" Opt_IgnoreDotGhci ]
3015
3016 -- | These @-d\<blah\>@ flags can all be reversed with @-dno-\<blah\>@
3017 dFlags :: [FlagSpec GeneralFlag]
3018 dFlags = [
3019 -- See Note [Updating flag description in the User's Guide]
3020 -- See Note [Supporting CLI completion]
3021 -- Please keep the list of flags below sorted alphabetically
3022 flagSpec "ppr-case-as-let" Opt_PprCaseAsLet,
3023 flagSpec "ppr-ticks" Opt_PprShowTicks,
3024 flagSpec "suppress-coercions" Opt_SuppressCoercions,
3025 flagSpec "suppress-idinfo" Opt_SuppressIdInfo,
3026 flagSpec "suppress-unfoldings" Opt_SuppressUnfoldings,
3027 flagSpec "suppress-module-prefixes" Opt_SuppressModulePrefixes,
3028 flagSpec "suppress-type-applications" Opt_SuppressTypeApplications,
3029 flagSpec "suppress-type-signatures" Opt_SuppressTypeSignatures,
3030 flagSpec "suppress-uniques" Opt_SuppressUniques,
3031 flagSpec "suppress-var-kinds" Opt_SuppressVarKinds]
3032
3033 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
3034 fFlags :: [FlagSpec GeneralFlag]
3035 fFlags = [
3036 -- See Note [Updating flag description in the User's Guide]
3037 -- See Note [Supporting CLI completion]
3038 -- Please keep the list of flags below sorted alphabetically
3039 flagGhciSpec "break-on-error" Opt_BreakOnError,
3040 flagGhciSpec "break-on-exception" Opt_BreakOnException,
3041 flagSpec "building-cabal-package" Opt_BuildingCabalPackage,
3042 flagSpec "call-arity" Opt_CallArity,
3043 flagSpec "case-merge" Opt_CaseMerge,
3044 flagSpec "cmm-elim-common-blocks" Opt_CmmElimCommonBlocks,
3045 flagSpec "cmm-sink" Opt_CmmSink,
3046 flagSpec "cse" Opt_CSE,
3047 flagSpec "cpr-anal" Opt_CprAnal,
3048 flagSpec "defer-type-errors" Opt_DeferTypeErrors,
3049 flagSpec "defer-typed-holes" Opt_DeferTypedHoles,
3050 flagSpec "dicts-cheap" Opt_DictsCheap,
3051 flagSpec "dicts-strict" Opt_DictsStrict,
3052 flagSpec "dmd-tx-dict-sel" Opt_DmdTxDictSel,
3053 flagSpec "do-eta-reduction" Opt_DoEtaReduction,
3054 flagSpec "do-lambda-eta-expansion" Opt_DoLambdaEtaExpansion,
3055 flagSpec "eager-blackholing" Opt_EagerBlackHoling,
3056 flagSpec "embed-manifest" Opt_EmbedManifest,
3057 flagSpec "enable-rewrite-rules" Opt_EnableRewriteRules,
3058 flagSpec "error-spans" Opt_ErrorSpans,
3059 flagSpec "excess-precision" Opt_ExcessPrecision,
3060 flagSpec "expose-all-unfoldings" Opt_ExposeAllUnfoldings,
3061 flagSpec "external-interpreter" Opt_ExternalInterpreter,
3062 flagSpec "flat-cache" Opt_FlatCache,
3063 flagSpec "float-in" Opt_FloatIn,
3064 flagSpec "force-recomp" Opt_ForceRecomp,
3065 flagSpec "full-laziness" Opt_FullLaziness,
3066 flagSpec "fun-to-thunk" Opt_FunToThunk,
3067 flagSpec "gen-manifest" Opt_GenManifest,
3068 flagSpec "ghci-history" Opt_GhciHistory,
3069 flagSpec "ghci-sandbox" Opt_GhciSandbox,
3070 flagSpec "helpful-errors" Opt_HelpfulErrors,
3071 flagSpec "hpc" Opt_Hpc,
3072 flagSpec "ignore-asserts" Opt_IgnoreAsserts,
3073 flagSpec "ignore-interface-pragmas" Opt_IgnoreInterfacePragmas,
3074 flagGhciSpec "implicit-import-qualified" Opt_ImplicitImportQualified,
3075 flagSpec "irrefutable-tuples" Opt_IrrefutableTuples,
3076 flagSpec "kill-absence" Opt_KillAbsence,
3077 flagSpec "kill-one-shot" Opt_KillOneShot,
3078 flagSpec "late-dmd-anal" Opt_LateDmdAnal,
3079 flagSpec "liberate-case" Opt_LiberateCase,
3080 flagHiddenSpec "llvm-pass-vectors-in-regs" Opt_LlvmPassVectorsInRegisters,
3081 flagHiddenSpec "llvm-tbaa" Opt_LlvmTBAA,
3082 flagHiddenSpec "llvm-fill-undef-with-garbage" Opt_LlvmFillUndefWithGarbage,
3083 flagSpec "loopification" Opt_Loopification,
3084 flagSpec "omit-interface-pragmas" Opt_OmitInterfacePragmas,
3085 flagSpec "omit-yields" Opt_OmitYields,
3086 flagSpec "pedantic-bottoms" Opt_PedanticBottoms,
3087 flagSpec "pre-inlining" Opt_SimplPreInlining,
3088 flagGhciSpec "print-bind-contents" Opt_PrintBindContents,
3089 flagGhciSpec "print-bind-result" Opt_PrintBindResult,
3090 flagGhciSpec "print-evld-with-show" Opt_PrintEvldWithShow,
3091 flagSpec "print-explicit-foralls" Opt_PrintExplicitForalls,
3092 flagSpec "print-explicit-kinds" Opt_PrintExplicitKinds,
3093 flagSpec "print-explicit-coercions" Opt_PrintExplicitCoercions,
3094 flagSpec "print-equality-relations" Opt_PrintEqualityRelations,
3095 flagSpec "print-unicode-syntax" Opt_PrintUnicodeSyntax,
3096 flagSpec "print-expanded-synonyms" Opt_PrintExpandedSynonyms,
3097 flagSpec "print-potential-instances" Opt_PrintPotentialInstances,
3098 flagSpec "print-typechecker-elaboration" Opt_PrintTypecheckerElaboration,
3099 flagSpec "prof-cafs" Opt_AutoSccsOnIndividualCafs,
3100 flagSpec "prof-count-entries" Opt_ProfCountEntries,
3101 flagSpec "regs-graph" Opt_RegsGraph,
3102 flagSpec "regs-iterative" Opt_RegsIterative,
3103 flagSpec' "rewrite-rules" Opt_EnableRewriteRules
3104 (useInstead "enable-rewrite-rules"),
3105 flagSpec "shared-implib" Opt_SharedImplib,
3106 flagSpec "simple-list-literals" Opt_SimpleListLiterals,
3107 flagSpec "spec-constr" Opt_SpecConstr,
3108 flagSpec "specialise" Opt_Specialise,
3109 flagSpec "specialise-aggressively" Opt_SpecialiseAggressively,
3110 flagSpec "cross-module-specialise" Opt_CrossModuleSpecialise,
3111 flagSpec "static-argument-transformation" Opt_StaticArgumentTransformation,
3112 flagSpec "strictness" Opt_Strictness,
3113 flagSpec "use-rpaths" Opt_RPath,
3114 flagSpec "write-interface" Opt_WriteInterface,
3115 flagSpec "unbox-small-strict-fields" Opt_UnboxSmallStrictFields,
3116 flagSpec "unbox-strict-fields" Opt_UnboxStrictFields,
3117 flagSpec "vectorisation-avoidance" Opt_VectorisationAvoidance,
3118 flagSpec "vectorise" Opt_Vectorise,
3119 flagSpec "worker-wrapper" Opt_WorkerWrapper
3120 ]
3121
3122 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
3123 fLangFlags :: [FlagSpec LangExt.Extension]
3124 fLangFlags = [
3125 -- See Note [Updating flag description in the User's Guide]
3126 -- See Note [Supporting CLI completion]
3127 flagSpec' "th" LangExt.TemplateHaskell
3128 (\on -> deprecatedForExtension "TemplateHaskell" on
3129 >> checkTemplateHaskellOk on),
3130 flagSpec' "fi" LangExt.ForeignFunctionInterface
3131 (deprecatedForExtension "ForeignFunctionInterface"),
3132 flagSpec' "ffi" LangExt.ForeignFunctionInterface
3133 (deprecatedForExtension "ForeignFunctionInterface"),
3134 flagSpec' "arrows" LangExt.Arrows
3135 (deprecatedForExtension "Arrows"),
3136 flagSpec' "implicit-prelude" LangExt.ImplicitPrelude
3137 (deprecatedForExtension "ImplicitPrelude"),
3138 flagSpec' "bang-patterns" LangExt.BangPatterns
3139 (deprecatedForExtension "BangPatterns"),
3140 flagSpec' "monomorphism-restriction" LangExt.MonomorphismRestriction
3141 (deprecatedForExtension "MonomorphismRestriction"),
3142 flagSpec' "mono-pat-binds" LangExt.MonoPatBinds
3143 (deprecatedForExtension "MonoPatBinds"),
3144 flagSpec' "extended-default-rules" LangExt.ExtendedDefaultRules
3145 (deprecatedForExtension "ExtendedDefaultRules"),
3146 flagSpec' "implicit-params" LangExt.ImplicitParams
3147 (deprecatedForExtension "ImplicitParams"),
3148 flagSpec' "scoped-type-variables" LangExt.ScopedTypeVariables
3149 (deprecatedForExtension "ScopedTypeVariables"),
3150 flagSpec' "parr" LangExt.ParallelArrays
3151 (deprecatedForExtension "ParallelArrays"),
3152 flagSpec' "PArr" LangExt.ParallelArrays
3153 (deprecatedForExtension "ParallelArrays"),
3154 flagSpec' "allow-overlapping-instances" LangExt.OverlappingInstances
3155 (deprecatedForExtension "OverlappingInstances"),
3156 flagSpec' "allow-undecidable-instances" LangExt.UndecidableInstances
3157 (deprecatedForExtension "UndecidableInstances"),
3158 flagSpec' "allow-incoherent-instances" LangExt.IncoherentInstances
3159 (deprecatedForExtension "IncoherentInstances")
3160 ]
3161
3162 supportedLanguages :: [String]
3163 supportedLanguages = map flagSpecName languageFlags
3164
3165 supportedLanguageOverlays :: [String]
3166 supportedLanguageOverlays = map flagSpecName safeHaskellFlags
3167
3168 supportedExtensions :: [String]
3169 supportedExtensions = concatMap toFlagSpecNamePair xFlags
3170 where
3171 toFlagSpecNamePair flg
3172 #ifndef GHCI
3173 -- make sure that `ghc --supported-extensions` omits
3174 -- "TemplateHaskell" when it's known to be unsupported. See also
3175 -- GHC #11102 for rationale
3176 | flagSpecFlag flg == LangExt.TemplateHaskell = [noName]
3177 #endif
3178 | otherwise = [name, noName]
3179 where
3180 noName = "No" ++ name
3181 name = flagSpecName flg
3182
3183 supportedLanguagesAndExtensions :: [String]
3184 supportedLanguagesAndExtensions =
3185 supportedLanguages ++ supportedLanguageOverlays ++ supportedExtensions
3186
3187 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
3188 languageFlags :: [FlagSpec Language]
3189 languageFlags = [
3190 flagSpec "Haskell98" Haskell98,
3191 flagSpec "Haskell2010" Haskell2010
3192 ]
3193
3194 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
3195 -- They are used to place hard requirements on what GHC Haskell language
3196 -- features can be used.
3197 safeHaskellFlags :: [FlagSpec SafeHaskellMode]
3198 safeHaskellFlags = [mkF Sf_Unsafe, mkF Sf_Trustworthy, mkF Sf_Safe]
3199 where mkF flag = flagSpec (show flag) flag
3200
3201 -- | These -X<blah> flags can all be reversed with -XNo<blah>
3202 xFlags :: [FlagSpec LangExt.Extension]
3203 xFlags = [
3204 -- See Note [Updating flag description in the User's Guide]
3205 -- See Note [Supporting CLI completion]
3206 -- See Note [Adding a language extension]
3207 -- Please keep the list of flags below sorted alphabetically
3208 flagSpec "AllowAmbiguousTypes" LangExt.AllowAmbiguousTypes,
3209 flagSpec "AlternativeLayoutRule" LangExt.AlternativeLayoutRule,
3210 flagSpec "AlternativeLayoutRuleTransitional"
3211 LangExt.AlternativeLayoutRuleTransitional,
3212 flagSpec "Arrows" LangExt.Arrows,
3213 flagSpec "AutoDeriveTypeable" LangExt.AutoDeriveTypeable,
3214 flagSpec "BangPatterns" LangExt.BangPatterns,
3215 flagSpec "BinaryLiterals" LangExt.BinaryLiterals,
3216 flagSpec "CApiFFI" LangExt.CApiFFI,
3217 flagSpec "CPP" LangExt.Cpp,
3218 flagSpec "ConstrainedClassMethods" LangExt.ConstrainedClassMethods,
3219 flagSpec "ConstraintKinds" LangExt.ConstraintKinds,
3220 flagSpec "DataKinds" LangExt.DataKinds,
3221 flagSpec' "DatatypeContexts" LangExt.DatatypeContexts
3222 (\ turn_on -> when turn_on $
3223 deprecate $ "It was widely considered a misfeature, " ++
3224 "and has been removed from the Haskell language."),
3225 flagSpec "DefaultSignatures" LangExt.DefaultSignatures,
3226 flagSpec "DeriveAnyClass" LangExt.DeriveAnyClass,
3227 flagSpec "DeriveDataTypeable" LangExt.DeriveDataTypeable,
3228 flagSpec "DeriveFoldable" LangExt.DeriveFoldable,
3229 flagSpec "DeriveFunctor" LangExt.DeriveFunctor,
3230 flagSpec "DeriveGeneric" LangExt.DeriveGeneric,
3231 flagSpec "DeriveLift" LangExt.DeriveLift,
3232 flagSpec "DeriveTraversable" LangExt.DeriveTraversable,
3233 flagSpec "DisambiguateRecordFields" LangExt.DisambiguateRecordFields,
3234 flagSpec "DoAndIfThenElse" LangExt.DoAndIfThenElse,
3235 flagSpec' "DoRec" LangExt.RecursiveDo
3236 (deprecatedForExtension "RecursiveDo"),
3237 flagSpec "DuplicateRecordFields" LangExt.DuplicateRecordFields,
3238 flagSpec "EmptyCase" LangExt.EmptyCase,
3239 flagSpec "EmptyDataDecls" LangExt.EmptyDataDecls,
3240 flagSpec "ExistentialQuantification" LangExt.ExistentialQuantification,
3241 flagSpec "ExplicitForAll" LangExt.ExplicitForAll,
3242 flagSpec "ExplicitNamespaces" LangExt.ExplicitNamespaces,
3243 flagSpec "ExtendedDefaultRules" LangExt.ExtendedDefaultRules,
3244 flagSpec "FlexibleContexts" LangExt.FlexibleContexts,
3245 flagSpec "FlexibleInstances" LangExt.FlexibleInstances,
3246 flagSpec "ForeignFunctionInterface" LangExt.ForeignFunctionInterface,
3247 flagSpec "FunctionalDependencies" LangExt.FunctionalDependencies,
3248 flagSpec "GADTSyntax" LangExt.GADTSyntax,
3249 flagSpec "GADTs" LangExt.GADTs,
3250 flagSpec "GHCForeignImportPrim" LangExt.GHCForeignImportPrim,
3251 flagSpec' "GeneralizedNewtypeDeriving" LangExt.GeneralizedNewtypeDeriving
3252 setGenDeriving,
3253 flagSpec "ImplicitParams" LangExt.ImplicitParams,
3254 flagSpec "ImplicitPrelude" LangExt.ImplicitPrelude,
3255 flagSpec "ImpredicativeTypes" LangExt.ImpredicativeTypes,
3256 flagSpec' "IncoherentInstances" LangExt.IncoherentInstances
3257 setIncoherentInsts,
3258 flagSpec "TypeFamilyDependencies" LangExt.TypeFamilyDependencies,
3259 flagSpec "InstanceSigs" LangExt.InstanceSigs,
3260 flagSpec "ApplicativeDo" LangExt.ApplicativeDo,
3261 flagSpec "InterruptibleFFI" LangExt.InterruptibleFFI,
3262 flagSpec "JavaScriptFFI" LangExt.JavaScriptFFI,
3263 flagSpec "KindSignatures" LangExt.KindSignatures,
3264 flagSpec "LambdaCase" LangExt.LambdaCase,
3265 flagSpec "LiberalTypeSynonyms" LangExt.LiberalTypeSynonyms,
3266 flagSpec "MagicHash" LangExt.MagicHash,
3267 flagSpec "MonadComprehensions" LangExt.MonadComprehensions,
3268 flagSpec "MonadFailDesugaring" LangExt.MonadFailDesugaring,
3269 flagSpec "MonoLocalBinds" LangExt.MonoLocalBinds,
3270 flagSpec' "MonoPatBinds" LangExt.MonoPatBinds
3271 (\ turn_on -> when turn_on $
3272 deprecate "Experimental feature now removed; has no effect"),
3273 flagSpec "MonomorphismRestriction" LangExt.MonomorphismRestriction,
3274 flagSpec "MultiParamTypeClasses" LangExt.MultiParamTypeClasses,
3275 flagSpec "MultiWayIf" LangExt.MultiWayIf,
3276 flagSpec "NPlusKPatterns" LangExt.NPlusKPatterns,
3277 flagSpec "NamedFieldPuns" LangExt.RecordPuns,
3278 flagSpec "NamedWildCards" LangExt.NamedWildCards,
3279 flagSpec "NegativeLiterals" LangExt.NegativeLiterals,
3280 flagSpec "NondecreasingIndentation" LangExt.NondecreasingIndentation,
3281 flagSpec' "NullaryTypeClasses" LangExt.NullaryTypeClasses
3282 (deprecatedForExtension "MultiParamTypeClasses"),
3283 flagSpec "NumDecimals" LangExt.NumDecimals,
3284 flagSpec' "OverlappingInstances" LangExt.OverlappingInstances
3285 setOverlappingInsts,
3286 flagSpec "OverloadedLabels" LangExt.OverloadedLabels,
3287 flagSpec "OverloadedLists" LangExt.OverloadedLists,
3288 flagSpec "OverloadedStrings" LangExt.OverloadedStrings,
3289 flagSpec "PackageImports" LangExt.PackageImports,
3290 flagSpec "ParallelArrays" LangExt.ParallelArrays,
3291 flagSpec "ParallelListComp" LangExt.ParallelListComp,
3292 flagSpec "PartialTypeSignatures" LangExt.PartialTypeSignatures,
3293 flagSpec "PatternGuards" LangExt.PatternGuards,
3294 flagSpec' "PatternSignatures" LangExt.ScopedTypeVariables
3295 (deprecatedForExtension "ScopedTypeVariables"),
3296 flagSpec "PatternSynonyms" LangExt.PatternSynonyms,
3297 flagSpec "PolyKinds" LangExt.PolyKinds,
3298 flagSpec "PolymorphicComponents" LangExt.RankNTypes,
3299 flagSpec "PostfixOperators" LangExt.PostfixOperators,
3300 flagSpec "QuasiQuotes" LangExt.QuasiQuotes,
3301 flagSpec "Rank2Types" LangExt.RankNTypes,
3302 flagSpec "RankNTypes" LangExt.RankNTypes,
3303 flagSpec "RebindableSyntax" LangExt.RebindableSyntax,
3304 flagSpec' "RecordPuns" LangExt.RecordPuns
3305 (deprecatedForExtension "NamedFieldPuns"),
3306 flagSpec "RecordWildCards" LangExt.RecordWildCards,
3307 flagSpec "RecursiveDo" LangExt.RecursiveDo,
3308 flagSpec "RelaxedLayout" LangExt.RelaxedLayout,
3309 flagSpec' "RelaxedPolyRec" LangExt.RelaxedPolyRec
3310 (\ turn_on -> unless turn_on $
3311 deprecate "You can't turn off RelaxedPolyRec any more"),
3312 flagSpec "RoleAnnotations" LangExt.RoleAnnotations,
3313 flagSpec "ScopedTypeVariables" LangExt.ScopedTypeVariables,
3314 flagSpec "StandaloneDeriving" LangExt.StandaloneDeriving,
3315 flagSpec "StaticPointers" LangExt.StaticPointers,
3316 flagSpec "Strict" LangExt.Strict,
3317 flagSpec "StrictData" LangExt.StrictData,
3318 flagSpec' "TemplateHaskell" LangExt.TemplateHaskell
3319 checkTemplateHaskellOk,
3320 flagSpec "TemplateHaskellQuotes" LangExt.TemplateHaskellQuotes,
3321 flagSpec "TraditionalRecordSyntax" LangExt.TraditionalRecordSyntax,
3322 flagSpec "TransformListComp" LangExt.TransformListComp,
3323 flagSpec "TupleSections" LangExt.TupleSections,
3324 flagSpec "TypeApplications" LangExt.TypeApplications,
3325 flagSpec "TypeInType" LangExt.TypeInType,
3326 flagSpec "TypeFamilies" LangExt.TypeFamilies,
3327 flagSpec "TypeOperators" LangExt.TypeOperators,
3328 flagSpec "TypeSynonymInstances" LangExt.TypeSynonymInstances,
3329 flagSpec "UnboxedTuples" LangExt.UnboxedTuples,
3330 flagSpec "UndecidableInstances" LangExt.UndecidableInstances,
3331 flagSpec "UndecidableSuperClasses" LangExt.UndecidableSuperClasses,
3332 flagSpec "UnicodeSyntax" LangExt.UnicodeSyntax,
3333 flagSpec "UnliftedFFITypes" LangExt.UnliftedFFITypes,
3334 flagSpec "ViewPatterns" LangExt.ViewPatterns
3335 ]
3336
3337 defaultFlags :: Settings -> [GeneralFlag]
3338 defaultFlags settings
3339 -- See Note [Updating flag description in the User's Guide]
3340 = [ Opt_AutoLinkPackages,
3341 Opt_EmbedManifest,
3342 Opt_FlatCache,
3343 Opt_GenManifest,
3344 Opt_GhciHistory,
3345 Opt_GhciSandbox,
3346 Opt_HelpfulErrors,
3347 Opt_OmitYields,
3348 Opt_PrintBindContents,
3349 Opt_ProfCountEntries,
3350 Opt_RPath,
3351 Opt_SharedImplib,
3352 Opt_SimplPreInlining
3353 ]
3354
3355 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
3356 -- The default -O0 options
3357
3358 ++ default_PIC platform
3359
3360 ++ concatMap (wayGeneralFlags platform) (defaultWays settings)
3361
3362 where platform = sTargetPlatform settings
3363
3364 default_PIC :: Platform -> [GeneralFlag]
3365 default_PIC platform =
3366 case (platformOS platform, platformArch platform) of
3367 (OSDarwin, ArchX86_64) -> [Opt_PIC]
3368 (OSOpenBSD, ArchX86_64) -> [Opt_PIC] -- Due to PIE support in
3369 -- OpenBSD since 5.3 release
3370 -- (1 May 2013) we need to
3371 -- always generate PIC. See
3372 -- #10597 for more
3373 -- information.
3374 _ -> []
3375
3376 -- General flags that are switched on/off when other general flags are switched
3377 -- on
3378 impliedGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]
3379 impliedGFlags = [(Opt_DeferTypeErrors, turnOn, Opt_DeferTypedHoles)
3380 ,(Opt_Strictness, turnOn, Opt_WorkerWrapper)
3381 ]
3382
3383 -- General flags that are switched on/off when other general flags are switched
3384 -- off
3385 impliedOffGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]
3386 impliedOffGFlags = [(Opt_Strictness, turnOff, Opt_WorkerWrapper)]
3387
3388 impliedXFlags :: [(LangExt.Extension, TurnOnFlag, LangExt.Extension)]
3389 impliedXFlags
3390 -- See Note [Updating flag description in the User's Guide]
3391 = [ (LangExt.RankNTypes, turnOn, LangExt.ExplicitForAll)
3392 , (LangExt.ScopedTypeVariables, turnOn, LangExt.ExplicitForAll)
3393 , (LangExt.LiberalTypeSynonyms, turnOn, LangExt.ExplicitForAll)
3394 , (LangExt.ExistentialQuantification, turnOn, LangExt.ExplicitForAll)
3395 , (LangExt.FlexibleInstances, turnOn, LangExt.TypeSynonymInstances)
3396 , (LangExt.FunctionalDependencies, turnOn, LangExt.MultiParamTypeClasses)
3397 , (LangExt.MultiParamTypeClasses, turnOn, LangExt.ConstrainedClassMethods) -- c.f. Trac #7854
3398 , (LangExt.TypeFamilyDependencies, turnOn, LangExt.TypeFamilies)
3399
3400 , (LangExt.RebindableSyntax, turnOff, LangExt.ImplicitPrelude) -- NB: turn off!
3401
3402 , (LangExt.GADTs, turnOn, LangExt.GADTSyntax)
3403 , (LangExt.GADTs, turnOn, LangExt.MonoLocalBinds)
3404 , (LangExt.TypeFamilies, turnOn, LangExt.MonoLocalBinds)
3405
3406 , (LangExt.TypeFamilies, turnOn, LangExt.KindSignatures) -- Type families use kind signatures
3407 , (LangExt.PolyKinds, turnOn, LangExt.KindSignatures) -- Ditto polymorphic kinds
3408 , (LangExt.TypeInType, turnOn, LangExt.DataKinds)
3409 , (LangExt.TypeInType, turnOn, LangExt.PolyKinds)
3410 , (LangExt.TypeInType, turnOn, LangExt.KindSignatures)
3411
3412 -- AutoDeriveTypeable is not very useful without DeriveDataTypeable
3413 , (LangExt.AutoDeriveTypeable, turnOn, LangExt.DeriveDataTypeable)
3414
3415 -- We turn this on so that we can export associated type
3416 -- type synonyms in subordinates (e.g. MyClass(type AssocType))
3417 , (LangExt.TypeFamilies, turnOn, LangExt.ExplicitNamespaces)
3418 , (LangExt.TypeOperators, turnOn, LangExt.ExplicitNamespaces)
3419
3420 , (LangExt.ImpredicativeTypes, turnOn, LangExt.RankNTypes)
3421
3422 -- Record wild-cards implies field disambiguation
3423 -- Otherwise if you write (C {..}) you may well get
3424 -- stuff like " 'a' not in scope ", which is a bit silly
3425 -- if the compiler has just filled in field 'a' of constructor 'C'
3426 , (LangExt.RecordWildCards, turnOn, LangExt.DisambiguateRecordFields)
3427
3428 , (LangExt.ParallelArrays, turnOn, LangExt.ParallelListComp)
3429
3430 , (LangExt.JavaScriptFFI, turnOn, LangExt.InterruptibleFFI)
3431
3432 , (LangExt.DeriveTraversable, turnOn, LangExt.DeriveFunctor)
3433 , (LangExt.DeriveTraversable, turnOn, LangExt.DeriveFoldable)
3434
3435 -- Duplicate record fields require field disambiguation
3436 , (LangExt.DuplicateRecordFields, turnOn, LangExt.DisambiguateRecordFields)
3437
3438 , (LangExt.TemplateHaskell, turnOn, LangExt.TemplateHaskellQuotes)
3439 , (LangExt.Strict, turnOn, LangExt.StrictData)
3440 , (LangExt.TypeApplications, turnOn, LangExt.AllowAmbiguousTypes)
3441 ]
3442
3443 -- Note [Documenting optimisation flags]
3444 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3445 --
3446 -- If you change the list of flags enabled for particular optimisation levels
3447 -- please remember to update the User's Guide. The relevant files are:
3448 --
3449 -- * utils/mkUserGuidePart/Options/
3450 -- * docs/users_guide/using.rst
3451 --
3452 -- The first contains the Flag Refrence section, which breifly lists all
3453 -- available flags. The second contains a detailed description of the
3454 -- flags. Both places should contain information whether a flag is implied by
3455 -- -O0, -O or -O2.
3456
3457 optLevelFlags :: [([Int], GeneralFlag)]
3458 optLevelFlags -- see Note [Documenting optimisation flags]
3459 = [ ([0,1,2], Opt_DoLambdaEtaExpansion)
3460 , ([0,1,2], Opt_DmdTxDictSel)
3461 , ([0,1,2], Opt_LlvmTBAA)
3462 , ([0,1,2], Opt_VectorisationAvoidance)
3463 -- This one is important for a tiresome reason:
3464 -- we want to make sure that the bindings for data
3465 -- constructors are eta-expanded. This is probably
3466 -- a good thing anyway, but it seems fragile.
3467
3468 , ([0], Opt_IgnoreInterfacePragmas)
3469 , ([0], Opt_OmitInterfacePragmas)
3470
3471 , ([1,2], Opt_CallArity)
3472 , ([1,2], Opt_CaseMerge)
3473 , ([1,2], Opt_CmmElimCommonBlocks)
3474 , ([1,2], Opt_CmmSink)
3475 , ([1,2], Opt_CSE)
3476 , ([1,2], Opt_DoEtaReduction)
3477 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
3478 -- in PrelRules
3479 , ([1,2], Opt_FloatIn)
3480 , ([1,2], Opt_FullLaziness)
3481 , ([1,2], Opt_IgnoreAsserts)
3482 , ([1,2], Opt_Loopification)
3483 , ([1,2], Opt_Specialise)
3484 , ([1,2], Opt_CrossModuleSpecialise)
3485 , ([1,2], Opt_Strictness)
3486 , ([1,2], Opt_UnboxSmallStrictFields)
3487 , ([1,2], Opt_CprAnal)
3488 , ([1,2], Opt_WorkerWrapper)
3489
3490 , ([2], Opt_LiberateCase)
3491 , ([2], Opt_SpecConstr)
3492 -- , ([2], Opt_RegsGraph)
3493 -- RegsGraph suffers performance regression. See #7679
3494 -- , ([2], Opt_StaticArgumentTransformation)
3495 -- Static Argument Transformation needs investigation. See #9374
3496 ]
3497
3498 -- -----------------------------------------------------------------------------
3499 -- Standard sets of warning options
3500
3501 -- Note [Documenting warning flags]
3502 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3503 --
3504 -- If you change the list of warning enabled by default
3505 -- please remember to update the User's Guide. The relevant file is:
3506 --
3507 -- * utils/mkUserGuidePart/
3508 -- * docs/users_guide/using-warnings.rst
3509
3510 -- | Warnings enabled unless specified otherwise
3511 standardWarnings :: [WarningFlag]
3512 standardWarnings -- see Note [Documenting warning flags]
3513 = [ Opt_WarnOverlappingPatterns,
3514 Opt_WarnWarningsDeprecations,
3515 Opt_WarnDeprecatedFlags,
3516 Opt_WarnDeferredTypeErrors,
3517 Opt_WarnTypedHoles,
3518 Opt_WarnPartialTypeSignatures,
3519 Opt_WarnUnrecognisedPragmas,
3520 Opt_WarnDuplicateExports,
3521 Opt_WarnOverflowedLiterals,
3522 Opt_WarnEmptyEnumerations,
3523 Opt_WarnMissingFields,
3524 Opt_WarnMissingMethods,
3525 Opt_WarnWrongDoBind,
3526 Opt_WarnUnsupportedCallingConventions,
3527 Opt_WarnDodgyForeignImports,
3528 Opt_WarnInlineRuleShadowing,
3529 Opt_WarnAlternativeLayoutRuleTransitional,
3530 Opt_WarnUnsupportedLlvmVersion,
3531 Opt_WarnTabs,
3532 Opt_WarnUnrecognisedWarningFlags
3533 ]
3534
3535 -- | Things you get with -W
3536 minusWOpts :: [WarningFlag]
3537 minusWOpts
3538 = standardWarnings ++
3539 [ Opt_WarnUnusedTopBinds,
3540 Opt_WarnUnusedLocalBinds,
3541 Opt_WarnUnusedPatternBinds,
3542 Opt_WarnUnusedMatches,
3543 Opt_WarnUnusedForalls,
3544 Opt_WarnUnusedImports,
3545 Opt_WarnIncompletePatterns,
3546 Opt_WarnDodgyExports,
3547 Opt_WarnDodgyImports
3548 ]
3549
3550 -- | Things you get with -Wall
3551 minusWallOpts :: [WarningFlag]
3552 minusWallOpts
3553 = minusWOpts ++
3554 [ Opt_WarnTypeDefaults,
3555 Opt_WarnNameShadowing,
3556 Opt_WarnMissingSigs,
3557 Opt_WarnHiShadows,
3558 Opt_WarnOrphans,
3559 Opt_WarnUnusedDoBind,
3560 Opt_WarnTrustworthySafe,
3561 Opt_WarnUntickedPromotedConstructors,
3562 Opt_WarnMissingPatSynSigs
3563 ]
3564
3565 -- | Things you get with -Weverything, i.e. *all* known warnings flags
3566 minusWeverythingOpts :: [WarningFlag]
3567 minusWeverythingOpts = [ toEnum 0 .. ]
3568
3569 -- | Things you get with -Wcompat.
3570 --
3571 -- This is intended to group together warnings that will be enabled by default
3572 -- at some point in the future, so that library authors eager to make their
3573 -- code future compatible to fix issues before they even generate warnings.
3574 minusWcompatOpts :: [WarningFlag]
3575 minusWcompatOpts
3576 = [ Opt_WarnMissingMonadFailInstances
3577 , Opt_WarnSemigroup
3578 , Opt_WarnNonCanonicalMonoidInstances
3579 ]
3580
3581 enableUnusedBinds :: DynP ()
3582 enableUnusedBinds = mapM_ setWarningFlag unusedBindsFlags
3583
3584 disableUnusedBinds :: DynP ()
3585 disableUnusedBinds = mapM_ unSetWarningFlag unusedBindsFlags
3586
3587 -- Things you get with -Wunused-binds
3588 unusedBindsFlags :: [WarningFlag]
3589 unusedBindsFlags = [ Opt_WarnUnusedTopBinds
3590 , Opt_WarnUnusedLocalBinds
3591 , Opt_WarnUnusedPatternBinds
3592 ]
3593
3594 enableGlasgowExts :: DynP ()
3595 enableGlasgowExts = do setGeneralFlag Opt_PrintExplicitForalls
3596 mapM_ setExtensionFlag glasgowExtsFlags
3597
3598 disableGlasgowExts :: DynP ()
3599 disableGlasgowExts = do unSetGeneralFlag Opt_PrintExplicitForalls
3600 mapM_ unSetExtensionFlag glasgowExtsFlags
3601
3602 glasgowExtsFlags :: [LangExt.Extension]
3603 glasgowExtsFlags = [
3604 LangExt.ConstrainedClassMethods
3605 , LangExt.DeriveDataTypeable
3606 , LangExt.DeriveFoldable
3607 , LangExt.DeriveFunctor
3608 , LangExt.DeriveGeneric
3609 , LangExt.DeriveTraversable
3610 , LangExt.EmptyDataDecls
3611 , LangExt.ExistentialQuantification
3612 , LangExt.ExplicitNamespaces
3613 , LangExt.FlexibleContexts
3614 , LangExt.FlexibleInstances
3615 , LangExt.ForeignFunctionInterface
3616 , LangExt.FunctionalDependencies
3617 , LangExt.GeneralizedNewtypeDeriving
3618 , LangExt.ImplicitParams
3619 , LangExt.KindSignatures
3620 , LangExt.LiberalTypeSynonyms
3621 , LangExt.MagicHash
3622 , LangExt.MultiParamTypeClasses
3623 , LangExt.ParallelListComp
3624 , LangExt.PatternGuards
3625 , LangExt.PostfixOperators
3626 , LangExt.RankNTypes
3627 , LangExt.RecursiveDo
3628 , LangExt.ScopedTypeVariables
3629 , LangExt.StandaloneDeriving
3630 , LangExt.TypeOperators
3631 , LangExt.TypeSynonymInstances
3632 , LangExt.UnboxedTuples
3633 , LangExt.UnicodeSyntax
3634 , LangExt.UnliftedFFITypes ]
3635
3636 foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt
3637
3638 -- | Was the runtime system built with profiling enabled?
3639 rtsIsProfiled :: Bool
3640 rtsIsProfiled = unsafeDupablePerformIO rtsIsProfiledIO /= 0
3641
3642 #ifdef GHCI
3643 -- Consult the RTS to find whether GHC itself has been built with
3644 -- dynamic linking. This can't be statically known at compile-time,
3645 -- because we build both the static and dynamic versions together with
3646 -- -dynamic-too.
3647 foreign import ccall unsafe "rts_isDynamic" rtsIsDynamicIO :: IO CInt
3648
3649 dynamicGhc :: Bool
3650 dynamicGhc = unsafeDupablePerformIO rtsIsDynamicIO /= 0
3651 #else
3652 dynamicGhc :: Bool
3653 dynamicGhc = False
3654 #endif
3655
3656 setWarnSafe :: Bool -> DynP ()
3657 setWarnSafe True = getCurLoc >>= \l -> upd (\d -> d { warnSafeOnLoc = l })
3658 setWarnSafe False = return ()
3659
3660 setWarnUnsafe :: Bool -> DynP ()
3661 setWarnUnsafe True = getCurLoc >>= \l -> upd (\d -> d { warnUnsafeOnLoc = l })
3662 setWarnUnsafe False = return ()
3663
3664 setPackageTrust :: DynP ()
3665 setPackageTrust = do
3666 setGeneralFlag Opt_PackageTrust
3667 l <- getCurLoc
3668 upd $ \d -> d { pkgTrustOnLoc = l }
3669
3670 setGenDeriving :: TurnOnFlag -> DynP ()
3671 setGenDeriving True = getCurLoc >>= \l -> upd (\d -> d { newDerivOnLoc = l })
3672 setGenDeriving False = return ()
3673
3674 setOverlappingInsts :: TurnOnFlag -> DynP ()
3675 setOverlappingInsts False = return ()
3676 setOverlappingInsts True = do
3677 l <- getCurLoc
3678 upd (\d -> d { overlapInstLoc = l })
3679 deprecate "instead use per-instance pragmas OVERLAPPING/OVERLAPPABLE/OVERLAPS"
3680
3681 setIncoherentInsts :: TurnOnFlag -> DynP ()
3682 setIncoherentInsts False = return ()
3683 setIncoherentInsts True = do
3684 l <- getCurLoc
3685 upd (\d -> d { incoherentOnLoc = l })
3686
3687 checkTemplateHaskellOk :: TurnOnFlag -> DynP ()
3688 #ifdef GHCI
3689 checkTemplateHaskellOk _turn_on
3690 = getCurLoc >>= \l -> upd (\d -> d { thOnLoc = l })
3691 #else
3692 -- In stage 1, Template Haskell is simply illegal, except with -M
3693 -- We don't bleat with -M because there's no problem with TH there,
3694 -- and in fact GHC's build system does ghc -M of the DPH libraries
3695 -- with a stage1 compiler
3696 checkTemplateHaskellOk turn_on
3697 | turn_on = do dfs <- liftEwM getCmdLineState
3698 case ghcMode dfs of
3699 MkDepend -> return ()
3700 _ -> addErr msg
3701 | otherwise = return ()
3702 where
3703 msg = "Template Haskell requires GHC with interpreter support\n " ++
3704 "Perhaps you are using a stage-1 compiler?"
3705 #endif
3706
3707 {- **********************************************************************
3708 %* *
3709 DynFlags constructors
3710 %* *
3711 %********************************************************************* -}
3712
3713 type DynP = EwM (CmdLineP DynFlags)
3714
3715 upd :: (DynFlags -> DynFlags) -> DynP ()
3716 upd f = liftEwM (do dflags <- getCmdLineState
3717 putCmdLineState $! f dflags)
3718
3719 updM :: (DynFlags -> DynP DynFlags) -> DynP ()
3720 updM f = do dflags <- liftEwM getCmdLineState
3721 dflags' <- f dflags
3722 liftEwM $ putCmdLineState $! dflags'
3723
3724 --------------- Constructor functions for OptKind -----------------
3725 noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
3726 noArg fn = NoArg (upd fn)
3727
3728 noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
3729 noArgM fn = NoArg (updM fn)
3730
3731 hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
3732 hasArg fn = HasArg (upd . fn)
3733
3734 sepArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
3735 sepArg fn = SepArg (upd . fn)
3736
3737 intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
3738 intSuffix fn = IntSuffix (\n -> upd (fn n))
3739
3740 intSuffixM :: (Int -> DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
3741 intSuffixM fn = IntSuffix (\n -> updM (fn n))
3742
3743 floatSuffix :: (Float -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
3744 floatSuffix fn = FloatSuffix (\n -> upd (fn n))
3745
3746 optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)
3747 -> OptKind (CmdLineP DynFlags)
3748 optIntSuffixM fn = OptIntSuffix (\mi -> updM (fn mi))
3749
3750 setDumpFlag :: DumpFlag -> OptKind (CmdLineP DynFlags)
3751 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
3752
375