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