Expand $tooldir in ghc --info output
[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 ( expandToolDir, 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, -- ditto
1153 sGhciUsagePath :: FilePath, -- ditto
1154 sToolDir :: Maybe FilePath, -- ditto
1155 sTopDir :: FilePath, -- ditto
1156 sTmpDir :: String, -- no trailing '/'
1157 sProgramName :: String,
1158 sProjectVersion :: String,
1159 -- You shouldn't need to look things up in rawSettings directly.
1160 -- They should have their own fields instead.
1161 sRawSettings :: [(String, String)],
1162 sExtraGccViaCFlags :: [String],
1163 sSystemPackageConfig :: FilePath,
1164 sLdSupportsCompactUnwind :: Bool,
1165 sLdSupportsBuildId :: Bool,
1166 sLdSupportsFilelist :: Bool,
1167 sLdIsGnuLd :: Bool,
1168 sGccSupportsNoPie :: Bool,
1169 -- commands for particular phases
1170 sPgm_L :: String,
1171 sPgm_P :: (String,[Option]),
1172 sPgm_F :: String,
1173 sPgm_c :: (String,[Option]),
1174 sPgm_s :: (String,[Option]),
1175 sPgm_a :: (String,[Option]),
1176 sPgm_l :: (String,[Option]),
1177 sPgm_dll :: (String,[Option]),
1178 sPgm_T :: String,
1179 sPgm_windres :: String,
1180 sPgm_libtool :: String,
1181 sPgm_ar :: String,
1182 sPgm_ranlib :: String,
1183 sPgm_lo :: (String,[Option]), -- LLVM: opt llvm optimiser
1184 sPgm_lc :: (String,[Option]), -- LLVM: llc static compiler
1185 sPgm_lcc :: (String,[Option]), -- LLVM: c compiler
1186 sPgm_i :: String,
1187 -- options for particular phases
1188 sOpt_L :: [String],
1189 sOpt_P :: [String],
1190 sOpt_P_fingerprint :: Fingerprint, -- cached Fingerprint of sOpt_P
1191 -- See Note [Repeated -optP hashing]
1192 sOpt_F :: [String],
1193 sOpt_c :: [String],
1194 sOpt_a :: [String],
1195 sOpt_l :: [String],
1196 sOpt_windres :: [String],
1197 sOpt_lo :: [String], -- LLVM: llvm optimiser
1198 sOpt_lc :: [String], -- LLVM: llc static compiler
1199 sOpt_lcc :: [String], -- LLVM: c compiler
1200 sOpt_i :: [String], -- iserv options
1201
1202 sPlatformConstants :: PlatformConstants
1203 }
1204
1205 targetPlatform :: DynFlags -> Platform
1206 targetPlatform dflags = sTargetPlatform (settings dflags)
1207 programName :: DynFlags -> String
1208 programName dflags = sProgramName (settings dflags)
1209 projectVersion :: DynFlags -> String
1210 projectVersion dflags = sProjectVersion (settings dflags)
1211 ghcUsagePath :: DynFlags -> FilePath
1212 ghcUsagePath dflags = sGhcUsagePath (settings dflags)
1213 ghciUsagePath :: DynFlags -> FilePath
1214 ghciUsagePath dflags = sGhciUsagePath (settings dflags)
1215 toolDir :: DynFlags -> Maybe FilePath
1216 toolDir dflags = sToolDir (settings dflags)
1217 topDir :: DynFlags -> FilePath
1218 topDir dflags = sTopDir (settings dflags)
1219 tmpDir :: DynFlags -> String
1220 tmpDir dflags = sTmpDir (settings dflags)
1221 rawSettings :: DynFlags -> [(String, String)]
1222 rawSettings dflags = sRawSettings (settings dflags)
1223 extraGccViaCFlags :: DynFlags -> [String]
1224 extraGccViaCFlags dflags = sExtraGccViaCFlags (settings dflags)
1225 systemPackageConfig :: DynFlags -> FilePath
1226 systemPackageConfig dflags = sSystemPackageConfig (settings dflags)
1227 pgm_L :: DynFlags -> String
1228 pgm_L dflags = sPgm_L (settings dflags)
1229 pgm_P :: DynFlags -> (String,[Option])
1230 pgm_P dflags = sPgm_P (settings dflags)
1231 pgm_F :: DynFlags -> String
1232 pgm_F dflags = sPgm_F (settings dflags)
1233 pgm_c :: DynFlags -> (String,[Option])
1234 pgm_c dflags = sPgm_c (settings dflags)
1235 pgm_s :: DynFlags -> (String,[Option])
1236 pgm_s dflags = sPgm_s (settings dflags)
1237 pgm_a :: DynFlags -> (String,[Option])
1238 pgm_a dflags = sPgm_a (settings dflags)
1239 pgm_l :: DynFlags -> (String,[Option])
1240 pgm_l dflags = sPgm_l (settings dflags)
1241 pgm_dll :: DynFlags -> (String,[Option])
1242 pgm_dll dflags = sPgm_dll (settings dflags)
1243 pgm_T :: DynFlags -> String
1244 pgm_T dflags = sPgm_T (settings dflags)
1245 pgm_windres :: DynFlags -> String
1246 pgm_windres dflags = sPgm_windres (settings dflags)
1247 pgm_libtool :: DynFlags -> String
1248 pgm_libtool dflags = sPgm_libtool (settings dflags)
1249 pgm_lcc :: DynFlags -> (String,[Option])
1250 pgm_lcc dflags = sPgm_lcc (settings dflags)
1251 pgm_ar :: DynFlags -> String
1252 pgm_ar dflags = sPgm_ar (settings dflags)
1253 pgm_ranlib :: DynFlags -> String
1254 pgm_ranlib dflags = sPgm_ranlib (settings dflags)
1255 pgm_lo :: DynFlags -> (String,[Option])
1256 pgm_lo dflags = sPgm_lo (settings dflags)
1257 pgm_lc :: DynFlags -> (String,[Option])
1258 pgm_lc dflags = sPgm_lc (settings dflags)
1259 pgm_i :: DynFlags -> String
1260 pgm_i dflags = sPgm_i (settings dflags)
1261 opt_L :: DynFlags -> [String]
1262 opt_L dflags = sOpt_L (settings dflags)
1263 opt_P :: DynFlags -> [String]
1264 opt_P dflags = concatMap (wayOptP (targetPlatform dflags)) (ways dflags)
1265 ++ sOpt_P (settings dflags)
1266
1267 -- This function packages everything that's needed to fingerprint opt_P
1268 -- flags. See Note [Repeated -optP hashing].
1269 opt_P_signature :: DynFlags -> ([String], Fingerprint)
1270 opt_P_signature dflags =
1271 ( concatMap (wayOptP (targetPlatform dflags)) (ways dflags)
1272 , sOpt_P_fingerprint (settings dflags))
1273
1274 opt_F :: DynFlags -> [String]
1275 opt_F dflags = sOpt_F (settings dflags)
1276 opt_c :: DynFlags -> [String]
1277 opt_c dflags = concatMap (wayOptc (targetPlatform dflags)) (ways dflags)
1278 ++ sOpt_c (settings dflags)
1279 opt_a :: DynFlags -> [String]
1280 opt_a dflags = sOpt_a (settings dflags)
1281 opt_l :: DynFlags -> [String]
1282 opt_l dflags = concatMap (wayOptl (targetPlatform dflags)) (ways dflags)
1283 ++ sOpt_l (settings dflags)
1284 opt_windres :: DynFlags -> [String]
1285 opt_windres dflags = sOpt_windres (settings dflags)
1286 opt_lcc :: DynFlags -> [String]
1287 opt_lcc dflags = sOpt_lcc (settings dflags)
1288 opt_lo :: DynFlags -> [String]
1289 opt_lo dflags = sOpt_lo (settings dflags)
1290 opt_lc :: DynFlags -> [String]
1291 opt_lc dflags = sOpt_lc (settings dflags)
1292 opt_i :: DynFlags -> [String]
1293 opt_i dflags = sOpt_i (settings dflags)
1294
1295 -- | The directory for this version of ghc in the user's app directory
1296 -- (typically something like @~/.ghc/x86_64-linux-7.6.3@)
1297 --
1298 versionedAppDir :: DynFlags -> MaybeT IO FilePath
1299 versionedAppDir dflags = do
1300 -- Make sure we handle the case the HOME isn't set (see #11678)
1301 appdir <- tryMaybeT $ getAppUserDataDirectory (programName dflags)
1302 return $ appdir </> versionedFilePath dflags
1303
1304 -- | A filepath like @x86_64-linux-7.6.3@ with the platform string to use when
1305 -- constructing platform-version-dependent files that need to co-exist.
1306 --
1307 versionedFilePath :: DynFlags -> FilePath
1308 versionedFilePath dflags = TARGET_ARCH
1309 ++ '-':TARGET_OS
1310 ++ '-':projectVersion dflags
1311 -- NB: This functionality is reimplemented in Cabal, so if you
1312 -- change it, be sure to update Cabal.
1313
1314 -- | The target code type of the compilation (if any).
1315 --
1316 -- Whenever you change the target, also make sure to set 'ghcLink' to
1317 -- something sensible.
1318 --
1319 -- 'HscNothing' can be used to avoid generating any output, however, note
1320 -- that:
1321 --
1322 -- * If a program uses Template Haskell the typechecker may need to run code
1323 -- from an imported module. To facilitate this, code generation is enabled
1324 -- for modules imported by modules that use template haskell.
1325 -- See Note [-fno-code mode].
1326 --
1327 data HscTarget
1328 = HscC -- ^ Generate C code.
1329 | HscAsm -- ^ Generate assembly using the native code generator.
1330 | HscLlvm -- ^ Generate assembly using the llvm code generator.
1331 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
1332 | HscNothing -- ^ Don't generate any code. See notes above.
1333 deriving (Eq, Show)
1334
1335 -- | Will this target result in an object file on the disk?
1336 isObjectTarget :: HscTarget -> Bool
1337 isObjectTarget HscC = True
1338 isObjectTarget HscAsm = True
1339 isObjectTarget HscLlvm = True
1340 isObjectTarget _ = False
1341
1342 -- | Does this target retain *all* top-level bindings for a module,
1343 -- rather than just the exported bindings, in the TypeEnv and compiled
1344 -- code (if any)? In interpreted mode we do this, so that GHCi can
1345 -- call functions inside a module. In HscNothing mode we also do it,
1346 -- so that Haddock can get access to the GlobalRdrEnv for a module
1347 -- after typechecking it.
1348 targetRetainsAllBindings :: HscTarget -> Bool
1349 targetRetainsAllBindings HscInterpreted = True
1350 targetRetainsAllBindings HscNothing = True
1351 targetRetainsAllBindings _ = False
1352
1353 -- | The 'GhcMode' tells us whether we're doing multi-module
1354 -- compilation (controlled via the "GHC" API) or one-shot
1355 -- (single-module) compilation. This makes a difference primarily to
1356 -- the "Finder": in one-shot mode we look for interface files for
1357 -- imported modules, but in multi-module mode we look for source files
1358 -- in order to check whether they need to be recompiled.
1359 data GhcMode
1360 = CompManager -- ^ @\-\-make@, GHCi, etc.
1361 | OneShot -- ^ @ghc -c Foo.hs@
1362 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
1363 deriving Eq
1364
1365 instance Outputable GhcMode where
1366 ppr CompManager = text "CompManager"
1367 ppr OneShot = text "OneShot"
1368 ppr MkDepend = text "MkDepend"
1369
1370 isOneShot :: GhcMode -> Bool
1371 isOneShot OneShot = True
1372 isOneShot _other = False
1373
1374 -- | What to do in the link step, if there is one.
1375 data GhcLink
1376 = NoLink -- ^ Don't link at all
1377 | LinkBinary -- ^ Link object code into a binary
1378 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
1379 -- bytecode and object code).
1380 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
1381 | LinkStaticLib -- ^ Link objects into a static lib
1382 deriving (Eq, Show)
1383
1384 isNoLink :: GhcLink -> Bool
1385 isNoLink NoLink = True
1386 isNoLink _ = False
1387
1388 -- | We accept flags which make packages visible, but how they select
1389 -- the package varies; this data type reflects what selection criterion
1390 -- is used.
1391 data PackageArg =
1392 PackageArg String -- ^ @-package@, by 'PackageName'
1393 | UnitIdArg UnitId -- ^ @-package-id@, by 'UnitId'
1394 deriving (Eq, Show)
1395 instance Outputable PackageArg where
1396 ppr (PackageArg pn) = text "package" <+> text pn
1397 ppr (UnitIdArg uid) = text "unit" <+> ppr uid
1398
1399 -- | Represents the renaming that may be associated with an exposed
1400 -- package, e.g. the @rns@ part of @-package "foo (rns)"@.
1401 --
1402 -- Here are some example parsings of the package flags (where
1403 -- a string literal is punned to be a 'ModuleName':
1404 --
1405 -- * @-package foo@ is @ModRenaming True []@
1406 -- * @-package foo ()@ is @ModRenaming False []@
1407 -- * @-package foo (A)@ is @ModRenaming False [("A", "A")]@
1408 -- * @-package foo (A as B)@ is @ModRenaming False [("A", "B")]@
1409 -- * @-package foo with (A as B)@ is @ModRenaming True [("A", "B")]@
1410 data ModRenaming = ModRenaming {
1411 modRenamingWithImplicit :: Bool, -- ^ Bring all exposed modules into scope?
1412 modRenamings :: [(ModuleName, ModuleName)] -- ^ Bring module @m@ into scope
1413 -- under name @n@.
1414 } deriving (Eq)
1415 instance Outputable ModRenaming where
1416 ppr (ModRenaming b rns) = ppr b <+> parens (ppr rns)
1417
1418 -- | Flags for manipulating the set of non-broken packages.
1419 newtype IgnorePackageFlag = IgnorePackage String -- ^ @-ignore-package@
1420 deriving (Eq)
1421
1422 -- | Flags for manipulating package trust.
1423 data TrustFlag
1424 = TrustPackage String -- ^ @-trust@
1425 | DistrustPackage String -- ^ @-distrust@
1426 deriving (Eq)
1427
1428 -- | Flags for manipulating packages visibility.
1429 data PackageFlag
1430 = ExposePackage String PackageArg ModRenaming -- ^ @-package@, @-package-id@
1431 | HidePackage String -- ^ @-hide-package@
1432 deriving (Eq) -- NB: equality instance is used by packageFlagsChanged
1433
1434 data PackageDBFlag
1435 = PackageDB PkgConfRef
1436 | NoUserPackageDB
1437 | NoGlobalPackageDB
1438 | ClearPackageDBs
1439 deriving (Eq)
1440
1441 packageFlagsChanged :: DynFlags -> DynFlags -> Bool
1442 packageFlagsChanged idflags1 idflags0 =
1443 packageFlags idflags1 /= packageFlags idflags0 ||
1444 ignorePackageFlags idflags1 /= ignorePackageFlags idflags0 ||
1445 pluginPackageFlags idflags1 /= pluginPackageFlags idflags0 ||
1446 trustFlags idflags1 /= trustFlags idflags0 ||
1447 packageDBFlags idflags1 /= packageDBFlags idflags0 ||
1448 packageGFlags idflags1 /= packageGFlags idflags0
1449 where
1450 packageGFlags dflags = map (`gopt` dflags)
1451 [ Opt_HideAllPackages
1452 , Opt_HideAllPluginPackages
1453 , Opt_AutoLinkPackages ]
1454
1455 instance Outputable PackageFlag where
1456 ppr (ExposePackage n arg rn) = text n <> braces (ppr arg <+> ppr rn)
1457 ppr (HidePackage str) = text "-hide-package" <+> text str
1458
1459 defaultHscTarget :: Platform -> HscTarget
1460 defaultHscTarget = defaultObjectTarget
1461
1462 -- | The 'HscTarget' value corresponding to the default way to create
1463 -- object files on the current platform.
1464 defaultObjectTarget :: Platform -> HscTarget
1465 defaultObjectTarget platform
1466 | platformUnregisterised platform = HscC
1467 | cGhcWithNativeCodeGen == "YES" = HscAsm
1468 | otherwise = HscLlvm
1469
1470 tablesNextToCode :: DynFlags -> Bool
1471 tablesNextToCode dflags
1472 = mkTablesNextToCode (platformUnregisterised (targetPlatform dflags))
1473
1474 -- Determines whether we will be compiling
1475 -- info tables that reside just before the entry code, or with an
1476 -- indirection to the entry code. See TABLES_NEXT_TO_CODE in
1477 -- includes/rts/storage/InfoTables.h.
1478 mkTablesNextToCode :: Bool -> Bool
1479 mkTablesNextToCode unregisterised
1480 = not unregisterised && cGhcEnableTablesNextToCode == "YES"
1481
1482 data DynLibLoader
1483 = Deployable
1484 | SystemDependent
1485 deriving Eq
1486
1487 data RtsOptsEnabled
1488 = RtsOptsNone | RtsOptsIgnore | RtsOptsIgnoreAll | RtsOptsSafeOnly
1489 | RtsOptsAll
1490 deriving (Show)
1491
1492 shouldUseColor :: DynFlags -> Bool
1493 shouldUseColor dflags = overrideWith (canUseColor dflags) (useColor dflags)
1494
1495 shouldUseHexWordLiterals :: DynFlags -> Bool
1496 shouldUseHexWordLiterals dflags =
1497 Opt_HexWordLiterals `EnumSet.member` generalFlags dflags
1498
1499 -- | Are we building with @-fPIE@ or @-fPIC@ enabled?
1500 positionIndependent :: DynFlags -> Bool
1501 positionIndependent dflags = gopt Opt_PIC dflags || gopt Opt_PIE dflags
1502
1503 -----------------------------------------------------------------------------
1504 -- Ways
1505
1506 -- The central concept of a "way" is that all objects in a given
1507 -- program must be compiled in the same "way". Certain options change
1508 -- parameters of the virtual machine, eg. profiling adds an extra word
1509 -- to the object header, so profiling objects cannot be linked with
1510 -- non-profiling objects.
1511
1512 -- After parsing the command-line options, we determine which "way" we
1513 -- are building - this might be a combination way, eg. profiling+threaded.
1514
1515 -- We then find the "build-tag" associated with this way, and this
1516 -- becomes the suffix used to find .hi files and libraries used in
1517 -- this compilation.
1518
1519 data Way
1520 = WayCustom String -- for GHC API clients building custom variants
1521 | WayThreaded
1522 | WayDebug
1523 | WayProf
1524 | WayEventLog
1525 | WayDyn
1526 deriving (Eq, Ord, Show)
1527
1528 allowed_combination :: [Way] -> Bool
1529 allowed_combination way = and [ x `allowedWith` y
1530 | x <- way, y <- way, x < y ]
1531 where
1532 -- Note ordering in these tests: the left argument is
1533 -- <= the right argument, according to the Ord instance
1534 -- on Way above.
1535
1536 -- dyn is allowed with everything
1537 _ `allowedWith` WayDyn = True
1538 WayDyn `allowedWith` _ = True
1539
1540 -- debug is allowed with everything
1541 _ `allowedWith` WayDebug = True
1542 WayDebug `allowedWith` _ = True
1543
1544 (WayCustom {}) `allowedWith` _ = True
1545 WayThreaded `allowedWith` WayProf = True
1546 WayThreaded `allowedWith` WayEventLog = True
1547 WayProf `allowedWith` WayEventLog = True
1548 _ `allowedWith` _ = False
1549
1550 mkBuildTag :: [Way] -> String
1551 mkBuildTag ways = concat (intersperse "_" (map wayTag ways))
1552
1553 wayTag :: Way -> String
1554 wayTag (WayCustom xs) = xs
1555 wayTag WayThreaded = "thr"
1556 wayTag WayDebug = "debug"
1557 wayTag WayDyn = "dyn"
1558 wayTag WayProf = "p"
1559 wayTag WayEventLog = "l"
1560
1561 wayRTSOnly :: Way -> Bool
1562 wayRTSOnly (WayCustom {}) = False
1563 wayRTSOnly WayThreaded = True
1564 wayRTSOnly WayDebug = True
1565 wayRTSOnly WayDyn = False
1566 wayRTSOnly WayProf = False
1567 wayRTSOnly WayEventLog = True
1568
1569 wayDesc :: Way -> String
1570 wayDesc (WayCustom xs) = xs
1571 wayDesc WayThreaded = "Threaded"
1572 wayDesc WayDebug = "Debug"
1573 wayDesc WayDyn = "Dynamic"
1574 wayDesc WayProf = "Profiling"
1575 wayDesc WayEventLog = "RTS Event Logging"
1576
1577 -- Turn these flags on when enabling this way
1578 wayGeneralFlags :: Platform -> Way -> [GeneralFlag]
1579 wayGeneralFlags _ (WayCustom {}) = []
1580 wayGeneralFlags _ WayThreaded = []
1581 wayGeneralFlags _ WayDebug = []
1582 wayGeneralFlags _ WayDyn = [Opt_PIC, Opt_ExternalDynamicRefs]
1583 -- We could get away without adding -fPIC when compiling the
1584 -- modules of a program that is to be linked with -dynamic; the
1585 -- program itself does not need to be position-independent, only
1586 -- the libraries need to be. HOWEVER, GHCi links objects into a
1587 -- .so before loading the .so using the system linker. Since only
1588 -- PIC objects can be linked into a .so, we have to compile even
1589 -- modules of the main program with -fPIC when using -dynamic.
1590 wayGeneralFlags _ WayProf = [Opt_SccProfilingOn]
1591 wayGeneralFlags _ WayEventLog = []
1592
1593 -- Turn these flags off when enabling this way
1594 wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]
1595 wayUnsetGeneralFlags _ (WayCustom {}) = []
1596 wayUnsetGeneralFlags _ WayThreaded = []
1597 wayUnsetGeneralFlags _ WayDebug = []
1598 wayUnsetGeneralFlags _ WayDyn = [-- There's no point splitting objects
1599 -- when we're going to be dynamically
1600 -- linking. Plus it breaks compilation
1601 -- on OSX x86.
1602 Opt_SplitObjs,
1603 -- If splitobjs wasn't useful for this,
1604 -- assume sections aren't either.
1605 Opt_SplitSections]
1606 wayUnsetGeneralFlags _ WayProf = []
1607 wayUnsetGeneralFlags _ WayEventLog = []
1608
1609 wayOptc :: Platform -> Way -> [String]
1610 wayOptc _ (WayCustom {}) = []
1611 wayOptc platform WayThreaded = case platformOS platform of
1612 OSOpenBSD -> ["-pthread"]
1613 OSNetBSD -> ["-pthread"]
1614 _ -> []
1615 wayOptc _ WayDebug = []
1616 wayOptc _ WayDyn = []
1617 wayOptc _ WayProf = ["-DPROFILING"]
1618 wayOptc _ WayEventLog = ["-DTRACING"]
1619
1620 wayOptl :: Platform -> Way -> [String]
1621 wayOptl _ (WayCustom {}) = []
1622 wayOptl platform WayThreaded =
1623 case platformOS platform of
1624 OSFreeBSD -> ["-pthread"]
1625 OSOpenBSD -> ["-pthread"]
1626 OSNetBSD -> ["-pthread"]
1627 _ -> []
1628 wayOptl _ WayDebug = []
1629 wayOptl _ WayDyn = []
1630 wayOptl _ WayProf = []
1631 wayOptl _ WayEventLog = []
1632
1633 wayOptP :: Platform -> Way -> [String]
1634 wayOptP _ (WayCustom {}) = []
1635 wayOptP _ WayThreaded = []
1636 wayOptP _ WayDebug = []
1637 wayOptP _ WayDyn = []
1638 wayOptP _ WayProf = ["-DPROFILING"]
1639 wayOptP _ WayEventLog = ["-DTRACING"]
1640
1641 whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m ()
1642 whenGeneratingDynamicToo dflags f = ifGeneratingDynamicToo dflags f (return ())
1643
1644 ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a
1645 ifGeneratingDynamicToo dflags f g = generateDynamicTooConditional dflags f g g
1646
1647 whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m ()
1648 whenCannotGenerateDynamicToo dflags f
1649 = ifCannotGenerateDynamicToo dflags f (return ())
1650
1651 ifCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a
1652 ifCannotGenerateDynamicToo dflags f g
1653 = generateDynamicTooConditional dflags g f g
1654
1655 generateDynamicTooConditional :: MonadIO m
1656 => DynFlags -> m a -> m a -> m a -> m a
1657 generateDynamicTooConditional dflags canGen cannotGen notTryingToGen
1658 = if gopt Opt_BuildDynamicToo dflags
1659 then do let ref = canGenerateDynamicToo dflags
1660 b <- liftIO $ readIORef ref
1661 if b then canGen else cannotGen
1662 else notTryingToGen
1663
1664 dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags
1665 dynamicTooMkDynamicDynFlags dflags0
1666 = let dflags1 = addWay' WayDyn dflags0
1667 dflags2 = dflags1 {
1668 outputFile = dynOutputFile dflags1,
1669 hiSuf = dynHiSuf dflags1,
1670 objectSuf = dynObjectSuf dflags1
1671 }
1672 dflags3 = updateWays dflags2
1673 dflags4 = gopt_unset dflags3 Opt_BuildDynamicToo
1674 in dflags4
1675
1676 -----------------------------------------------------------------------------
1677
1678 -- | Used by 'GHC.runGhc' to partially initialize a new 'DynFlags' value
1679 initDynFlags :: DynFlags -> IO DynFlags
1680 initDynFlags dflags = do
1681 let -- We can't build with dynamic-too on Windows, as labels before
1682 -- the fork point are different depending on whether we are
1683 -- building dynamically or not.
1684 platformCanGenerateDynamicToo
1685 = platformOS (targetPlatform dflags) /= OSMinGW32
1686 refCanGenerateDynamicToo <- newIORef platformCanGenerateDynamicToo
1687 refNextTempSuffix <- newIORef 0
1688 refFilesToClean <- newIORef emptyFilesToClean
1689 refDirsToClean <- newIORef Map.empty
1690 refGeneratedDumps <- newIORef Set.empty
1691 refRtldInfo <- newIORef Nothing
1692 refRtccInfo <- newIORef Nothing
1693 wrapperNum <- newIORef emptyModuleEnv
1694 canUseUnicode <- do let enc = localeEncoding
1695 str = "‘’"
1696 (withCString enc str $ \cstr ->
1697 do str' <- peekCString enc cstr
1698 return (str == str'))
1699 `catchIOError` \_ -> return False
1700 canUseColor <- stderrSupportsAnsiColors
1701 maybeGhcColorsEnv <- lookupEnv "GHC_COLORS"
1702 maybeGhcColoursEnv <- lookupEnv "GHC_COLOURS"
1703 let adjustCols (Just env) = Col.parseScheme env
1704 adjustCols Nothing = id
1705 let (useColor', colScheme') =
1706 (adjustCols maybeGhcColoursEnv . adjustCols maybeGhcColorsEnv)
1707 (useColor dflags, colScheme dflags)
1708 return dflags{
1709 canGenerateDynamicToo = refCanGenerateDynamicToo,
1710 nextTempSuffix = refNextTempSuffix,
1711 filesToClean = refFilesToClean,
1712 dirsToClean = refDirsToClean,
1713 generatedDumps = refGeneratedDumps,
1714 nextWrapperNum = wrapperNum,
1715 useUnicode = canUseUnicode,
1716 useColor = useColor',
1717 canUseColor = canUseColor,
1718 colScheme = colScheme',
1719 rtldInfo = refRtldInfo,
1720 rtccInfo = refRtccInfo
1721 }
1722
1723 -- | The normal 'DynFlags'. Note that they are not suitable for use in this form
1724 -- and must be fully initialized by 'GHC.runGhc' first.
1725 defaultDynFlags :: Settings -> LlvmTargets -> DynFlags
1726 defaultDynFlags mySettings myLlvmTargets =
1727 -- See Note [Updating flag description in the User's Guide]
1728 DynFlags {
1729 ghcMode = CompManager,
1730 ghcLink = LinkBinary,
1731 hscTarget = defaultHscTarget (sTargetPlatform mySettings),
1732 verbosity = 0,
1733 optLevel = 0,
1734 debugLevel = 0,
1735 simplPhases = 2,
1736 maxSimplIterations = 4,
1737 maxPmCheckIterations = 2000000,
1738 ruleCheck = Nothing,
1739 inlineCheck = Nothing,
1740 maxRelevantBinds = Just 6,
1741 maxValidSubstitutions = Just 6,
1742 maxRefSubstitutions = Just 6,
1743 refLevelSubstitutions = Nothing,
1744 maxUncoveredPatterns = 4,
1745 simplTickFactor = 100,
1746 specConstrThreshold = Just 2000,
1747 specConstrCount = Just 3,
1748 specConstrRecursive = 3,
1749 liberateCaseThreshold = Just 2000,
1750 floatLamArgs = Just 0, -- Default: float only if no fvs
1751
1752 historySize = 20,
1753 strictnessBefore = [],
1754
1755 parMakeCount = Just 1,
1756
1757 enableTimeStats = False,
1758 ghcHeapSize = Nothing,
1759
1760 importPaths = ["."],
1761 mainModIs = mAIN,
1762 mainFunIs = Nothing,
1763 reductionDepth = treatZeroAsInf mAX_REDUCTION_DEPTH,
1764 solverIterations = treatZeroAsInf mAX_SOLVER_ITERATIONS,
1765
1766 thisInstalledUnitId = toInstalledUnitId mainUnitId,
1767 thisUnitIdInsts_ = Nothing,
1768 thisComponentId_ = Nothing,
1769
1770 objectDir = Nothing,
1771 dylibInstallName = Nothing,
1772 hiDir = Nothing,
1773 stubDir = Nothing,
1774 dumpDir = Nothing,
1775
1776 objectSuf = phaseInputExt StopLn,
1777 hcSuf = phaseInputExt HCc,
1778 hiSuf = "hi",
1779
1780 canGenerateDynamicToo = panic "defaultDynFlags: No canGenerateDynamicToo",
1781 dynObjectSuf = "dyn_" ++ phaseInputExt StopLn,
1782 dynHiSuf = "dyn_hi",
1783
1784 pluginModNames = [],
1785 pluginModNameOpts = [],
1786 frontendPluginOpts = [],
1787 plugins = [],
1788 hooks = emptyHooks,
1789
1790 outputFile = Nothing,
1791 dynOutputFile = Nothing,
1792 outputHi = Nothing,
1793 dynLibLoader = SystemDependent,
1794 dumpPrefix = Nothing,
1795 dumpPrefixForce = Nothing,
1796 ldInputs = [],
1797 includePaths = IncludeSpecs [] [],
1798 libraryPaths = [],
1799 frameworkPaths = [],
1800 cmdlineFrameworks = [],
1801 rtsOpts = Nothing,
1802 rtsOptsEnabled = RtsOptsSafeOnly,
1803 rtsOptsSuggestions = True,
1804
1805 hpcDir = ".hpc",
1806
1807 packageDBFlags = [],
1808 packageFlags = [],
1809 pluginPackageFlags = [],
1810 ignorePackageFlags = [],
1811 trustFlags = [],
1812 packageEnv = Nothing,
1813 pkgDatabase = Nothing,
1814 -- This gets filled in with GHC.setSessionDynFlags
1815 pkgState = emptyPackageState,
1816 ways = defaultWays mySettings,
1817 buildTag = mkBuildTag (defaultWays mySettings),
1818 splitInfo = Nothing,
1819 settings = mySettings,
1820 llvmTargets = myLlvmTargets,
1821
1822 -- ghc -M values
1823 depMakefile = "Makefile",
1824 depIncludePkgDeps = False,
1825 depExcludeMods = [],
1826 depSuffixes = [],
1827 -- end of ghc -M values
1828 nextTempSuffix = panic "defaultDynFlags: No nextTempSuffix",
1829 filesToClean = panic "defaultDynFlags: No filesToClean",
1830 dirsToClean = panic "defaultDynFlags: No dirsToClean",
1831 generatedDumps = panic "defaultDynFlags: No generatedDumps",
1832 ghcVersionFile = Nothing,
1833 haddockOptions = Nothing,
1834 dumpFlags = EnumSet.empty,
1835 generalFlags = EnumSet.fromList (defaultFlags mySettings),
1836 warningFlags = EnumSet.fromList standardWarnings,
1837 fatalWarningFlags = EnumSet.empty,
1838 ghciScripts = [],
1839 language = Nothing,
1840 safeHaskell = Sf_None,
1841 safeInfer = True,
1842 safeInferred = True,
1843 thOnLoc = noSrcSpan,
1844 newDerivOnLoc = noSrcSpan,
1845 overlapInstLoc = noSrcSpan,
1846 incoherentOnLoc = noSrcSpan,
1847 pkgTrustOnLoc = noSrcSpan,
1848 warnSafeOnLoc = noSrcSpan,
1849 warnUnsafeOnLoc = noSrcSpan,
1850 trustworthyOnLoc = noSrcSpan,
1851 extensions = [],
1852 extensionFlags = flattenExtensionFlags Nothing [],
1853
1854 -- The ufCreationThreshold threshold must be reasonably high to
1855 -- take account of possible discounts.
1856 -- E.g. 450 is not enough in 'fulsom' for Interval.sqr to inline
1857 -- into Csg.calc (The unfolding for sqr never makes it into the
1858 -- interface file.)
1859 ufCreationThreshold = 750,
1860 ufUseThreshold = 60,
1861 ufFunAppDiscount = 60,
1862 -- Be fairly keen to inline a function if that means
1863 -- we'll be able to pick the right method from a dictionary
1864 ufDictDiscount = 30,
1865 ufKeenessFactor = 1.5,
1866 ufDearOp = 40,
1867 ufVeryAggressive = False,
1868
1869 maxWorkerArgs = 10,
1870
1871 ghciHistSize = 50, -- keep a log of length 50 by default
1872
1873 -- Logging
1874
1875 initLogAction = defaultLogOutput,
1876
1877 log_action = defaultLogAction,
1878 log_finaliser = \ _ -> return (),
1879
1880 flushOut = defaultFlushOut,
1881 flushErr = defaultFlushErr,
1882 pprUserLength = 5,
1883 pprCols = 100,
1884 useUnicode = False,
1885 useColor = Auto,
1886 canUseColor = False,
1887 colScheme = Col.defaultScheme,
1888 profAuto = NoProfAuto,
1889 interactivePrint = Nothing,
1890 nextWrapperNum = panic "defaultDynFlags: No nextWrapperNum",
1891 sseVersion = Nothing,
1892 bmiVersion = Nothing,
1893 avx = False,
1894 avx2 = False,
1895 avx512cd = False,
1896 avx512er = False,
1897 avx512f = False,
1898 avx512pf = False,
1899 rtldInfo = panic "defaultDynFlags: no rtldInfo",
1900 rtccInfo = panic "defaultDynFlags: no rtccInfo",
1901
1902 maxInlineAllocSize = 128,
1903 maxInlineMemcpyInsns = 32,
1904 maxInlineMemsetInsns = 32,
1905
1906 initialUnique = 0,
1907 uniqueIncrement = 1,
1908
1909 reverseErrors = False,
1910 maxErrors = Nothing
1911 }
1912
1913 defaultWays :: Settings -> [Way]
1914 defaultWays settings = if pc_DYNAMIC_BY_DEFAULT (sPlatformConstants settings)
1915 then [WayDyn]
1916 else []
1917
1918 interpWays :: [Way]
1919 interpWays
1920 | dynamicGhc = [WayDyn]
1921 | rtsIsProfiled = [WayProf]
1922 | otherwise = []
1923
1924 interpreterProfiled :: DynFlags -> Bool
1925 interpreterProfiled dflags
1926 | gopt Opt_ExternalInterpreter dflags = gopt Opt_SccProfilingOn dflags
1927 | otherwise = rtsIsProfiled
1928
1929 interpreterDynamic :: DynFlags -> Bool
1930 interpreterDynamic dflags
1931 | gopt Opt_ExternalInterpreter dflags = WayDyn `elem` ways dflags
1932 | otherwise = dynamicGhc
1933
1934 --------------------------------------------------------------------------
1935 --
1936 -- Note [JSON Error Messages]
1937 --
1938 -- When the user requests the compiler output to be dumped as json
1939 -- we modify the log_action to collect all the messages in an IORef
1940 -- and then finally in GHC.withCleanupSession the log_finaliser is
1941 -- called which prints out the messages together.
1942 --
1943 -- Before the compiler calls log_action, it has already turned the `ErrMsg`
1944 -- into a formatted message. This means that we lose some possible
1945 -- information to provide to the user but refactoring log_action is quite
1946 -- invasive as it is called in many places. So, for now I left it alone
1947 -- and we can refine its behaviour as users request different output.
1948
1949 type FatalMessager = String -> IO ()
1950
1951 data LogOutput = LogOutput
1952 { getLogAction :: LogAction
1953 , getLogFinaliser :: LogFinaliser
1954 }
1955
1956 defaultLogOutput :: IO (Maybe LogOutput)
1957 defaultLogOutput = return $ Nothing
1958
1959 type LogAction = DynFlags
1960 -> WarnReason
1961 -> Severity
1962 -> SrcSpan
1963 -> PprStyle
1964 -> MsgDoc
1965 -> IO ()
1966
1967 type LogFinaliser = DynFlags -> IO ()
1968
1969 defaultFatalMessager :: FatalMessager
1970 defaultFatalMessager = hPutStrLn stderr
1971
1972
1973 -- See Note [JSON Error Messages]
1974 jsonLogOutput :: IO (Maybe LogOutput)
1975 jsonLogOutput = do
1976 ref <- newIORef []
1977 return . Just $ LogOutput (jsonLogAction ref) (jsonLogFinaliser ref)
1978
1979 jsonLogAction :: IORef [SDoc] -> LogAction
1980 jsonLogAction iref dflags reason severity srcSpan style msg
1981 = do
1982 addMessage . withPprStyle (mkCodeStyle CStyle) . renderJSON $
1983 JSObject [ ( "span", json srcSpan )
1984 , ( "doc" , JSString (showSDoc dflags msg) )
1985 , ( "severity", json severity )
1986 , ( "reason" , json reason )
1987 ]
1988 defaultLogAction dflags reason severity srcSpan style msg
1989 where
1990 addMessage m = modifyIORef iref (m:)
1991
1992
1993 jsonLogFinaliser :: IORef [SDoc] -> DynFlags -> IO ()
1994 jsonLogFinaliser iref dflags = do
1995 msgs <- readIORef iref
1996 let fmt_msgs = brackets $ pprWithCommas (blankLine $$) msgs
1997 output fmt_msgs
1998 where
1999 -- dumpSDoc uses log_action to output the dump
2000 dflags' = dflags { log_action = defaultLogAction }
2001 output doc = dumpSDoc dflags' neverQualify Opt_D_dump_json "" doc
2002
2003
2004 defaultLogAction :: LogAction
2005 defaultLogAction dflags reason severity srcSpan style msg
2006 = case severity of
2007 SevOutput -> printOut msg style
2008 SevDump -> printOut (msg $$ blankLine) style
2009 SevInteractive -> putStrSDoc msg style
2010 SevInfo -> printErrs msg style
2011 SevFatal -> printErrs msg style
2012 SevWarning -> printWarns
2013 SevError -> printWarns
2014 where
2015 printOut = defaultLogActionHPrintDoc dflags stdout
2016 printErrs = defaultLogActionHPrintDoc dflags stderr
2017 putStrSDoc = defaultLogActionHPutStrDoc dflags stdout
2018 -- Pretty print the warning flag, if any (#10752)
2019 message = mkLocMessageAnn flagMsg severity srcSpan msg
2020
2021 printWarns = do
2022 hPutChar stderr '\n'
2023 caretDiagnostic <-
2024 if gopt Opt_DiagnosticsShowCaret dflags
2025 then getCaretDiagnostic severity srcSpan
2026 else pure empty
2027 printErrs (message $+$ caretDiagnostic)
2028 (setStyleColoured True style)
2029 -- careful (#2302): printErrs prints in UTF-8,
2030 -- whereas converting to string first and using
2031 -- hPutStr would just emit the low 8 bits of
2032 -- each unicode char.
2033
2034 flagMsg =
2035 case reason of
2036 NoReason -> Nothing
2037 Reason wflag -> do
2038 spec <- flagSpecOf wflag
2039 return ("-W" ++ flagSpecName spec ++ warnFlagGrp wflag)
2040 ErrReason Nothing ->
2041 return "-Werror"
2042 ErrReason (Just wflag) -> do
2043 spec <- flagSpecOf wflag
2044 return $
2045 "-W" ++ flagSpecName spec ++ warnFlagGrp wflag ++
2046 ", -Werror=" ++ flagSpecName spec
2047
2048 warnFlagGrp flag
2049 | gopt Opt_ShowWarnGroups dflags =
2050 case smallestGroups flag of
2051 [] -> ""
2052 groups -> " (in " ++ intercalate ", " (map ("-W"++) groups) ++ ")"
2053 | otherwise = ""
2054
2055 -- | Like 'defaultLogActionHPutStrDoc' but appends an extra newline.
2056 defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
2057 defaultLogActionHPrintDoc dflags h d sty
2058 = defaultLogActionHPutStrDoc dflags h (d $$ text "") sty
2059
2060 defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
2061 defaultLogActionHPutStrDoc dflags h d sty
2062 -- Don't add a newline at the end, so that successive
2063 -- calls to this log-action can output all on the same line
2064 = printSDoc Pretty.PageMode dflags h sty d
2065
2066 newtype FlushOut = FlushOut (IO ())
2067
2068 defaultFlushOut :: FlushOut
2069 defaultFlushOut = FlushOut $ hFlush stdout
2070
2071 newtype FlushErr = FlushErr (IO ())
2072
2073 defaultFlushErr :: FlushErr
2074 defaultFlushErr = FlushErr $ hFlush stderr
2075
2076 {-
2077 Note [Verbosity levels]
2078 ~~~~~~~~~~~~~~~~~~~~~~~
2079 0 | print errors & warnings only
2080 1 | minimal verbosity: print "compiling M ... done." for each module.
2081 2 | equivalent to -dshow-passes
2082 3 | equivalent to existing "ghc -v"
2083 4 | "ghc -v -ddump-most"
2084 5 | "ghc -v -ddump-all"
2085 -}
2086
2087 data OnOff a = On a
2088 | Off a
2089 deriving (Eq, Show)
2090
2091 instance Outputable a => Outputable (OnOff a) where
2092 ppr (On x) = text "On" <+> ppr x
2093 ppr (Off x) = text "Off" <+> ppr x
2094
2095 -- OnOffs accumulate in reverse order, so we use foldr in order to
2096 -- process them in the right order
2097 flattenExtensionFlags :: Maybe Language -> [OnOff LangExt.Extension] -> EnumSet LangExt.Extension
2098 flattenExtensionFlags ml = foldr f defaultExtensionFlags
2099 where f (On f) flags = EnumSet.insert f flags
2100 f (Off f) flags = EnumSet.delete f flags
2101 defaultExtensionFlags = EnumSet.fromList (languageExtensions ml)
2102
2103 languageExtensions :: Maybe Language -> [LangExt.Extension]
2104
2105 languageExtensions Nothing
2106 -- Nothing => the default case
2107 = LangExt.NondecreasingIndentation -- This has been on by default for some time
2108 : delete LangExt.DatatypeContexts -- The Haskell' committee decided to
2109 -- remove datatype contexts from the
2110 -- language:
2111 -- http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html
2112 (languageExtensions (Just Haskell2010))
2113
2114 -- NB: MonoPatBinds is no longer the default
2115
2116 languageExtensions (Just Haskell98)
2117 = [LangExt.ImplicitPrelude,
2118 LangExt.MonomorphismRestriction,
2119 LangExt.NPlusKPatterns,
2120 LangExt.DatatypeContexts,
2121 LangExt.TraditionalRecordSyntax,
2122 LangExt.NondecreasingIndentation
2123 -- strictly speaking non-standard, but we always had this
2124 -- on implicitly before the option was added in 7.1, and
2125 -- turning it off breaks code, so we're keeping it on for
2126 -- backwards compatibility. Cabal uses -XHaskell98 by
2127 -- default unless you specify another language.
2128 ]
2129
2130 languageExtensions (Just Haskell2010)
2131 = [LangExt.ImplicitPrelude,
2132 LangExt.MonomorphismRestriction,
2133 LangExt.DatatypeContexts,
2134 LangExt.TraditionalRecordSyntax,
2135 LangExt.EmptyDataDecls,
2136 LangExt.ForeignFunctionInterface,
2137 LangExt.PatternGuards,
2138 LangExt.DoAndIfThenElse,
2139 LangExt.RelaxedPolyRec]
2140
2141 hasPprDebug :: DynFlags -> Bool
2142 hasPprDebug = dopt Opt_D_ppr_debug
2143
2144 hasNoDebugOutput :: DynFlags -> Bool
2145 hasNoDebugOutput = dopt Opt_D_no_debug_output
2146
2147 hasNoStateHack :: DynFlags -> Bool
2148 hasNoStateHack = gopt Opt_G_NoStateHack
2149
2150 hasNoOptCoercion :: DynFlags -> Bool
2151 hasNoOptCoercion = gopt Opt_G_NoOptCoercion
2152
2153
2154 -- | Test whether a 'DumpFlag' is set
2155 dopt :: DumpFlag -> DynFlags -> Bool
2156 dopt f dflags = (f `EnumSet.member` dumpFlags dflags)
2157 || (verbosity dflags >= 4 && enableIfVerbose f)
2158 where enableIfVerbose Opt_D_dump_tc_trace = False
2159 enableIfVerbose Opt_D_dump_rn_trace = False
2160 enableIfVerbose Opt_D_dump_cs_trace = False
2161 enableIfVerbose Opt_D_dump_if_trace = False
2162 enableIfVerbose Opt_D_dump_vt_trace = False
2163 enableIfVerbose Opt_D_dump_tc = False
2164 enableIfVerbose Opt_D_dump_rn = False
2165 enableIfVerbose Opt_D_dump_shape = False
2166 enableIfVerbose Opt_D_dump_rn_stats = False
2167 enableIfVerbose Opt_D_dump_hi_diffs = False
2168 enableIfVerbose Opt_D_verbose_core2core = False
2169 enableIfVerbose Opt_D_verbose_stg2stg = False
2170 enableIfVerbose Opt_D_dump_splices = False
2171 enableIfVerbose Opt_D_th_dec_file = False
2172 enableIfVerbose Opt_D_dump_rule_firings = False
2173 enableIfVerbose Opt_D_dump_rule_rewrites = False
2174 enableIfVerbose Opt_D_dump_simpl_trace = False
2175 enableIfVerbose Opt_D_dump_rtti = False
2176 enableIfVerbose Opt_D_dump_inlinings = False
2177 enableIfVerbose Opt_D_dump_core_stats = False
2178 enableIfVerbose Opt_D_dump_asm_stats = False
2179 enableIfVerbose Opt_D_dump_types = False
2180 enableIfVerbose Opt_D_dump_simpl_iterations = False
2181 enableIfVerbose Opt_D_dump_ticked = False
2182 enableIfVerbose Opt_D_dump_view_pattern_commoning = False
2183 enableIfVerbose Opt_D_dump_mod_cycles = False
2184 enableIfVerbose Opt_D_dump_mod_map = False
2185 enableIfVerbose Opt_D_dump_ec_trace = False
2186 enableIfVerbose _ = True
2187
2188 -- | Set a 'DumpFlag'
2189 dopt_set :: DynFlags -> DumpFlag -> DynFlags
2190 dopt_set dfs f = dfs{ dumpFlags = EnumSet.insert f (dumpFlags dfs) }
2191
2192 -- | Unset a 'DumpFlag'
2193 dopt_unset :: DynFlags -> DumpFlag -> DynFlags
2194 dopt_unset dfs f = dfs{ dumpFlags = EnumSet.delete f (dumpFlags dfs) }
2195
2196 -- | Test whether a 'GeneralFlag' is set
2197 gopt :: GeneralFlag -> DynFlags -> Bool
2198 gopt f dflags = f `EnumSet.member` generalFlags dflags
2199
2200 -- | Set a 'GeneralFlag'
2201 gopt_set :: DynFlags -> GeneralFlag -> DynFlags
2202 gopt_set dfs f = dfs{ generalFlags = EnumSet.insert f (generalFlags dfs) }
2203
2204 -- | Unset a 'GeneralFlag'
2205 gopt_unset :: DynFlags -> GeneralFlag -> DynFlags
2206 gopt_unset dfs f = dfs{ generalFlags = EnumSet.delete f (generalFlags dfs) }
2207
2208 -- | Test whether a 'WarningFlag' is set
2209 wopt :: WarningFlag -> DynFlags -> Bool
2210 wopt f dflags = f `EnumSet.member` warningFlags dflags
2211
2212 -- | Set a 'WarningFlag'
2213 wopt_set :: DynFlags -> WarningFlag -> DynFlags
2214 wopt_set dfs f = dfs{ warningFlags = EnumSet.insert f (warningFlags dfs) }
2215
2216 -- | Unset a 'WarningFlag'
2217 wopt_unset :: DynFlags -> WarningFlag -> DynFlags
2218 wopt_unset dfs f = dfs{ warningFlags = EnumSet.delete f (warningFlags dfs) }
2219
2220 -- | Test whether a 'WarningFlag' is set as fatal
2221 wopt_fatal :: WarningFlag -> DynFlags -> Bool
2222 wopt_fatal f dflags = f `EnumSet.member` fatalWarningFlags dflags
2223
2224 -- | Mark a 'WarningFlag' as fatal (do not set the flag)
2225 wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags
2226 wopt_set_fatal dfs f
2227 = dfs { fatalWarningFlags = EnumSet.insert f (fatalWarningFlags dfs) }
2228
2229 -- | Mark a 'WarningFlag' as not fatal
2230 wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags
2231 wopt_unset_fatal dfs f
2232 = dfs { fatalWarningFlags = EnumSet.delete f (fatalWarningFlags dfs) }
2233
2234 -- | Test whether a 'LangExt.Extension' is set
2235 xopt :: LangExt.Extension -> DynFlags -> Bool
2236 xopt f dflags = f `EnumSet.member` extensionFlags dflags
2237
2238 -- | Set a 'LangExt.Extension'
2239 xopt_set :: DynFlags -> LangExt.Extension -> DynFlags
2240 xopt_set dfs f
2241 = let onoffs = On f : extensions dfs
2242 in dfs { extensions = onoffs,
2243 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
2244
2245 -- | Unset a 'LangExt.Extension'
2246 xopt_unset :: DynFlags -> LangExt.Extension -> DynFlags
2247 xopt_unset dfs f
2248 = let onoffs = Off f : extensions dfs
2249 in dfs { extensions = onoffs,
2250 extensionFlags = flattenExtensionFlags (language dfs) onoffs }
2251
2252 lang_set :: DynFlags -> Maybe Language -> DynFlags
2253 lang_set dflags lang =
2254 dflags {
2255 language = lang,
2256 extensionFlags = flattenExtensionFlags lang (extensions dflags)
2257 }
2258
2259 -- | An internal helper to check whether to use unicode syntax for output.
2260 --
2261 -- Note: You should very likely be using 'Outputable.unicodeSyntax' instead
2262 -- of this function.
2263 useUnicodeSyntax :: DynFlags -> Bool
2264 useUnicodeSyntax = gopt Opt_PrintUnicodeSyntax
2265
2266 -- | Set the Haskell language standard to use
2267 setLanguage :: Language -> DynP ()
2268 setLanguage l = upd (`lang_set` Just l)
2269
2270 -- | Some modules have dependencies on others through the DynFlags rather than textual imports
2271 dynFlagDependencies :: DynFlags -> [ModuleName]
2272 dynFlagDependencies = pluginModNames
2273
2274 -- | Is the -fpackage-trust mode on
2275 packageTrustOn :: DynFlags -> Bool
2276 packageTrustOn = gopt Opt_PackageTrust
2277
2278 -- | Is Safe Haskell on in some way (including inference mode)
2279 safeHaskellOn :: DynFlags -> Bool
2280 safeHaskellOn dflags = safeHaskell dflags /= Sf_None || safeInferOn dflags
2281
2282 -- | Is the Safe Haskell safe language in use
2283 safeLanguageOn :: DynFlags -> Bool
2284 safeLanguageOn dflags = safeHaskell dflags == Sf_Safe
2285
2286 -- | Is the Safe Haskell safe inference mode active
2287 safeInferOn :: DynFlags -> Bool
2288 safeInferOn = safeInfer
2289
2290 -- | Test if Safe Imports are on in some form
2291 safeImportsOn :: DynFlags -> Bool
2292 safeImportsOn dflags = safeHaskell dflags == Sf_Unsafe ||
2293 safeHaskell dflags == Sf_Trustworthy ||
2294 safeHaskell dflags == Sf_Safe
2295
2296 -- | Set a 'Safe Haskell' flag
2297 setSafeHaskell :: SafeHaskellMode -> DynP ()
2298 setSafeHaskell s = updM f
2299 where f dfs = do
2300 let sf = safeHaskell dfs
2301 safeM <- combineSafeFlags sf s
2302 case s of
2303 Sf_Safe -> return $ dfs { safeHaskell = safeM, safeInfer = False }
2304 -- leave safe inferrence on in Trustworthy mode so we can warn
2305 -- if it could have been inferred safe.
2306 Sf_Trustworthy -> do
2307 l <- getCurLoc
2308 return $ dfs { safeHaskell = safeM, trustworthyOnLoc = l }
2309 -- leave safe inference on in Unsafe mode as well.
2310 _ -> return $ dfs { safeHaskell = safeM }
2311
2312 -- | Are all direct imports required to be safe for this Safe Haskell mode?
2313 -- Direct imports are when the code explicitly imports a module
2314 safeDirectImpsReq :: DynFlags -> Bool
2315 safeDirectImpsReq d = safeLanguageOn d
2316
2317 -- | Are all implicit imports required to be safe for this Safe Haskell mode?
2318 -- Implicit imports are things in the prelude. e.g System.IO when print is used.
2319 safeImplicitImpsReq :: DynFlags -> Bool
2320 safeImplicitImpsReq d = safeLanguageOn d
2321
2322 -- | Combine two Safe Haskell modes correctly. Used for dealing with multiple flags.
2323 -- This makes Safe Haskell very much a monoid but for now I prefer this as I don't
2324 -- want to export this functionality from the module but do want to export the
2325 -- type constructors.
2326 combineSafeFlags :: SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
2327 combineSafeFlags a b | a == Sf_None = return b
2328 | b == Sf_None = return a
2329 | a == b = return a
2330 | otherwise = addErr errm >> pure a
2331 where errm = "Incompatible Safe Haskell flags! ("
2332 ++ show a ++ ", " ++ show b ++ ")"
2333
2334 -- | A list of unsafe flags under Safe Haskell. Tuple elements are:
2335 -- * name of the flag
2336 -- * function to get srcspan that enabled the flag
2337 -- * function to test if the flag is on
2338 -- * function to turn the flag off
2339 unsafeFlags, unsafeFlagsForInfer
2340 :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]
2341 unsafeFlags = [ ("-XGeneralizedNewtypeDeriving", newDerivOnLoc,
2342 xopt LangExt.GeneralizedNewtypeDeriving,
2343 flip xopt_unset LangExt.GeneralizedNewtypeDeriving)
2344 , ("-XTemplateHaskell", thOnLoc,
2345 xopt LangExt.TemplateHaskell,
2346 flip xopt_unset LangExt.TemplateHaskell)
2347 ]
2348 unsafeFlagsForInfer = unsafeFlags
2349
2350
2351 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
2352 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
2353 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
2354 -> [a] -- ^ Correctly ordered extracted options
2355 getOpts dflags opts = reverse (opts dflags)
2356 -- We add to the options from the front, so we need to reverse the list
2357
2358 -- | Gets the verbosity flag for the current verbosity level. This is fed to
2359 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
2360 getVerbFlags :: DynFlags -> [String]
2361 getVerbFlags dflags
2362 | verbosity dflags >= 4 = ["-v"]
2363 | otherwise = []
2364
2365 setObjectDir, setHiDir, setStubDir, setDumpDir, setOutputDir,
2366 setDynObjectSuf, setDynHiSuf,
2367 setDylibInstallName,
2368 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
2369 setPgmP, addOptl, addOptc, addOptP,
2370 addCmdlineFramework, addHaddockOpts, addGhciScript,
2371 setInteractivePrint
2372 :: String -> DynFlags -> DynFlags
2373 setOutputFile, setDynOutputFile, setOutputHi, setDumpPrefixForce
2374 :: Maybe String -> DynFlags -> DynFlags
2375
2376 setObjectDir f d = d { objectDir = Just f}
2377 setHiDir f d = d { hiDir = Just f}
2378 setStubDir f d = d { stubDir = Just f
2379 , includePaths = addGlobalInclude (includePaths d) [f] }
2380 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
2381 -- \#included from the .hc file when compiling via C (i.e. unregisterised
2382 -- builds).
2383 setDumpDir f d = d { dumpDir = Just f}
2384 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f . setDumpDir f
2385 setDylibInstallName f d = d { dylibInstallName = Just f}
2386
2387 setObjectSuf f d = d { objectSuf = f}
2388 setDynObjectSuf f d = d { dynObjectSuf = f}
2389 setHiSuf f d = d { hiSuf = f}
2390 setDynHiSuf f d = d { dynHiSuf = f}
2391 setHcSuf f d = d { hcSuf = f}
2392
2393 setOutputFile f d = d { outputFile = f}
2394 setDynOutputFile f d = d { dynOutputFile = f}
2395 setOutputHi f d = d { outputHi = f}
2396
2397 setJsonLogAction :: DynFlags -> DynFlags
2398 setJsonLogAction d = d { initLogAction = jsonLogOutput }
2399
2400 thisComponentId :: DynFlags -> ComponentId
2401 thisComponentId dflags =
2402 case thisComponentId_ dflags of
2403 Just cid -> cid
2404 Nothing ->
2405 case thisUnitIdInsts_ dflags of
2406 Just _ ->
2407 throwGhcException $ CmdLineError ("Use of -instantiated-with requires -this-component-id")
2408 Nothing -> ComponentId (unitIdFS (thisPackage dflags))
2409
2410 thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)]
2411 thisUnitIdInsts dflags =
2412 case thisUnitIdInsts_ dflags of
2413 Just insts -> insts
2414 Nothing -> []
2415
2416 thisPackage :: DynFlags -> UnitId
2417 thisPackage dflags =
2418 case thisUnitIdInsts_ dflags of
2419 Nothing -> default_uid
2420 Just insts
2421 | all (\(x,y) -> mkHoleModule x == y) insts
2422 -> newUnitId (thisComponentId dflags) insts
2423 | otherwise
2424 -> default_uid
2425 where
2426 default_uid = DefiniteUnitId (DefUnitId (thisInstalledUnitId dflags))
2427
2428 parseUnitIdInsts :: String -> [(ModuleName, Module)]
2429 parseUnitIdInsts str = case filter ((=="").snd) (readP_to_S parse str) of
2430 [(r, "")] -> r
2431 _ -> throwGhcException $ CmdLineError ("Can't parse -instantiated-with: " ++ str)
2432 where parse = sepBy parseEntry (R.char ',')
2433 parseEntry = do
2434 n <- parseModuleName
2435 _ <- R.char '='
2436 m <- parseModuleId
2437 return (n, m)
2438
2439 setUnitIdInsts :: String -> DynFlags -> DynFlags
2440 setUnitIdInsts s d =
2441 d { thisUnitIdInsts_ = Just (parseUnitIdInsts s) }
2442
2443 setComponentId :: String -> DynFlags -> DynFlags
2444 setComponentId s d =
2445 d { thisComponentId_ = Just (ComponentId (fsLit s)) }
2446
2447 addPluginModuleName :: String -> DynFlags -> DynFlags
2448 addPluginModuleName name d = d { pluginModNames = (mkModuleName name) : (pluginModNames d) }
2449
2450 addPluginModuleNameOption :: String -> DynFlags -> DynFlags
2451 addPluginModuleNameOption optflag d = d { pluginModNameOpts = (mkModuleName m, option) : (pluginModNameOpts d) }
2452 where (m, rest) = break (== ':') optflag
2453 option = case rest of
2454 [] -> "" -- should probably signal an error
2455 (_:plug_opt) -> plug_opt -- ignore the ':' from break
2456
2457 addFrontendPluginOption :: String -> DynFlags -> DynFlags
2458 addFrontendPluginOption s d = d { frontendPluginOpts = s : frontendPluginOpts d }
2459
2460 parseDynLibLoaderMode f d =
2461 case splitAt 8 f of
2462 ("deploy", "") -> d { dynLibLoader = Deployable }
2463 ("sysdep", "") -> d { dynLibLoader = SystemDependent }
2464 _ -> throwGhcException (CmdLineError ("Unknown dynlib loader: " ++ f))
2465
2466 setDumpPrefixForce f d = d { dumpPrefixForce = f}
2467
2468 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
2469 -- Config.hs should really use Option.
2470 setPgmP f = let (pgm:args) = words f in alterSettings (\s -> s { sPgm_P = (pgm, map Option args)})
2471 addOptl f = alterSettings (\s -> s { sOpt_l = f : sOpt_l s})
2472 addOptc f = alterSettings (\s -> s { sOpt_c = f : sOpt_c s})
2473 addOptP f = alterSettings (\s -> s { sOpt_P = f : sOpt_P s
2474 , sOpt_P_fingerprint = fingerprintStrings (f : sOpt_P s)
2475 })
2476 -- See Note [Repeated -optP hashing]
2477 where
2478 fingerprintStrings ss = fingerprintFingerprints $ map fingerprintString ss
2479
2480
2481 setDepMakefile :: FilePath -> DynFlags -> DynFlags
2482 setDepMakefile f d = d { depMakefile = f }
2483
2484 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
2485 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
2486
2487 addDepExcludeMod :: String -> DynFlags -> DynFlags
2488 addDepExcludeMod m d
2489 = d { depExcludeMods = mkModuleName m : depExcludeMods d }
2490
2491 addDepSuffix :: FilePath -> DynFlags -> DynFlags
2492 addDepSuffix s d = d { depSuffixes = s : depSuffixes d }
2493
2494 addCmdlineFramework f d = d { cmdlineFrameworks = f : cmdlineFrameworks d}
2495
2496 addGhcVersionFile :: FilePath -> DynFlags -> DynFlags
2497 addGhcVersionFile f d = d { ghcVersionFile = Just f }
2498
2499 addHaddockOpts f d = d { haddockOptions = Just f}
2500
2501 addGhciScript f d = d { ghciScripts = f : ghciScripts d}
2502
2503 setInteractivePrint f d = d { interactivePrint = Just f}
2504
2505 -- -----------------------------------------------------------------------------
2506 -- Command-line options
2507
2508 -- | When invoking external tools as part of the compilation pipeline, we
2509 -- pass these a sequence of options on the command-line. Rather than
2510 -- just using a list of Strings, we use a type that allows us to distinguish
2511 -- between filepaths and 'other stuff'. The reason for this is that
2512 -- this type gives us a handle on transforming filenames, and filenames only,
2513 -- to whatever format they're expected to be on a particular platform.
2514 data Option
2515 = FileOption -- an entry that _contains_ filename(s) / filepaths.
2516 String -- a non-filepath prefix that shouldn't be
2517 -- transformed (e.g., "/out=")
2518 String -- the filepath/filename portion
2519 | Option String
2520 deriving ( Eq )
2521
2522 showOpt :: Option -> String
2523 showOpt (FileOption pre f) = pre ++ f
2524 showOpt (Option s) = s
2525
2526 -----------------------------------------------------------------------------
2527 -- Setting the optimisation level
2528
2529 updOptLevel :: Int -> DynFlags -> DynFlags
2530 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
2531 updOptLevel n dfs
2532 = dfs2{ optLevel = final_n }
2533 where
2534 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
2535 dfs1 = foldr (flip gopt_unset) dfs remove_gopts
2536 dfs2 = foldr (flip gopt_set) dfs1 extra_gopts
2537
2538 extra_gopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
2539 remove_gopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
2540
2541 {- **********************************************************************
2542 %* *
2543 DynFlags parser
2544 %* *
2545 %********************************************************************* -}
2546
2547 -- -----------------------------------------------------------------------------
2548 -- Parsing the dynamic flags.
2549
2550
2551 -- | Parse dynamic flags from a list of command line arguments. Returns the
2552 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
2553 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
2554 -- flags or missing arguments).
2555 parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String]
2556 -> m (DynFlags, [Located String], [Warn])
2557 -- ^ Updated 'DynFlags', left-over arguments, and
2558 -- list of warnings.
2559 parseDynamicFlagsCmdLine = parseDynamicFlagsFull flagsAll True
2560
2561
2562 -- | Like 'parseDynamicFlagsCmdLine' but does not allow the package flags
2563 -- (-package, -hide-package, -ignore-package, -hide-all-packages, -package-db).
2564 -- Used to parse flags set in a modules pragma.
2565 parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String]
2566 -> m (DynFlags, [Located String], [Warn])
2567 -- ^ Updated 'DynFlags', left-over arguments, and
2568 -- list of warnings.
2569 parseDynamicFilePragma = parseDynamicFlagsFull flagsDynamic False
2570
2571
2572 -- | Parses the dynamically set flags for GHC. This is the most general form of
2573 -- the dynamic flag parser that the other methods simply wrap. It allows
2574 -- saying which flags are valid flags and indicating if we are parsing
2575 -- arguments from the command line or from a file pragma.
2576 parseDynamicFlagsFull :: MonadIO m
2577 => [Flag (CmdLineP DynFlags)] -- ^ valid flags to match against
2578 -> Bool -- ^ are the arguments from the command line?
2579 -> DynFlags -- ^ current dynamic flags
2580 -> [Located String] -- ^ arguments to parse
2581 -> m (DynFlags, [Located String], [Warn])
2582 parseDynamicFlagsFull activeFlags cmdline dflags0 args = do
2583 let ((leftover, errs, warns), dflags1)
2584 = runCmdLine (processArgs activeFlags args) dflags0
2585
2586 -- See Note [Handling errors when parsing commandline flags]
2587 unless (null errs) $ liftIO $ throwGhcExceptionIO $ errorsToGhcException $
2588 map ((showPpr dflags0 . getLoc &&& unLoc) . errMsg) $ errs
2589
2590 -- check for disabled flags in safe haskell
2591 let (dflags2, sh_warns) = safeFlagCheck cmdline dflags1
2592 dflags3 = updateWays dflags2
2593 theWays = ways dflags3
2594
2595 unless (allowed_combination theWays) $ liftIO $
2596 throwGhcExceptionIO (CmdLineError ("combination not supported: " ++
2597 intercalate "/" (map wayDesc theWays)))
2598
2599 let chooseOutput
2600 | isJust (outputFile dflags3) -- Only iff user specified -o ...
2601 , not (isJust (dynOutputFile dflags3)) -- but not -dyno
2602 = return $ dflags3 { dynOutputFile = Just $ dynOut (fromJust $ outputFile dflags3) }
2603 | otherwise
2604 = return dflags3
2605 where
2606 dynOut = flip addExtension (dynObjectSuf dflags3) . dropExtension
2607 dflags4 <- ifGeneratingDynamicToo dflags3 chooseOutput (return dflags3)
2608
2609 let (dflags5, consistency_warnings) = makeDynFlagsConsistent dflags4
2610
2611 -- Set timer stats & heap size
2612 when (enableTimeStats dflags5) $ liftIO enableTimingStats
2613 case (ghcHeapSize dflags5) of
2614 Just x -> liftIO (setHeapSize x)
2615 _ -> return ()
2616
2617 dflags7 <- liftIO $ setLogAction dflags5
2618
2619 liftIO $ setUnsafeGlobalDynFlags dflags7
2620
2621 let warns' = map (Warn Cmd.NoReason) (consistency_warnings ++ sh_warns)
2622
2623 return (dflags7, leftover, warns' ++ warns)
2624
2625 setLogAction :: DynFlags -> IO DynFlags
2626 setLogAction dflags = do
2627 mlogger <- initLogAction dflags
2628 return $
2629 maybe
2630 dflags
2631 (\logger ->
2632 dflags
2633 { log_action = getLogAction logger
2634 , log_finaliser = getLogFinaliser logger
2635 , initLogAction = return $ Nothing -- Don't initialise it twice
2636 })
2637 mlogger
2638
2639 -- | Write an error or warning to the 'LogOutput'.
2640 putLogMsg :: DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle
2641 -> MsgDoc -> IO ()
2642 putLogMsg dflags = log_action dflags dflags
2643
2644 updateWays :: DynFlags -> DynFlags
2645 updateWays dflags
2646 = let theWays = sort $ nub $ ways dflags
2647 in dflags {
2648 ways = theWays,
2649 buildTag = mkBuildTag (filter (not . wayRTSOnly) theWays)
2650 }
2651
2652 -- | Check (and potentially disable) any extensions that aren't allowed
2653 -- in safe mode.
2654 --
2655 -- The bool is to indicate if we are parsing command line flags (false means
2656 -- file pragma). This allows us to generate better warnings.
2657 safeFlagCheck :: Bool -> DynFlags -> (DynFlags, [Located String])
2658 safeFlagCheck _ dflags | safeLanguageOn dflags = (dflagsUnset, warns)
2659 where
2660 -- Handle illegal flags under safe language.
2661 (dflagsUnset, warns) = foldl check_method (dflags, []) unsafeFlags
2662
2663 check_method (df, warns) (str,loc,test,fix)
2664 | test df = (fix df, warns ++ safeFailure (loc df) str)
2665 | otherwise = (df, warns)
2666
2667 safeFailure loc str
2668 = [L loc $ str ++ " is not allowed in Safe Haskell; ignoring "
2669 ++ str]
2670
2671 safeFlagCheck cmdl dflags =
2672 case (safeInferOn dflags) of
2673 True | safeFlags -> (dflags', warn)
2674 True -> (dflags' { safeInferred = False }, warn)
2675 False -> (dflags', warn)
2676
2677 where
2678 -- dynflags and warn for when -fpackage-trust by itself with no safe
2679 -- haskell flag
2680 (dflags', warn)
2681 | safeHaskell dflags == Sf_None && not cmdl && packageTrustOn dflags
2682 = (gopt_unset dflags Opt_PackageTrust, pkgWarnMsg)
2683 | otherwise = (dflags, [])
2684
2685 pkgWarnMsg = [L (pkgTrustOnLoc dflags') $
2686 "-fpackage-trust ignored;" ++
2687 " must be specified with a Safe Haskell flag"]
2688
2689 -- Have we inferred Unsafe? See Note [HscMain . Safe Haskell Inference]
2690 safeFlags = all (\(_,_,t,_) -> not $ t dflags) unsafeFlagsForInfer
2691
2692
2693 {- **********************************************************************
2694 %* *
2695 DynFlags specifications
2696 %* *
2697 %********************************************************************* -}
2698
2699 -- | All dynamic flags option strings without the deprecated ones.
2700 -- These are the user facing strings for enabling and disabling options.
2701 allNonDeprecatedFlags :: [String]
2702 allNonDeprecatedFlags = allFlagsDeps False
2703
2704 -- | All flags with possibility to filter deprecated ones
2705 allFlagsDeps :: Bool -> [String]
2706 allFlagsDeps keepDeprecated = [ '-':flagName flag
2707 | (deprecated, flag) <- flagsAllDeps
2708 , ok (flagOptKind flag)
2709 , keepDeprecated || not (isDeprecated deprecated)]
2710 where ok (PrefixPred _ _) = False
2711 ok _ = True
2712 isDeprecated Deprecated = True
2713 isDeprecated _ = False
2714
2715 {-
2716 - Below we export user facing symbols for GHC dynamic flags for use with the
2717 - GHC API.
2718 -}
2719
2720 -- All dynamic flags present in GHC.
2721 flagsAll :: [Flag (CmdLineP DynFlags)]
2722 flagsAll = map snd flagsAllDeps
2723
2724 -- All dynamic flags present in GHC with deprecation information.
2725 flagsAllDeps :: [(Deprecation, Flag (CmdLineP DynFlags))]
2726 flagsAllDeps = package_flags_deps ++ dynamic_flags_deps
2727
2728
2729 -- All dynamic flags, minus package flags, present in GHC.
2730 flagsDynamic :: [Flag (CmdLineP DynFlags)]
2731 flagsDynamic = map snd dynamic_flags_deps
2732
2733 -- ALl package flags present in GHC.
2734 flagsPackage :: [Flag (CmdLineP DynFlags)]
2735 flagsPackage = map snd package_flags_deps
2736
2737 ----------------Helpers to make flags and keep deprecation information----------
2738
2739 type FlagMaker m = String -> OptKind m -> Flag m
2740 type DynFlagMaker = FlagMaker (CmdLineP DynFlags)
2741 data Deprecation = NotDeprecated | Deprecated deriving (Eq, Ord)
2742
2743 -- Make a non-deprecated flag
2744 make_ord_flag :: DynFlagMaker -> String -> OptKind (CmdLineP DynFlags)
2745 -> (Deprecation, Flag (CmdLineP DynFlags))
2746 make_ord_flag fm name kind = (NotDeprecated, fm name kind)
2747
2748 -- Make a deprecated flag
2749 make_dep_flag :: DynFlagMaker -> String -> OptKind (CmdLineP DynFlags) -> String
2750 -> (Deprecation, Flag (CmdLineP DynFlags))
2751 make_dep_flag fm name kind message = (Deprecated,
2752 fm name $ add_dep_message kind message)
2753
2754 add_dep_message :: OptKind (CmdLineP DynFlags) -> String
2755 -> OptKind (CmdLineP DynFlags)
2756 add_dep_message (NoArg f) message = NoArg $ f >> deprecate message
2757 add_dep_message (HasArg f) message = HasArg $ \s -> f s >> deprecate message
2758 add_dep_message (SepArg f) message = SepArg $ \s -> f s >> deprecate message
2759 add_dep_message (Prefix f) message = Prefix $ \s -> f s >> deprecate message
2760 add_dep_message (OptPrefix f) message =
2761 OptPrefix $ \s -> f s >> deprecate message
2762 add_dep_message (OptIntSuffix f) message =
2763 OptIntSuffix $ \oi -> f oi >> deprecate message
2764 add_dep_message (IntSuffix f) message =
2765 IntSuffix $ \i -> f i >> deprecate message
2766 add_dep_message (FloatSuffix f) message =
2767 FloatSuffix $ \fl -> f fl >> deprecate message
2768 add_dep_message (PassFlag f) message =
2769 PassFlag $ \s -> f s >> deprecate message
2770 add_dep_message (AnySuffix f) message =
2771 AnySuffix $ \s -> f s >> deprecate message
2772 add_dep_message (PrefixPred pred f) message =
2773 PrefixPred pred $ \s -> f s >> deprecate message
2774 add_dep_message (AnySuffixPred pred f) message =
2775 AnySuffixPred pred $ \s -> f s >> deprecate message
2776
2777 ----------------------- The main flags themselves ------------------------------
2778 -- See Note [Updating flag description in the User's Guide]
2779 -- See Note [Supporting CLI completion]
2780 dynamic_flags_deps :: [(Deprecation, Flag (CmdLineP DynFlags))]
2781 dynamic_flags_deps = [
2782 make_dep_flag defFlag "n" (NoArg $ return ())
2783 "The -n flag is deprecated and no longer has any effect"
2784 , make_ord_flag defFlag "cpp" (NoArg (setExtensionFlag LangExt.Cpp))
2785 , make_ord_flag defFlag "F" (NoArg (setGeneralFlag Opt_Pp))
2786 , (Deprecated, defFlag "#include"
2787 (HasArg (\_s ->
2788 deprecate ("-#include and INCLUDE pragmas are " ++
2789 "deprecated: They no longer have any effect"))))
2790 , make_ord_flag defFlag "v" (OptIntSuffix setVerbosity)
2791
2792 , make_ord_flag defGhcFlag "j" (OptIntSuffix
2793 (\n -> case n of
2794 Just n
2795 | n > 0 -> upd (\d -> d { parMakeCount = Just n })
2796 | otherwise -> addErr "Syntax: -j[n] where n > 0"
2797 Nothing -> upd (\d -> d { parMakeCount = Nothing })))
2798 -- When the number of parallel builds
2799 -- is omitted, it is the same
2800 -- as specifing that the number of
2801 -- parallel builds is equal to the
2802 -- result of getNumProcessors
2803 , make_ord_flag defFlag "instantiated-with" (sepArg setUnitIdInsts)
2804 , make_ord_flag defFlag "this-component-id" (sepArg setComponentId)
2805
2806 -- RTS options -------------------------------------------------------------
2807 , make_ord_flag defFlag "H" (HasArg (\s -> upd (\d ->
2808 d { ghcHeapSize = Just $ fromIntegral (decodeSize s)})))
2809
2810 , make_ord_flag defFlag "Rghc-timing" (NoArg (upd (\d ->
2811 d { enableTimeStats = True })))
2812
2813 ------- ways ---------------------------------------------------------------
2814 , make_ord_flag defGhcFlag "prof" (NoArg (addWay WayProf))
2815 , make_ord_flag defGhcFlag "eventlog" (NoArg (addWay WayEventLog))
2816 , make_dep_flag defGhcFlag "smp"
2817 (NoArg $ addWay WayThreaded) "Use -threaded instead"
2818 , make_ord_flag defGhcFlag "debug" (NoArg (addWay WayDebug))
2819 , make_ord_flag defGhcFlag "threaded" (NoArg (addWay WayThreaded))
2820
2821 , make_ord_flag defGhcFlag "ticky"
2822 (NoArg (setGeneralFlag Opt_Ticky >> addWay WayDebug))
2823
2824 -- -ticky enables ticky-ticky code generation, and also implies -debug which
2825 -- is required to get the RTS ticky support.
2826
2827 ----- Linker --------------------------------------------------------
2828 , make_ord_flag defGhcFlag "static" (NoArg removeWayDyn)
2829 , make_ord_flag defGhcFlag "dynamic" (NoArg (addWay WayDyn))
2830 , make_ord_flag defGhcFlag "rdynamic" $ noArg $
2831 #if defined(linux_HOST_OS)
2832 addOptl "-rdynamic"
2833 #elif defined (mingw32_HOST_OS)
2834 addOptl "-Wl,--export-all-symbols"
2835 #else
2836 -- ignored for compat w/ gcc:
2837 id
2838 #endif
2839 , make_ord_flag defGhcFlag "relative-dynlib-paths"
2840 (NoArg (setGeneralFlag Opt_RelativeDynlibPaths))
2841 , make_ord_flag defGhcFlag "pie" (NoArg (setGeneralFlag Opt_PICExecutable))
2842 , make_ord_flag defGhcFlag "no-pie" (NoArg (unSetGeneralFlag Opt_PICExecutable))
2843
2844 ------- Specific phases --------------------------------------------
2845 -- need to appear before -pgmL to be parsed as LLVM flags.
2846 , make_ord_flag defFlag "pgmlo"
2847 (hasArg (\f -> alterSettings (\s -> s { sPgm_lo = (f,[])})))
2848 , make_ord_flag defFlag "pgmlc"
2849 (hasArg (\f -> alterSettings (\s -> s { sPgm_lc = (f,[])})))
2850 , make_ord_flag defFlag "pgmi"
2851 (hasArg (\f -> alterSettings (\s -> s { sPgm_i = f})))
2852 , make_ord_flag defFlag "pgmL"
2853 (hasArg (\f -> alterSettings (\s -> s { sPgm_L = f})))
2854 , make_ord_flag defFlag "pgmP"
2855 (hasArg setPgmP)
2856 , make_ord_flag defFlag "pgmF"
2857 (hasArg (\f -> alterSettings (\s -> s { sPgm_F = f})))
2858 , make_ord_flag defFlag "pgmc"
2859 (hasArg (\f -> alterSettings (\s -> s { sPgm_c = (f,[])})))
2860 , make_ord_flag defFlag "pgms"
2861 (hasArg (\f -> alterSettings (\s -> s { sPgm_s = (f,[])})))
2862 , make_ord_flag defFlag "pgma"
2863 (hasArg (\f -> alterSettings (\s -> s { sPgm_a = (f,[])})))
2864 , make_ord_flag defFlag "pgml"
2865 (hasArg (\f -> alterSettings (\s -> s { sPgm_l = (f,[])})))
2866 , make_ord_flag defFlag "pgmdll"
2867 (hasArg (\f -> alterSettings (\s -> s { sPgm_dll = (f,[])})))
2868 , make_ord_flag defFlag "pgmwindres"
2869 (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f})))
2870 , make_ord_flag defFlag "pgmlibtool"
2871 (hasArg (\f -> alterSettings (\s -> s { sPgm_libtool = f})))
2872 , make_ord_flag defFlag "pgmar"
2873 (hasArg (\f -> alterSettings (\s -> s { sPgm_ar = f})))
2874 , make_ord_flag defFlag "pgmranlib"
2875 (hasArg (\f -> alterSettings (\s -> s { sPgm_ranlib = f})))
2876
2877
2878 -- need to appear before -optl/-opta to be parsed as LLVM flags.
2879 , make_ord_flag defFlag "optlo"
2880 (hasArg (\f -> alterSettings (\s -> s { sOpt_lo = f : sOpt_lo s})))
2881 , make_ord_flag defFlag "optlc"
2882 (hasArg (\f -> alterSettings (\s -> s { sOpt_lc = f : sOpt_lc s})))
2883 , make_ord_flag defFlag "opti"
2884 (hasArg (\f -> alterSettings (\s -> s { sOpt_i = f : sOpt_i s})))
2885 , make_ord_flag defFlag "optL"
2886 (hasArg (\f -> alterSettings (\s -> s { sOpt_L = f : sOpt_L s})))
2887 , make_ord_flag defFlag "optP"
2888 (hasArg addOptP)
2889 , make_ord_flag defFlag "optF"
2890 (hasArg (\f -> alterSettings (\s -> s { sOpt_F = f : sOpt_F s})))
2891 , make_ord_flag defFlag "optc"
2892 (hasArg addOptc)
2893 , make_ord_flag defFlag "opta"
2894 (hasArg (\f -> alterSettings (\s -> s { sOpt_a = f : sOpt_a s})))
2895 , make_ord_flag defFlag "optl"
2896 (hasArg addOptl)
2897 , make_ord_flag defFlag "optwindres"
2898 (hasArg (\f ->
2899 alterSettings (\s -> s { sOpt_windres = f : sOpt_windres s})))
2900
2901 , make_ord_flag defGhcFlag "split-objs"
2902 (NoArg (if can_split
2903 then setGeneralFlag Opt_SplitObjs
2904 else addWarn "ignoring -split-objs"))
2905
2906 , make_ord_flag defGhcFlag "split-sections"
2907 (noArgM (\dflags -> do
2908 if platformHasSubsectionsViaSymbols (targetPlatform dflags)
2909 then do addErr $
2910 "-split-sections is not useful on this platform " ++
2911 "since it always uses subsections via symbols."
2912 return dflags
2913 else return (gopt_set dflags Opt_SplitSections)))
2914
2915 -------- ghc -M -----------------------------------------------------
2916 , make_ord_flag defGhcFlag "dep-suffix" (hasArg addDepSuffix)
2917 , make_ord_flag defGhcFlag "dep-makefile" (hasArg setDepMakefile)
2918 , make_ord_flag defGhcFlag "include-pkg-deps"
2919 (noArg (setDepIncludePkgDeps True))
2920 , make_ord_flag defGhcFlag "exclude-module" (hasArg addDepExcludeMod)
2921
2922 -------- Linking ----------------------------------------------------
2923 , make_ord_flag defGhcFlag "no-link"
2924 (noArg (\d -> d { ghcLink=NoLink }))
2925 , make_ord_flag defGhcFlag "shared"
2926 (noArg (\d -> d { ghcLink=LinkDynLib }))
2927 , make_ord_flag defGhcFlag "staticlib"
2928 (noArg (\d -> d { ghcLink=LinkStaticLib }))
2929 , make_ord_flag defGhcFlag "dynload" (hasArg parseDynLibLoaderMode)
2930 , make_ord_flag defGhcFlag "dylib-install-name" (hasArg setDylibInstallName)
2931
2932 ------- Libraries ---------------------------------------------------
2933 , make_ord_flag defFlag "L" (Prefix addLibraryPath)
2934 , make_ord_flag defFlag "l" (hasArg (addLdInputs . Option . ("-l" ++)))
2935
2936 ------- Frameworks --------------------------------------------------
2937 -- -framework-path should really be -F ...
2938 , make_ord_flag defFlag "framework-path" (HasArg addFrameworkPath)
2939 , make_ord_flag defFlag "framework" (hasArg addCmdlineFramework)
2940
2941 ------- Output Redirection ------------------------------------------
2942 , make_ord_flag defGhcFlag "odir" (hasArg setObjectDir)
2943 , make_ord_flag defGhcFlag "o" (sepArg (setOutputFile . Just))
2944 , make_ord_flag defGhcFlag "dyno"
2945 (sepArg (setDynOutputFile . Just))
2946 , make_ord_flag defGhcFlag "ohi"
2947 (hasArg (setOutputHi . Just ))
2948 , make_ord_flag defGhcFlag "osuf" (hasArg setObjectSuf)
2949 , make_ord_flag defGhcFlag "dynosuf" (hasArg setDynObjectSuf)
2950 , make_ord_flag defGhcFlag "hcsuf" (hasArg setHcSuf)
2951 , make_ord_flag defGhcFlag "hisuf" (hasArg setHiSuf)
2952 , make_ord_flag defGhcFlag "dynhisuf" (hasArg setDynHiSuf)
2953 , make_ord_flag defGhcFlag "hidir" (hasArg setHiDir)
2954 , make_ord_flag defGhcFlag "tmpdir" (hasArg setTmpDir)
2955 , make_ord_flag defGhcFlag "stubdir" (hasArg setStubDir)
2956 , make_ord_flag defGhcFlag "dumpdir" (hasArg setDumpDir)
2957 , make_ord_flag defGhcFlag "outputdir" (hasArg setOutputDir)
2958 , make_ord_flag defGhcFlag "ddump-file-prefix"
2959 (hasArg (setDumpPrefixForce . Just))
2960
2961 , make_ord_flag defGhcFlag "dynamic-too"
2962 (NoArg (setGeneralFlag Opt_BuildDynamicToo))
2963
2964 ------- Keeping temporary files -------------------------------------
2965 -- These can be singular (think ghc -c) or plural (think ghc --make)
2966 , make_ord_flag defGhcFlag "keep-hc-file"
2967 (NoArg (setGeneralFlag Opt_KeepHcFiles))
2968 , make_ord_flag defGhcFlag "keep-hc-files"
2969 (NoArg (setGeneralFlag Opt_KeepHcFiles))
2970 , make_ord_flag defGhcFlag "keep-s-file"
2971 (NoArg (setGeneralFlag Opt_KeepSFiles))
2972 , make_ord_flag defGhcFlag "keep-s-files"
2973 (NoArg (setGeneralFlag Opt_KeepSFiles))
2974 , make_ord_flag defGhcFlag "keep-llvm-file"
2975 (NoArg $ setObjTarget HscLlvm >> setGeneralFlag Opt_KeepLlvmFiles)
2976 , make_ord_flag defGhcFlag "keep-llvm-files"
2977 (NoArg $ setObjTarget HscLlvm >> setGeneralFlag Opt_KeepLlvmFiles)
2978 -- This only makes sense as plural
2979 , make_ord_flag defGhcFlag "keep-tmp-files"
2980 (NoArg (setGeneralFlag Opt_KeepTmpFiles))
2981 , make_ord_flag defGhcFlag "keep-hi-file"
2982 (NoArg (setGeneralFlag Opt_KeepHiFiles))
2983 , make_ord_flag defGhcFlag "no-keep-hi-file"
2984 (NoArg (unSetGeneralFlag Opt_KeepHiFiles))
2985 , make_ord_flag defGhcFlag "keep-hi-files"
2986 (NoArg (setGeneralFlag Opt_KeepHiFiles))
2987 , make_ord_flag defGhcFlag "no-keep-hi-files"
2988 (NoArg (unSetGeneralFlag Opt_KeepHiFiles))
2989 , make_ord_flag defGhcFlag "keep-o-file"
2990 (NoArg (setGeneralFlag Opt_KeepOFiles))
2991 , make_ord_flag defGhcFlag "no-keep-o-file"
2992 (NoArg (unSetGeneralFlag Opt_KeepOFiles))
2993 , make_ord_flag defGhcFlag "keep-o-files"
2994 (NoArg (setGeneralFlag Opt_KeepOFiles))
2995 , make_ord_flag defGhcFlag "no-keep-o-files"
2996 (NoArg (unSetGeneralFlag Opt_KeepOFiles))
2997
2998 ------- Miscellaneous ----------------------------------------------
2999 , make_ord_flag defGhcFlag "no-auto-link-packages"
3000 (NoArg (unSetGeneralFlag Opt_AutoLinkPackages))
3001 , make_ord_flag defGhcFlag "no-hs-main"
3002 (NoArg (setGeneralFlag Opt_NoHsMain))
3003 , make_ord_flag defGhcFlag "fno-state-hack"
3004 (NoArg (setGeneralFlag Opt_G_NoStateHack))
3005 , make_ord_flag defGhcFlag "fno-opt-coercion"
3006 (NoArg (setGeneralFlag Opt_G_NoOptCoercion))
3007 , make_ord_flag defGhcFlag "with-rtsopts"
3008 (HasArg setRtsOpts)
3009 , make_ord_flag defGhcFlag "rtsopts"
3010 (NoArg (setRtsOptsEnabled RtsOptsAll))
3011 , make_ord_flag defGhcFlag "rtsopts=all"
3012 (NoArg (setRtsOptsEnabled RtsOptsAll))
3013 , make_ord_flag defGhcFlag "rtsopts=some"
3014 (NoArg (setRtsOptsEnabled RtsOptsSafeOnly))
3015 , make_ord_flag defGhcFlag "rtsopts=none"
3016 (NoArg (setRtsOptsEnabled RtsOptsNone))
3017 , make_ord_flag defGhcFlag "rtsopts=ignore"
3018 (NoArg (setRtsOptsEnabled RtsOptsIgnore))
3019 , make_ord_flag defGhcFlag "rtsopts=ignoreAll"
3020 (NoArg (setRtsOptsEnabled RtsOptsIgnoreAll))
3021 , make_ord_flag defGhcFlag "no-rtsopts"
3022 (NoArg (setRtsOptsEnabled RtsOptsNone))
3023 , make_ord_flag defGhcFlag "no-rtsopts-suggestions"
3024 (noArg (\d -> d {rtsOptsSuggestions = False}))
3025 , make_ord_flag defGhcFlag "dhex-word-literals"
3026 (NoArg (setGeneralFlag Opt_HexWordLiterals))
3027
3028 , make_ord_flag defGhcFlag "ghcversion-file" (hasArg addGhcVersionFile)
3029 , make_ord_flag defGhcFlag "main-is" (SepArg setMainIs)
3030 , make_ord_flag defGhcFlag "haddock" (NoArg (setGeneralFlag Opt_Haddock))
3031 , make_ord_flag defGhcFlag "haddock-opts" (hasArg addHaddockOpts)
3032 , make_ord_flag defGhcFlag "hpcdir" (SepArg setOptHpcDir)
3033 , make_ord_flag defGhciFlag "ghci-script" (hasArg addGhciScript)
3034 , make_ord_flag defGhciFlag "interactive-print" (hasArg setInteractivePrint)
3035 , make_ord_flag defGhcFlag "ticky-allocd"
3036 (NoArg (setGeneralFlag Opt_Ticky_Allocd))
3037 , make_ord_flag defGhcFlag "ticky-LNE"
3038 (NoArg (setGeneralFlag Opt_Ticky_LNE))
3039 , make_ord_flag defGhcFlag "ticky-dyn-thunk"
3040 (NoArg (setGeneralFlag Opt_Ticky_Dyn_Thunk))
3041 ------- recompilation checker --------------------------------------
3042 , make_dep_flag defGhcFlag "recomp"
3043 (NoArg $ unSetGeneralFlag Opt_ForceRecomp)
3044 "Use -fno-force-recomp instead"
3045 , make_dep_flag defGhcFlag "no-recomp"
3046 (NoArg $ setGeneralFlag Opt_ForceRecomp) "Use -fforce-recomp instead"
3047 , make_ord_flag defFlag "fmax-errors"
3048 (intSuffix (\n d -> d { maxErrors = Just (max 1 n) }))
3049 , make_ord_flag defFlag "fno-max-errors"
3050 (noArg (\d -> d { maxErrors = Nothing }))
3051 , make_ord_flag defFlag "freverse-errors"
3052 (noArg (\d -> d {reverseErrors = True} ))
3053 , make_ord_flag defFlag "fno-reverse-errors"
3054 (noArg (\d -> d {reverseErrors = False} ))
3055
3056 ------ HsCpp opts ---------------------------------------------------
3057 , make_ord_flag defFlag "D" (AnySuffix (upd . addOptP))
3058 , make_ord_flag defFlag "U" (AnySuffix (upd . addOptP))
3059
3060 ------- Include/Import Paths ----------------------------------------
3061 , make_ord_flag defFlag "I" (Prefix addIncludePath)
3062 , make_ord_flag defFlag "i" (OptPrefix addImportPath)
3063
3064 ------ Output style options -----------------------------------------
3065 , make_ord_flag defFlag "dppr-user-length" (intSuffix (\n d ->
3066 d { pprUserLength = n }))
3067 , make_ord_flag defFlag "dppr-cols" (intSuffix (\n d ->
3068 d { pprCols = n }))
3069 , make_ord_flag defFlag "fdiagnostics-color=auto"
3070 (NoArg (upd (\d -> d { useColor = Auto })))
3071 , make_ord_flag defFlag "fdiagnostics-color=always"
3072 (NoArg (upd (\d -> d { useColor = Always })))
3073 , make_ord_flag defFlag "fdiagnostics-color=never"
3074 (NoArg (upd (\d -> d { useColor = Never })))
3075
3076 -- Suppress all that is suppressable in core dumps.
3077 -- Except for uniques, as some simplifier phases introduce new variables that
3078 -- have otherwise identical names.
3079 , make_ord_flag defGhcFlag "dsuppress-all"
3080 (NoArg $ do setGeneralFlag Opt_SuppressCoercions
3081 setGeneralFlag Opt_SuppressVarKinds
3082 setGeneralFlag Opt_SuppressModulePrefixes
3083 setGeneralFlag Opt_SuppressTypeApplications
3084 setGeneralFlag Opt_SuppressIdInfo
3085 setGeneralFlag Opt_SuppressTicks
3086 setGeneralFlag Opt_SuppressStgFreeVars
3087 setGeneralFlag Opt_SuppressTypeSignatures
3088 setGeneralFlag Opt_SuppressTimestamps)
3089
3090 ------ Debugging ----------------------------------------------------
3091 , make_ord_flag defGhcFlag "dstg-stats"
3092 (NoArg (setGeneralFlag Opt_StgStats))
3093
3094 , make_ord_flag defGhcFlag "ddump-cmm"
3095 (setDumpFlag Opt_D_dump_cmm)
3096 , make_ord_flag defGhcFlag "ddump-cmm-from-stg"
3097 (setDumpFlag Opt_D_dump_cmm_from_stg)
3098 , make_ord_flag defGhcFlag "ddump-cmm-raw"
3099 (setDumpFlag Opt_D_dump_cmm_raw)
3100 , make_ord_flag defGhcFlag "ddump-cmm-verbose"
3101 (setDumpFlag Opt_D_dump_cmm_verbose)
3102 , make_ord_flag defGhcFlag "ddump-cmm-cfg"
3103 (setDumpFlag Opt_D_dump_cmm_cfg)
3104 , make_ord_flag defGhcFlag "ddump-cmm-cbe"
3105 (setDumpFlag Opt_D_dump_cmm_cbe)
3106 , make_ord_flag defGhcFlag "ddump-cmm-switch"
3107 (setDumpFlag Opt_D_dump_cmm_switch)
3108 , make_ord_flag defGhcFlag "ddump-cmm-proc"
3109 (setDumpFlag Opt_D_dump_cmm_proc)
3110 , make_ord_flag defGhcFlag "ddump-cmm-sp"
3111 (setDumpFlag Opt_D_dump_cmm_sp)
3112 , make_ord_flag defGhcFlag "ddump-cmm-sink"
3113 (setDumpFlag Opt_D_dump_cmm_sink)
3114 , make_ord_flag defGhcFlag "ddump-cmm-caf"
3115 (setDumpFlag Opt_D_dump_cmm_caf)
3116 , make_ord_flag defGhcFlag "ddump-cmm-procmap"
3117 (setDumpFlag Opt_D_dump_cmm_procmap)
3118 , make_ord_flag defGhcFlag "ddump-cmm-split"
3119 (setDumpFlag Opt_D_dump_cmm_split)
3120 , make_ord_flag defGhcFlag "ddump-cmm-info"
3121 (setDumpFlag Opt_D_dump_cmm_info)
3122 , make_ord_flag defGhcFlag "ddump-cmm-cps"
3123 (setDumpFlag Opt_D_dump_cmm_cps)
3124 , make_ord_flag defGhcFlag "ddump-core-stats"
3125 (setDumpFlag Opt_D_dump_core_stats)
3126 , make_ord_flag defGhcFlag "ddump-asm"
3127 (setDumpFlag Opt_D_dump_asm)
3128 , make_ord_flag defGhcFlag "ddump-asm-native"
3129 (setDumpFlag Opt_D_dump_asm_native)
3130 , make_ord_flag defGhcFlag "ddump-asm-liveness"
3131 (setDumpFlag Opt_D_dump_asm_liveness)
3132 , make_ord_flag defGhcFlag "ddump-asm-regalloc"
3133 (setDumpFlag Opt_D_dump_asm_regalloc)
3134 , make_ord_flag defGhcFlag "ddump-asm-conflicts"
3135 (setDumpFlag Opt_D_dump_asm_conflicts)
3136 , make_ord_flag defGhcFlag "ddump-asm-regalloc-stages"
3137 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
3138 , make_ord_flag defGhcFlag "ddump-asm-stats"
3139 (setDumpFlag Opt_D_dump_asm_stats)
3140 , make_ord_flag defGhcFlag "ddump-asm-expanded"
3141 (setDumpFlag Opt_D_dump_asm_expanded)
3142 , make_ord_flag defGhcFlag "ddump-llvm"
3143 (NoArg $ setObjTarget HscLlvm >> setDumpFlag' Opt_D_dump_llvm)
3144 , make_ord_flag defGhcFlag "ddump-deriv"
3145 (setDumpFlag Opt_D_dump_deriv)
3146 , make_ord_flag defGhcFlag "ddump-ds"
3147 (setDumpFlag Opt_D_dump_ds)
3148 , make_ord_flag defGhcFlag "ddump-ds-preopt"
3149 (setDumpFlag Opt_D_dump_ds_preopt)
3150 , make_ord_flag defGhcFlag "ddump-foreign"
3151 (setDumpFlag Opt_D_dump_foreign)
3152 , make_ord_flag defGhcFlag "ddump-inlinings"
3153 (setDumpFlag Opt_D_dump_inlinings)
3154 , make_ord_flag defGhcFlag "ddump-rule-firings"
3155 (setDumpFlag Opt_D_dump_rule_firings)
3156 , make_ord_flag defGhcFlag "ddump-rule-rewrites"
3157 (setDumpFlag Opt_D_dump_rule_rewrites)
3158 , make_ord_flag defGhcFlag "ddump-simpl-trace"
3159 (setDumpFlag Opt_D_dump_simpl_trace)
3160 , make_ord_flag defGhcFlag "ddump-occur-anal"
3161 (setDumpFlag Opt_D_dump_occur_anal)
3162 , make_ord_flag defGhcFlag "ddump-parsed"
3163 (setDumpFlag Opt_D_dump_parsed)
3164 , make_ord_flag defGhcFlag "ddump-parsed-ast"
3165 (setDumpFlag Opt_D_dump_parsed_ast)
3166 , make_ord_flag defGhcFlag "ddump-rn"
3167 (setDumpFlag Opt_D_dump_rn)
3168 , make_ord_flag defGhcFlag "ddump-rn-ast"
3169 (setDumpFlag Opt_D_dump_rn_ast)
3170 , make_ord_flag defGhcFlag "ddump-simpl"
3171 (setDumpFlag Opt_D_dump_simpl)
3172 , make_ord_flag defGhcFlag "ddump-simpl-iterations"
3173 (setDumpFlag Opt_D_dump_simpl_iterations)
3174 , make_ord_flag defGhcFlag "ddump-spec"
3175 (setDumpFlag Opt_D_dump_spec)
3176 , make_ord_flag defGhcFlag "ddump-prep"
3177 (setDumpFlag Opt_D_dump_prep)
3178 , make_ord_flag defGhcFlag "ddump-stg"
3179 (setDumpFlag Opt_D_dump_stg)
3180 , make_ord_flag defGhcFlag "ddump-call-arity"
3181 (setDumpFlag Opt_D_dump_call_arity)
3182 , make_ord_flag defGhcFlag "ddump-exitify"
3183 (setDumpFlag Opt_D_dump_exitify)
3184 , make_ord_flag defGhcFlag "ddump-stranal"
3185 (setDumpFlag Opt_D_dump_stranal)
3186 , make_ord_flag defGhcFlag "ddump-str-signatures"
3187 (setDumpFlag Opt_D_dump_str_signatures)
3188 , make_ord_flag defGhcFlag "ddump-tc"
3189 (setDumpFlag Opt_D_dump_tc)
3190 , make_ord_flag defGhcFlag "ddump-tc-ast"
3191 (setDumpFlag Opt_D_dump_tc_ast)
3192 , make_ord_flag defGhcFlag "ddump-types"
3193 (setDumpFlag Opt_D_dump_types)
3194 , make_ord_flag defGhcFlag "ddump-rules"
3195 (setDumpFlag Opt_D_dump_rules)
3196 , make_ord_flag defGhcFlag "ddump-cse"
3197 (setDumpFlag Opt_D_dump_cse)
3198 , make_ord_flag defGhcFlag "ddump-worker-wrapper"
3199 (setDumpFlag Opt_D_dump_worker_wrapper)
3200 , make_ord_flag defGhcFlag "ddump-rn-trace"
3201 (setDumpFlag Opt_D_dump_rn_trace)
3202 , make_ord_flag defGhcFlag "ddump-shape"
3203 (setDumpFlag Opt_D_dump_shape)
3204 , make_ord_flag defGhcFlag "ddump-if-trace"
3205 (setDumpFlag Opt_D_dump_if_trace)
3206 , make_ord_flag defGhcFlag "ddump-cs-trace"
3207 (setDumpFlag Opt_D_dump_cs_trace)
3208 , make_ord_flag defGhcFlag "ddump-tc-trace"
3209 (NoArg (do setDumpFlag' Opt_D_dump_tc_trace
3210 setDumpFlag' Opt_D_dump_cs_trace))
3211 , make_ord_flag defGhcFlag "ddump-ec-trace"
3212 (setDumpFlag Opt_D_dump_ec_trace)
3213 , make_ord_flag defGhcFlag "ddump-vt-trace"
3214 (setDumpFlag Opt_D_dump_vt_trace)
3215 , make_ord_flag defGhcFlag "ddump-splices"
3216 (setDumpFlag Opt_D_dump_splices)
3217 , make_ord_flag defGhcFlag "dth-dec-file"
3218 (setDumpFlag Opt_D_th_dec_file)
3219
3220 , make_ord_flag defGhcFlag "ddump-rn-stats"
3221 (setDumpFlag Opt_D_dump_rn_stats)
3222 , make_ord_flag defGhcFlag "ddump-opt-cmm"
3223 (setDumpFlag Opt_D_dump_opt_cmm)
3224 , make_ord_flag defGhcFlag "ddump-simpl-stats"
3225 (setDumpFlag Opt_D_dump_simpl_stats)
3226 , make_ord_flag defGhcFlag "ddump-bcos"
3227 (setDumpFlag Opt_D_dump_BCOs)
3228 , make_ord_flag defGhcFlag "dsource-stats"
3229 (setDumpFlag Opt_D_source_stats)
3230 , make_ord_flag defGhcFlag "dverbose-core2core"
3231 (NoArg $ setVerbosity (Just 2) >> setVerboseCore2Core)
3232 , make_ord_flag defGhcFlag "dverbose-stg2stg"
3233 (setDumpFlag Opt_D_verbose_stg2stg)
3234 , make_ord_flag defGhcFlag "ddump-hi"
3235 (setDumpFlag Opt_D_dump_hi)
3236 , make_ord_flag defGhcFlag "ddump-minimal-imports"
3237 (NoArg (setGeneralFlag Opt_D_dump_minimal_imports))
3238 , make_ord_flag defGhcFlag "ddump-vect"
3239 (setDumpFlag Opt_D_dump_vect)
3240 , make_ord_flag defGhcFlag "ddump-hpc"
3241 (setDumpFlag Opt_D_dump_ticked) -- back compat
3242 , make_ord_flag defGhcFlag "ddump-ticked"
3243 (setDumpFlag Opt_D_dump_ticked)
3244 , make_ord_flag defGhcFlag "ddump-mod-cycles"
3245 (setDumpFlag Opt_D_dump_mod_cycles)
3246 , make_ord_flag defGhcFlag "ddump-mod-map"
3247 (setDumpFlag Opt_D_dump_mod_map)
3248 , make_ord_flag defGhcFlag "ddump-timings"
3249 (setDumpFlag Opt_D_dump_timings)
3250 , make_ord_flag defGhcFlag "ddump-view-pattern-commoning"
3251 (setDumpFlag Opt_D_dump_view_pattern_commoning)
3252 , make_ord_flag defGhcFlag "ddump-to-file"
3253 (NoArg (setGeneralFlag Opt_DumpToFile))
3254 , make_ord_flag defGhcFlag "ddump-hi-diffs"
3255 (setDumpFlag Opt_D_dump_hi_diffs)
3256 , make_ord_flag defGhcFlag "ddump-rtti"
3257 (setDumpFlag Opt_D_dump_rtti)
3258 , make_ord_flag defGhcFlag "dcore-lint"
3259 (NoArg (setGeneralFlag Opt_DoCoreLinting))
3260 , make_ord_flag defGhcFlag "dstg-lint"
3261 (NoArg (setGeneralFlag Opt_DoStgLinting))
3262 , make_ord_flag defGhcFlag "dcmm-lint"
3263 (NoArg (setGeneralFlag Opt_DoCmmLinting))
3264 , make_ord_flag defGhcFlag "dasm-lint"
3265 (NoArg (setGeneralFlag Opt_DoAsmLinting))
3266 , make_ord_flag defGhcFlag "dannot-lint"
3267 (NoArg (setGeneralFlag Opt_DoAnnotationLinting))
3268 , make_ord_flag defGhcFlag "dshow-passes"
3269 (NoArg $ forceRecompile >> (setVerbosity $ Just 2))
3270 , make_ord_flag defGhcFlag "dfaststring-stats"
3271 (NoArg (setGeneralFlag Opt_D_faststring_stats))
3272 , make_ord_flag defGhcFlag "dno-llvm-mangler"
3273 (NoArg (setGeneralFlag Opt_NoLlvmMangler)) -- hidden flag
3274 , make_ord_flag defGhcFlag "fast-llvm"
3275 (NoArg (setGeneralFlag Opt_FastLlvm)) -- hidden flag
3276 , make_ord_flag defGhcFlag "ddump-debug"
3277 (setDumpFlag Opt_D_dump_debug)
3278 , make_ord_flag defGhcFlag "ddump-json"
3279 (noArg (flip dopt_set Opt_D_dump_json . setJsonLogAction ) )
3280 , make_ord_flag defGhcFlag "dppr-debug"
3281 (setDumpFlag Opt_D_ppr_debug)
3282 , make_ord_flag defGhcFlag "ddebug-output"
3283 (noArg (flip dopt_unset Opt_D_no_debug_output))
3284 , make_ord_flag defGhcFlag "dno-debug-output"
3285 (setDumpFlag Opt_D_no_debug_output)
3286
3287 ------ Machine dependent (-m<blah>) stuff ---------------------------
3288
3289 , make_ord_flag defGhcFlag "msse" (noArg (\d ->
3290 d { sseVersion = Just SSE1 }))
3291 , make_ord_flag defGhcFlag "msse2" (noArg (\d ->
3292 d { sseVersion = Just SSE2 }))
3293 , make_ord_flag defGhcFlag "msse3" (noArg (\d ->
3294 d { sseVersion = Just SSE3 }))
3295 , make_ord_flag defGhcFlag "msse4" (noArg (\d ->
3296 d { sseVersion = Just SSE4 }))
3297 , make_ord_flag defGhcFlag "msse4.2" (noArg (\d ->
3298 d { sseVersion = Just SSE42 }))
3299 , make_ord_flag defGhcFlag "mbmi" (noArg (\d ->
3300 d { bmiVersion = Just BMI1 }))
3301 , make_ord_flag defGhcFlag "mbmi2" (noArg (\d ->
3302 d { bmiVersion = Just BMI2 }))
3303 , make_ord_flag defGhcFlag "mavx" (noArg (\d -> d { avx = True }))
3304 , make_ord_flag defGhcFlag "mavx2" (noArg (\d -> d { avx2 = True }))
3305 , make_ord_flag defGhcFlag "mavx512cd" (noArg (\d ->
3306 d { avx512cd = True }))
3307 , make_ord_flag defGhcFlag "mavx512er" (noArg (\d ->
3308 d { avx512er = True }))
3309 , make_ord_flag defGhcFlag "mavx512f" (noArg (\d -> d { avx512f = True }))
3310 , make_ord_flag defGhcFlag "mavx512pf" (noArg (\d ->
3311 d { avx512pf = True }))
3312
3313 ------ Warning opts -------------------------------------------------
3314 , make_ord_flag defFlag "W" (NoArg (mapM_ setWarningFlag minusWOpts))
3315 , make_ord_flag defFlag "Werror"
3316 (NoArg (do { setGeneralFlag Opt_WarnIsError
3317 ; mapM_ setFatalWarningFlag minusWeverythingOpts }))
3318 , make_ord_flag defFlag "Wwarn"
3319 (NoArg (do { unSetGeneralFlag Opt_WarnIsError
3320 ; mapM_ unSetFatalWarningFlag minusWeverythingOpts }))
3321 -- Opt_WarnIsError is still needed to pass -Werror
3322 -- to CPP; see runCpp in SysTools
3323 , make_dep_flag defFlag "Wnot" (NoArg (upd (\d ->
3324 d {warningFlags = EnumSet.empty})))
3325 "Use -w or -Wno-everything instead"
3326 , make_ord_flag defFlag "w" (NoArg (upd (\d ->
3327 d {warningFlags = EnumSet.empty})))
3328
3329 -- New-style uniform warning sets
3330 --
3331 -- Note that -Weverything > -Wall > -Wextra > -Wdefault > -Wno-everything
3332 , make_ord_flag defFlag "Weverything" (NoArg (mapM_
3333 setWarningFlag minusWeverythingOpts))
3334 , make_ord_flag defFlag "Wno-everything"
3335 (NoArg (upd (\d -> d {warningFlags = EnumSet.empty})))
3336
3337 , make_ord_flag defFlag "Wall" (NoArg (mapM_
3338 setWarningFlag minusWallOpts))
3339 , make_ord_flag defFlag "Wno-all" (NoArg (mapM_
3340 unSetWarningFlag minusWallOpts))
3341
3342 , make_ord_flag defFlag "Wextra" (NoArg (mapM_
3343 setWarningFlag minusWOpts))
3344 , make_ord_flag defFlag "Wno-extra" (NoArg (mapM_
3345 unSetWarningFlag minusWOpts))
3346
3347 , make_ord_flag defFlag "Wdefault" (NoArg (mapM_
3348 setWarningFlag standardWarnings))
3349 , make_ord_flag defFlag "Wno-default" (NoArg (mapM_
3350 unSetWarningFlag standardWarnings))
3351
3352 , make_ord_flag defFlag "Wcompat" (NoArg (mapM_
3353 setWarningFlag minusWcompatOpts))
3354 , make_ord_flag defFlag "Wno-compat" (NoArg (mapM_
3355 unSetWarningFlag minusWcompatOpts))
3356
3357 ------ Plugin flags ------------------------------------------------
3358 , make_ord_flag defGhcFlag "fplugin-opt" (hasArg addPluginModuleNameOption)
3359 , make_ord_flag defGhcFlag "fplugin" (hasArg addPluginModuleName)
3360 , make_ord_flag defGhcFlag "ffrontend-opt" (hasArg addFrontendPluginOption)
3361
3362 ------ Optimisation flags ------------------------------------------
3363 , make_dep_flag defGhcFlag "Onot" (noArgM $ setOptLevel 0 )
3364 "Use -O0 instead"
3365 , make_ord_flag defGhcFlag "Odph" (noArgM setDPHOpt)
3366 , make_ord_flag defGhcFlag "O" (optIntSuffixM (\mb_n ->
3367 setOptLevel (mb_n `orElse` 1)))
3368 -- If the number is missing, use 1
3369
3370
3371 , make_ord_flag defFlag "fmax-relevant-binds"
3372 (intSuffix (\n d -> d { maxRelevantBinds = Just n }))
3373 , make_ord_flag defFlag "fno-max-relevant-binds"
3374 (noArg (\d -> d { maxRelevantBinds = Nothing }))
3375 , make_ord_flag defFlag "fmax-valid-substitutions"
3376 (intSuffix (\n d -> d { maxValidSubstitutions = Just n }))
3377 , make_ord_flag defFlag "fno-max-valid-substitutions"
3378 (noArg (\d -> d { maxValidSubstitutions = Nothing }))
3379 , make_ord_flag defFlag "fmax-refinement-substitutions"
3380 (intSuffix (\n d -> d { maxRefSubstitutions = Just n }))
3381 , make_ord_flag defFlag "fno-max-refinement-substitutions"
3382 (noArg (\d -> d { maxRefSubstitutions = Nothing }))
3383 , make_ord_flag defFlag "frefinement-level-substitutions"
3384 (intSuffix (\n d -> d { refLevelSubstitutions = Just n }))
3385 , make_ord_flag defFlag "fno-refinement-level-substitutions"
3386 (noArg (\d -> d { refLevelSubstitutions = Nothing }))
3387 , make_ord_flag defFlag "fmax-uncovered-patterns"
3388 (intSuffix (\n d -> d { maxUncoveredPatterns = n }))
3389 , make_ord_flag defFlag "fsimplifier-phases"
3390 (intSuffix (\n d -> d { simplPhases = n }))
3391 , make_ord_flag defFlag "fmax-simplifier-iterations"
3392 (intSuffix (\n d -> d { maxSimplIterations = n }))
3393 , make_ord_flag defFlag "fmax-pmcheck-iterations"
3394 (intSuffix (\n d -> d{ maxPmCheckIterations = n }))
3395 , make_ord_flag defFlag "fsimpl-tick-factor"
3396 (intSuffix (\n d -> d { simplTickFactor = n }))
3397 , make_ord_flag defFlag "fspec-constr-threshold"
3398 (intSuffix (\n d -> d { specConstrThreshold = Just n }))
3399 , make_ord_flag defFlag "fno-spec-constr-threshold"
3400 (noArg (\d -> d { specConstrThreshold = Nothing }))
3401 , make_ord_flag defFlag "fspec-constr-count"
3402 (intSuffix (\n d -> d { specConstrCount = Just n }))
3403 , make_ord_flag defFlag "fno-spec-constr-count"
3404 (noArg (\d -> d { specConstrCount = Nothing }))
3405 , make_ord_flag defFlag "fspec-constr-recursive"
3406 (intSuffix (\n d -> d { specConstrRecursive = n }))
3407 , make_ord_flag defFlag "fliberate-case-threshold"
3408 (intSuffix (\n d -> d { liberateCaseThreshold = Just n }))
3409 , make_ord_flag defFlag "fno-liberate-case-threshold"
3410 (noArg (\d -> d { liberateCaseThreshold = Nothing }))
3411 , make_ord_flag defFlag "drule-check"
3412 (sepArg (\s d -> d { ruleCheck = Just s }))
3413 , make_ord_flag defFlag "dinline-check"
3414 (sepArg (\s d -> d { inlineCheck = Just s }))
3415 , make_ord_flag defFlag "freduction-depth"
3416 (intSuffix (\n d -> d { reductionDepth = treatZeroAsInf n }))
3417 , make_ord_flag defFlag "fconstraint-solver-iterations"
3418 (intSuffix (\n d -> d { solverIterations = treatZeroAsInf n }))
3419 , (Deprecated, defFlag "fcontext-stack"
3420 (intSuffixM (\n d ->
3421 do { deprecate $ "use -freduction-depth=" ++ show n ++ " instead"
3422 ; return $ d { reductionDepth = treatZeroAsInf n } })))
3423 , (Deprecated, defFlag "ftype-function-depth"
3424 (intSuffixM (\n d ->
3425 do { deprecate $ "use -freduction-depth=" ++ show n ++ " instead"
3426 ; return $ d { reductionDepth = treatZeroAsInf n } })))
3427 , make_ord_flag defFlag "fstrictness-before"
3428 (intSuffix (\n d -> d { strictnessBefore = n : strictnessBefore d }))
3429 , make_ord_flag defFlag "ffloat-lam-args"
3430 (intSuffix (\n d -> d { floatLamArgs = Just n }))
3431 , make_ord_flag defFlag "ffloat-all-lams"
3432 (noArg (\d -> d { floatLamArgs = Nothing }))
3433 , make_ord_flag defFlag "fhistory-size"
3434 (intSuffix (\n d -> d { historySize = n }))
3435 , make_ord_flag defFlag "funfolding-creation-threshold"
3436 (intSuffix (\n d -> d {ufCreationThreshold = n}))
3437 , make_ord_flag defFlag "funfolding-use-threshold"
3438 (intSuffix (\n d -> d {ufUseThreshold = n}))
3439 , make_ord_flag defFlag "funfolding-fun-discount"
3440 (intSuffix (\n d -> d {ufFunAppDiscount = n}))
3441 , make_ord_flag defFlag "funfolding-dict-discount"
3442 (intSuffix (\n d -> d {ufDictDiscount = n}))
3443 , make_ord_flag defFlag "funfolding-keeness-factor"
3444 (floatSuffix (\n d -> d {ufKeenessFactor = n}))
3445 , make_ord_flag defFlag "fmax-worker-args"
3446 (intSuffix (\n d -> d {maxWorkerArgs = n}))
3447 , make_ord_flag defGhciFlag "fghci-hist-size"
3448 (intSuffix (\n d -> d {ghciHistSize = n}))
3449 , make_ord_flag defGhcFlag "fmax-inline-alloc-size"
3450 (intSuffix (\n d -> d { maxInlineAllocSize = n }))
3451 , make_ord_flag defGhcFlag "fmax-inline-memcpy-insns"
3452 (intSuffix (\n d -> d { maxInlineMemcpyInsns = n }))
3453 , make_ord_flag defGhcFlag "fmax-inline-memset-insns"
3454 (intSuffix (\n d -> d { maxInlineMemsetInsns = n }))
3455 , make_ord_flag defGhcFlag "dinitial-unique"
3456 (intSuffix (\n d -> d { initialUnique = n }))
3457 , make_ord_flag defGhcFlag "dunique-increment"
3458 (intSuffix (\n d -> d { uniqueIncrement = n }))
3459
3460 ------ Profiling ----------------------------------------------------
3461
3462 -- OLD profiling flags
3463 , make_dep_flag defGhcFlag "auto-all"
3464 (noArg (\d -> d { profAuto = ProfAutoAll } ))
3465 "Use -fprof-auto instead"
3466 , make_dep_flag defGhcFlag "no-auto-all"
3467 (noArg (\d -> d { profAuto = NoProfAuto } ))
3468 "Use -fno-prof-auto instead"
3469 , make_dep_flag defGhcFlag "auto"
3470 (noArg (\d -> d { profAuto = ProfAutoExports } ))
3471 "Use -fprof-auto-exported instead"
3472 , make_dep_flag defGhcFlag "no-auto"
3473 (noArg (\d -> d { profAuto = NoProfAuto } ))
3474 "Use -fno-prof-auto instead"
3475 , make_dep_flag defGhcFlag "caf-all"
3476 (NoArg (setGeneralFlag Opt_AutoSccsOnIndividualCafs))
3477 "Use -fprof-cafs instead"
3478 , make_dep_flag defGhcFlag "no-caf-all"
3479 (NoArg (unSetGeneralFlag Opt_AutoSccsOnIndividualCafs))
3480 "Use -fno-prof-cafs instead"
3481
3482 -- NEW profiling flags
3483 , make_ord_flag defGhcFlag "fprof-auto"
3484 (noArg (\d -> d { profAuto = ProfAutoAll } ))
3485 , make_ord_flag defGhcFlag "fprof-auto-top"
3486 (noArg (\d -> d { profAuto = ProfAutoTop } ))
3487 , make_ord_flag defGhcFlag "fprof-auto-exported"
3488 (noArg (\d -> d { profAuto = ProfAutoExports } ))
3489 , make_ord_flag defGhcFlag "fprof-auto-calls"
3490 (noArg (\d -> d { profAuto = ProfAutoCalls } ))
3491 , make_ord_flag defGhcFlag "fno-prof-auto"
3492 (noArg (\d -> d { profAuto = NoProfAuto } ))
3493
3494 ------ Compiler flags -----------------------------------------------
3495
3496 , make_ord_flag defGhcFlag "fasm" (NoArg (setObjTarget HscAsm))
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 "fvia-C" (NoArg
3501 (deprecate $ "The -fvia-C flag does nothing; " ++
3502 "it will be removed in a future GHC release"))
3503 , make_ord_flag defGhcFlag "fllvm" (NoArg (setObjTarget HscLlvm))
3504
3505 , make_ord_flag defFlag "fno-code" (NoArg ((upd $ \d ->
3506 d { ghcLink=NoLink }) >> setTarget HscNothing))
3507 , make_ord_flag defFlag "fbyte-code" (NoArg (setTarget HscInterpreted))
3508 , make_ord_flag defFlag "fobject-code" (NoArg (setTargetWithPlatform
3509 defaultHscTarget))
3510 , make_dep_flag defFlag "fglasgow-exts"
3511 (NoArg enableGlasgowExts) "Use individual extensions instead"
3512 , make_dep_flag defFlag "fno-glasgow-exts"
3513 (NoArg disableGlasgowExts) "Use individual extensions instead"
3514 , make_ord_flag defFlag "Wunused-binds" (NoArg enableUnusedBinds)
3515 , make_ord_flag defFlag "Wno-unused-binds" (NoArg disableUnusedBinds)
3516 , make_ord_flag defHiddenFlag "fwarn-unused-binds" (NoArg enableUnusedBinds)
3517 , make_ord_flag defHiddenFlag "fno-warn-unused-binds" (NoArg
3518 disableUnusedBinds)
3519
3520 ------ Safe Haskell flags -------------------------------------------
3521 , make_ord_flag defFlag "fpackage-trust" (NoArg setPackageTrust)
3522 , make_ord_flag defFlag "fno-safe-infer" (noArg (\d ->
3523 d { safeInfer = False }))
3524 , make_ord_flag defGhcFlag "fPIC" (NoArg (setGeneralFlag Opt_PIC))
3525 , make_ord_flag defGhcFlag "fno-PIC" (NoArg (unSetGeneralFlag Opt_PIC))
3526 , make_ord_flag defGhcFlag "fPIE" (NoArg (setGeneralFlag Opt_PIC))
3527 , make_ord_flag defGhcFlag "fno-PIE" (NoArg (unSetGeneralFlag Opt_PIC))
3528
3529 ------ Debugging flags ----------------------------------------------
3530 , make_ord_flag defGhcFlag "g" (OptIntSuffix setDebugLevel)
3531 ]
3532 ++ map (mkFlag turnOn "" setGeneralFlag ) negatableFlagsDeps
3533 ++ map (mkFlag turnOff "no-" unSetGeneralFlag ) negatableFlagsDeps
3534 ++ map (mkFlag turnOn "d" setGeneralFlag ) dFlagsDeps
3535 ++ map (mkFlag turnOff "dno-" unSetGeneralFlag ) dFlagsDeps
3536 ++ map (mkFlag turnOn "f" setGeneralFlag ) fFlagsDeps
3537 ++ map (mkFlag turnOff "fno-" unSetGeneralFlag ) fFlagsDeps
3538 ++ map (mkFlag turnOn "W" setWarningFlag ) wWarningFlagsDeps
3539 ++ map (mkFlag turnOff "Wno-" unSetWarningFlag ) wWarningFlagsDeps
3540 ++ map (mkFlag turnOn "Werror=" (\flag -> do {
3541 ; setWarningFlag flag
3542 ; setFatalWarningFlag flag }))
3543 wWarningFlagsDeps
3544 ++ map (mkFlag turnOn "Wwarn=" unSetFatalWarningFlag )
3545 wWarningFlagsDeps
3546 ++ map (mkFlag turnOn "Wno-error=" unSetFatalWarningFlag )
3547 wWarningFlagsDeps
3548 ++ map (mkFlag turnOn "fwarn-" setWarningFlag . hideFlag)
3549 wWarningFlagsDeps
3550 ++ map (mkFlag turnOff "fno-warn-" unSetWarningFlag . hideFlag)
3551 wWarningFlagsDeps
3552 ++ [ (NotDeprecated, unrecognisedWarning "W"),
3553 (Deprecated, unrecognisedWarning "fwarn-"),
3554 (Deprecated, unrecognisedWarning "fno-warn-") ]
3555 ++ map (mkFlag turnOn "f" setExtensionFlag ) fLangFlagsDeps
3556 ++ map (mkFlag turnOff "fno-" unSetExtensionFlag) fLangFlagsDeps
3557 ++ map (mkFlag turnOn "X" setExtensionFlag ) xFlagsDeps
3558 ++ map (mkFlag turnOff "XNo" unSetExtensionFlag) xFlagsDeps
3559 ++ map (mkFlag turnOn "X" setLanguage ) languageFlagsDeps
3560 ++ map (mkFlag turnOn "X" setSafeHaskell ) safeHaskellFlagsDeps
3561 ++ [ make_dep_flag defFlag "XGenerics"
3562 (NoArg $ return ())
3563 ("it does nothing; look into -XDefaultSignatures " ++
3564 "and -XDeriveGeneric for generic programming support.")
3565 , make_dep_flag defFlag "XNoGenerics"
3566 (NoArg $ return ())
3567 ("it does nothing; look into -XDefaultSignatures and " ++
3568 "-XDeriveGeneric for generic programming support.") ]
3569
3570 -- | This is where we handle unrecognised warning flags. We only issue a warning
3571 -- if -Wunrecognised-warning-flags is set. See Trac #11429 for context.
3572 unrecognisedWarning :: String -> Flag (CmdLineP DynFlags)
3573 unrecognisedWarning prefix = defHiddenFlag prefix (Prefix action)
3574 where
3575 action :: String -> EwM (CmdLineP DynFlags) ()
3576 action flag = do
3577 f <- wopt Opt_WarnUnrecognisedWarningFlags <$> liftEwM getCmdLineState
3578 when f $ addFlagWarn Cmd.ReasonUnrecognisedFlag $
3579 "unrecognised warning flag: -" ++ prefix ++ flag
3580
3581 -- See Note [Supporting CLI completion]
3582 package_flags_deps :: [(Deprecation, Flag (CmdLineP DynFlags))]
3583 package_flags_deps = [
3584 ------- Packages ----------------------------------------------------
3585 make_ord_flag defFlag "package-db"
3586 (HasArg (addPkgConfRef . PkgConfFile))
3587 , make_ord_flag defFlag "clear-package-db" (NoArg clearPkgConf)
3588 , make_ord_flag defFlag "no-global-package-db" (NoArg removeGlobalPkgConf)
3589 , make_ord_flag defFlag "no-user-package-db" (NoArg removeUserPkgConf)
3590 , make_ord_flag defFlag "global-package-db"
3591 (NoArg (addPkgConfRef GlobalPkgConf))
3592 , make_ord_flag defFlag "user-package-db"
3593 (NoArg (addPkgConfRef UserPkgConf))
3594 -- backwards compat with GHC<=7.4 :
3595 , make_dep_flag defFlag "package-conf"
3596 (HasArg $ addPkgConfRef . PkgConfFile) "Use -package-db instead"
3597 , make_dep_flag defFlag "no-user-package-conf"
3598 (NoArg removeUserPkgConf) "Use -no-user-package-db instead"
3599 , make_ord_flag defGhcFlag "package-name" (HasArg $ \name -> do
3600 upd (setUnitId name))
3601 -- TODO: Since we JUST deprecated
3602 -- -this-package-key, let's keep this
3603 -- undeprecated for another cycle.
3604 -- Deprecate this eventually.
3605 -- deprecate "Use -this-unit-id instead")
3606 , make_dep_flag defGhcFlag "this-package-key" (HasArg $ upd . setUnitId)
3607 "Use -this-unit-id instead"
3608 , make_ord_flag defGhcFlag "this-unit-id" (hasArg setUnitId)
3609 , make_ord_flag defFlag "package" (HasArg exposePackage)
3610 , make_ord_flag defFlag "plugin-package-id" (HasArg exposePluginPackageId)
3611 , make_ord_flag defFlag "plugin-package" (HasArg exposePluginPackage)
3612 , make_ord_flag defFlag "package-id" (HasArg exposePackageId)
3613 , make_ord_flag defFlag "hide-package" (HasArg hidePackage)
3614 , make_ord_flag defFlag "hide-all-packages"
3615 (NoArg (setGeneralFlag Opt_HideAllPackages))
3616 , make_ord_flag defFlag "hide-all-plugin-packages"
3617 (NoArg (setGeneralFlag Opt_HideAllPluginPackages))
3618 , make_ord_flag defFlag "package-env" (HasArg setPackageEnv)
3619 , make_ord_flag defFlag "ignore-package" (HasArg ignorePackage)
3620 , make_dep_flag defFlag "syslib" (HasArg exposePackage) "Use -package instead"
3621 , make_ord_flag defFlag "distrust-all-packages"
3622 (NoArg (setGeneralFlag Opt_DistrustAllPackages))
3623 , make_ord_flag defFlag "trust" (HasArg trustPackage)
3624 , make_ord_flag defFlag "distrust" (HasArg distrustPackage)
3625 ]
3626 where
3627 setPackageEnv env = upd $ \s -> s { packageEnv = Just env }
3628
3629 -- | Make a list of flags for shell completion.
3630 -- Filter all available flags into two groups, for interactive GHC vs all other.
3631 flagsForCompletion :: Bool -> [String]
3632 flagsForCompletion isInteractive
3633 = [ '-':flagName flag
3634 | flag <- flagsAll
3635 , modeFilter (flagGhcMode flag)
3636 ]
3637 where
3638 modeFilter AllModes = True
3639 modeFilter OnlyGhci = isInteractive
3640 modeFilter OnlyGhc = not isInteractive
3641 modeFilter HiddenFlag = False
3642
3643 type TurnOnFlag = Bool -- True <=> we are turning the flag on
3644 -- False <=> we are turning the flag off
3645 turnOn :: TurnOnFlag; turnOn = True
3646 turnOff :: TurnOnFlag; turnOff = False
3647
3648 data FlagSpec flag
3649 = FlagSpec
3650 { flagSpecName :: String -- ^ Flag in string form
3651 , flagSpecFlag :: flag -- ^ Flag in internal form
3652 , flagSpecAction :: (TurnOnFlag -> DynP ())
3653 -- ^ Extra action to run when the flag is found
3654 -- Typically, emit a warning or error
3655 , flagSpecGhcMode :: GhcFlagMode
3656 -- ^ In which ghc mode the flag has effect
3657 }
3658
3659 -- | Define a new flag.
3660 flagSpec :: String -> flag -> (Deprecation, FlagSpec flag)
3661 flagSpec name flag = flagSpec' name flag nop
3662
3663 -- | Define a new flag with an effect.
3664 flagSpec' :: String -> flag -> (TurnOnFlag -> DynP ())
3665 -> (Deprecation, FlagSpec flag)
3666 flagSpec' name flag act = (NotDeprecated, FlagSpec name flag act AllModes)
3667
3668 -- | Define a new deprecated flag with an effect.
3669 depFlagSpecOp :: String -> flag -> (TurnOnFlag -> DynP ()) -> String
3670 -> (Deprecation, FlagSpec flag)
3671 depFlagSpecOp name flag act dep =
3672 (Deprecated, snd (flagSpec' name flag (\f -> act f >> deprecate dep)))
3673
3674 -- | Define a new deprecated flag.
3675 depFlagSpec :: String -> flag -> String
3676 -> (Deprecation, FlagSpec flag)
3677 depFlagSpec name flag dep = depFlagSpecOp name flag nop dep
3678
3679 -- | Define a new deprecated flag with an effect where the deprecation message
3680 -- depends on the flag value
3681 depFlagSpecOp' :: String
3682 -> flag
3683 -> (TurnOnFlag -> DynP ())
3684 -> (TurnOnFlag -> String)
3685 -> (Deprecation, FlagSpec flag)
3686 depFlagSpecOp' name flag act dep =
3687 (Deprecated, FlagSpec name flag (\f -> act f >> (deprecate $ dep f))
3688 AllModes)
3689
3690 -- | Define a new deprecated flag where the deprecation message
3691 -- depends on the flag value
3692 depFlagSpec' :: String
3693 -> flag
3694 -> (TurnOnFlag -> String)
3695 -> (Deprecation, FlagSpec flag)
3696 depFlagSpec' name flag dep = depFlagSpecOp' name flag nop dep
3697
3698
3699 -- | Define a new deprecated flag where the deprecation message
3700 -- is shown depending on the flag value
3701 depFlagSpecCond :: String
3702 -> flag
3703 -> (TurnOnFlag -> Bool)
3704 -> String
3705 -> (Deprecation, FlagSpec flag)
3706 depFlagSpecCond name flag cond dep =
3707 (Deprecated, FlagSpec name flag (\f -> when (cond f) $ deprecate dep)
3708 AllModes)
3709
3710 -- | Define a new flag for GHCi.
3711 flagGhciSpec :: String -> flag -> (Deprecation, FlagSpec flag)
3712 flagGhciSpec name flag = flagGhciSpec' name flag nop
3713
3714 -- | Define a new flag for GHCi with an effect.
3715 flagGhciSpec' :: String -> flag -> (TurnOnFlag -> DynP ())
3716 -> (Deprecation, FlagSpec flag)
3717 flagGhciSpec' name flag act = (NotDeprecated, FlagSpec name flag act OnlyGhci)
3718
3719 -- | Define a new flag invisible to CLI completion.
3720 flagHiddenSpec :: String -> flag -> (Deprecation, FlagSpec flag)
3721 flagHiddenSpec name flag = flagHiddenSpec' name flag nop
3722
3723 -- | Define a new flag invisible to CLI completion with an effect.
3724 flagHiddenSpec' :: String -> flag -> (TurnOnFlag -> DynP ())
3725 -> (Deprecation, FlagSpec flag)
3726 flagHiddenSpec' name flag act = (NotDeprecated, FlagSpec name flag act
3727 HiddenFlag)
3728
3729 -- | Hide a 'FlagSpec' from being displayed in @--show-options@.
3730 --
3731 -- This is for example useful for flags that are obsolete, but should not
3732 -- (yet) be deprecated for compatibility reasons.
3733 hideFlag :: (Deprecation, FlagSpec a) -> (Deprecation, FlagSpec a)
3734 hideFlag (dep, fs) = (dep, fs { flagSpecGhcMode = HiddenFlag })
3735
3736 mkFlag :: TurnOnFlag -- ^ True <=> it should be turned on
3737 -> String -- ^ The flag prefix
3738 -> (flag -> DynP ()) -- ^ What to do when the flag is found
3739 -> (Deprecation, FlagSpec flag) -- ^ Specification of
3740 -- this particular flag
3741 -> (Deprecation, Flag (CmdLineP DynFlags))
3742 mkFlag turn_on flagPrefix f (dep, (FlagSpec name flag extra_action mode))
3743 = (dep,
3744 Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on)) mode)
3745
3746 deprecatedForExtension :: String -> TurnOnFlag -> String
3747 deprecatedForExtension lang turn_on
3748 = "use -X" ++ flag ++
3749 " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead"
3750 where
3751 flag | turn_on = lang
3752 | otherwise = "No" ++ lang
3753
3754 useInstead :: String -> String -> TurnOnFlag -> String
3755 useInstead prefix flag turn_on
3756 = "Use " ++ prefix ++ no ++ flag ++ " instead"
3757 where
3758 no = if turn_on then "" else "no-"
3759
3760 nop :: TurnOnFlag -> DynP ()
3761 nop _ = return ()
3762
3763 -- | Find the 'FlagSpec' for a 'WarningFlag'.
3764 flagSpecOf :: WarningFlag -> Maybe (FlagSpec WarningFlag)
3765 flagSpecOf flag = listToMaybe $ filter check wWarningFlags
3766 where
3767 check fs = flagSpecFlag fs == flag
3768
3769 -- | These @-W\<blah\>@ flags can all be reversed with @-Wno-\<blah\>@
3770 wWarningFlags :: [FlagSpec WarningFlag]
3771 wWarningFlags = map snd (sortBy (comparing fst) wWarningFlagsDeps)
3772
3773 wWarningFlagsDeps :: [(Deprecation, FlagSpec WarningFlag)]
3774 wWarningFlagsDeps = [
3775 -- See Note [Updating flag description in the User's Guide]
3776 -- See Note [Supporting CLI completion]
3777 -- Please keep the list of flags below sorted alphabetically
3778 flagSpec "alternative-layout-rule-transitional"
3779 Opt_WarnAlternativeLayoutRuleTransitional,
3780 depFlagSpec "amp" Opt_WarnAMP
3781 "it has no effect",
3782 depFlagSpec "auto-orphans" Opt_WarnAutoOrphans
3783 "it has no effect",
3784 flagSpec "cpp-undef" Opt_WarnCPPUndef,
3785 flagSpec "unbanged-strict-patterns" Opt_WarnUnbangedStrictPatterns,
3786 flagSpec "deferred-type-errors" Opt_WarnDeferredTypeErrors,
3787 flagSpec "deferred-out-of-scope-variables"
3788 Opt_WarnDeferredOutOfScopeVariables,
3789 flagSpec "deprecations" Opt_WarnWarningsDeprecations,
3790 flagSpec "deprecated-flags" Opt_WarnDeprecatedFlags,
3791 flagSpec "deriving-typeable" Opt_WarnDerivingTypeable,
3792 flagSpec "dodgy-exports" Opt_WarnDodgyExports,
3793 flagSpec "dodgy-foreign-imports" Opt_WarnDodgyForeignImports,
3794 flagSpec "dodgy-imports" Opt_WarnDodgyImports,
3795 flagSpec "empty-enumerations" Opt_WarnEmptyEnumerations,
3796 depFlagSpec "duplicate-constraints" Opt_WarnDuplicateConstraints
3797 "it is subsumed by -Wredundant-constraints",
3798 flagSpec "redundant-constraints" Opt_WarnRedundantConstraints,
3799 flagSpec "duplicate-exports" Opt_WarnDuplicateExports,
3800 flagSpec "hi-shadowing" Opt_WarnHiShadows,
3801 flagSpec "implicit-prelude" Opt_WarnImplicitPrelude,
3802 flagSpec "incomplete-patterns" Opt_WarnIncompletePatterns,
3803 flagSpec "incomplete-record-updates" Opt_WarnIncompletePatternsRecUpd,
3804 flagSpec "incomplete-uni-patterns" Opt_WarnIncompleteUniPatterns,
3805 flagSpec "inline-rule-shadowing" Opt_WarnInlineRuleShadowing,
3806 flagSpec "identities" Opt_WarnIdentities,
3807 flagSpec "missing-fields" Opt_WarnMissingFields,
3808 flagSpec "missing-import-lists" Opt_WarnMissingImportList,
3809 flagSpec "missing-export-lists" Opt_WarnMissingExportList,
3810 depFlagSpec "missing-local-sigs" Opt_WarnMissingLocalSignatures
3811 "it is replaced by -Wmissing-local-signatures",
3812 flagSpec "missing-local-signatures" Opt_WarnMissingLocalSignatures,
3813 flagSpec "missing-methods" Opt_WarnMissingMethods,
3814 flagSpec "missing-monadfail-instances" Opt_WarnMissingMonadFailInstances,
3815 flagSpec "semigroup" Opt_WarnSemigroup,
3816 flagSpec "missing-signatures" Opt_WarnMissingSignatures,
3817 depFlagSpec "missing-exported-sigs" Opt_WarnMissingExportedSignatures
3818 "it is replaced by -Wmissing-exported-signatures",
3819 flagSpec "missing-exported-signatures" Opt_WarnMissingExportedSignatures,
3820 flagSpec "monomorphism-restriction" Opt_WarnMonomorphism,
3821 flagSpec "name-shadowing" Opt_WarnNameShadowing,
3822 flagSpec "noncanonical-monad-instances"
3823 Opt_WarnNonCanonicalMonadInstances,
3824 flagSpec "noncanonical-monadfail-instances"
3825 Opt_WarnNonCanonicalMonadFailInstances,
3826 flagSpec "noncanonical-monoid-instances"
3827 Opt_WarnNonCanonicalMonoidInstances,
3828 flagSpec "orphans" Opt_WarnOrphans,
3829 flagSpec "overflowed-literals" Opt_WarnOverflowedLiterals,
3830 flagSpec "overlapping-patterns" Opt_WarnOverlappingPatterns,
3831 flagSpec "missed-specialisations" Opt_WarnMissedSpecs,
3832