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