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