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