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