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