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