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