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