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