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