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