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