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