Add an unshare stg2stg phase
[ghc.git] / compiler / main / DynFlags.hs
1 -------------------------------------------------------------------------------
2 --
3 -- | Dynamic flags
4 --
5 -- Most flags are dynamic flags, which means they can change from compilation
6 -- to compilation using @OPTIONS_GHC@ pragmas, and in a multi-session GHC each
7 -- session can be using different dynamic flags. Dynamic flags can also be set
8 -- at the prompt in GHCi.
9 --
10 -- (c) The University of Glasgow 2005
11 --
12 -------------------------------------------------------------------------------
13
14 {-# OPTIONS_GHC -fno-warn-missing-fields #-}
15 -- So that tracingSettings works properly
16
17 module DynFlags (
18         -- * Dynamic flags and associated configuration types
19         DynFlag(..),
20         WarningFlag(..),
21         ExtensionFlag(..),
22         Language(..),
23         FatalMessager, LogAction, FlushOut(..), FlushErr(..),
24         ProfAuto(..),
25         glasgowExtsFlags,
26         dopt,
27         dopt_set,
28         dopt_unset,
29         wopt,
30         wopt_set,
31         wopt_unset,
32         xopt,
33         xopt_set,
34         xopt_unset,
35         lang_set,
36         DynFlags(..),
37         HasDynFlags(..), ContainsDynFlags(..),
38         RtsOptsEnabled(..),
39         HscTarget(..), isObjectTarget, defaultObjectTarget,
40         targetRetainsAllBindings,
41         GhcMode(..), isOneShot,
42         GhcLink(..), isNoLink,
43         PackageFlag(..),
44         PkgConfRef(..),
45         Option(..), showOpt,
46         DynLibLoader(..),
47         fFlags, fWarningFlags, fLangFlags, xFlags,
48         wayNames, dynFlagDependencies,
49         tablesNextToCode, mkTablesNextToCode,
50
51         printOutputForUser, printInfoForUser,
52
53         -- ** Safe Haskell
54         SafeHaskellMode(..),
55         safeHaskellOn, safeImportsOn, safeLanguageOn, safeInferOn,
56         packageTrustOn,
57         safeDirectImpsReq, safeImplicitImpsReq,
58         unsafeFlags,
59
60         -- ** System tool settings and locations
61         Settings(..),
62         targetPlatform,
63         ghcUsagePath, ghciUsagePath, topDir, tmpDir, rawSettings,
64         extraGccViaCFlags, systemPackageConfig,
65         pgm_L, pgm_P, pgm_F, pgm_c, pgm_s, pgm_a, pgm_l, pgm_dll, pgm_T,
66         pgm_sysman, pgm_windres, pgm_lo, pgm_lc,
67         opt_L, opt_P, opt_F, opt_c, opt_a, opt_l,
68         opt_windres, opt_lo, opt_lc,
69
70
71         -- ** Manipulating DynFlags
72         defaultDynFlags,                -- Settings -> DynFlags
73         initDynFlags,                   -- DynFlags -> IO DynFlags
74         defaultFatalMessager,
75         defaultLogAction,
76         defaultLogActionHPrintDoc,
77         defaultFlushOut,
78         defaultFlushErr,
79
80         getOpts,                        -- DynFlags -> (DynFlags -> [a]) -> [a]
81         getVerbFlags,
82         updOptLevel,
83         setTmpDir,
84         setPackageName,
85         doingTickyProfiling,
86
87         -- ** Parsing DynFlags
88         parseDynamicFlagsCmdLine,
89         parseDynamicFilePragma,
90         parseDynamicFlagsFull,
91
92         -- ** Available DynFlags
93         allFlags,
94         flagsAll,
95         flagsDynamic,
96         flagsPackage,
97
98         supportedLanguagesAndExtensions,
99
100         -- ** DynFlag C compiler options
101         picCCOpts, picPOpts,
102
103         -- * Configuration of the stg-to-stg passes
104         StgToDo(..),
105         getStgToDo,
106
107         -- * Compiler configuration suitable for display to the user
108         compilerInfo,
109
110 #ifdef GHCI
111 -- Only in stage 2 can we be sure that the RTS
112 -- exposes the appropriate runtime boolean
113         rtsIsProfiled,
114 #endif
115         -- ** Only for use in the tracing functions in Outputable
116         tracingDynFlags,
117   ) where
118
119 #include "HsVersions.h"
120
121 import Platform
122 import Module
123 import PackageConfig
124 import PrelNames        ( mAIN )
125 import StaticFlags
126 import {-# SOURCE #-} Packages (PackageState)
127 import DriverPhases     ( Phase(..), phaseInputExt )
128 import Config
129 import CmdLineParser
130 import Constants        ( mAX_CONTEXT_REDUCTION_DEPTH )
131 import Panic
132 import Util
133 import Maybes           ( orElse )
134 import qualified Pretty
135 import SrcLoc
136 import FastString
137 import Outputable
138 #ifdef GHCI
139 import Foreign.C        ( CInt(..) )
140 #endif
141 import {-# SOURCE #-} ErrUtils ( Severity(..), MsgDoc, mkLocMessage )
142
143 #ifdef GHCI
144 import System.IO.Unsafe ( unsafePerformIO )
145 #endif
146 import Data.IORef
147 import Control.Monad    ( when )
148
149 import Data.Char
150 import Data.List
151 import Data.Map (Map)
152 import qualified Data.Map as Map
153 import Data.Set (Set)
154 import qualified Data.Set as Set
155 import System.FilePath
156 import System.IO
157
158 import Data.IntSet (IntSet)
159 import qualified Data.IntSet as IntSet
160
161 -- -----------------------------------------------------------------------------
162 -- DynFlags
163
164 -- | Enumerates the simple on-or-off dynamic flags
165 data DynFlag
166
167    -- debugging flags
168    = Opt_D_dump_cmm
169    | Opt_D_dump_raw_cmm
170    | Opt_D_dump_cmmz
171    -- All of the cmmz subflags (there are a lot!)  Automatically
172    -- enabled if you run -ddump-cmmz
173    | Opt_D_dump_cmmz_cfg
174    | Opt_D_dump_cmmz_cbe
175    | Opt_D_dump_cmmz_proc
176    | Opt_D_dump_cmmz_spills
177    | Opt_D_dump_cmmz_rewrite
178    | Opt_D_dump_cmmz_dead
179    | Opt_D_dump_cmmz_stub
180    | Opt_D_dump_cmmz_sp
181    | Opt_D_dump_cmmz_procmap
182    | Opt_D_dump_cmmz_split
183    | Opt_D_dump_cmmz_lower
184    | Opt_D_dump_cmmz_info
185    | Opt_D_dump_cmmz_cafs
186    -- end cmmz subflags
187    | Opt_D_dump_cps_cmm
188    | Opt_D_dump_cvt_cmm
189    | Opt_D_dump_asm
190    | Opt_D_dump_asm_native
191    | Opt_D_dump_asm_liveness
192    | Opt_D_dump_asm_coalesce
193    | Opt_D_dump_asm_regalloc
194    | Opt_D_dump_asm_regalloc_stages
195    | Opt_D_dump_asm_conflicts
196    | Opt_D_dump_asm_stats
197    | Opt_D_dump_asm_expanded
198    | Opt_D_dump_llvm
199    | Opt_D_dump_core_stats
200    | Opt_D_dump_cpranal
201    | Opt_D_dump_deriv
202    | Opt_D_dump_ds
203    | Opt_D_dump_flatC
204    | Opt_D_dump_foreign
205    | Opt_D_dump_inlinings
206    | Opt_D_dump_rule_firings
207    | Opt_D_dump_rule_rewrites
208    | Opt_D_dump_occur_anal
209    | Opt_D_dump_parsed
210    | Opt_D_dump_rn
211    | Opt_D_dump_core_pipeline -- TODO FIXME: dump after simplifier stats
212    | Opt_D_dump_simpl
213    | Opt_D_dump_simpl_iterations
214    | Opt_D_dump_simpl_phases
215    | Opt_D_dump_spec
216    | Opt_D_dump_prep
217    | Opt_D_dump_stg
218    | Opt_D_dump_stranal
219    | Opt_D_dump_tc
220    | Opt_D_dump_types
221    | Opt_D_dump_rules
222    | Opt_D_dump_cse
223    | Opt_D_dump_worker_wrapper
224    | Opt_D_dump_rn_trace
225    | Opt_D_dump_rn_stats
226    | Opt_D_dump_opt_cmm
227    | Opt_D_dump_simpl_stats
228    | Opt_D_dump_cs_trace -- Constraint solver in type checker
229    | Opt_D_dump_tc_trace
230    | Opt_D_dump_if_trace
231    | Opt_D_dump_vt_trace
232    | Opt_D_dump_splices
233    | Opt_D_dump_BCOs
234    | Opt_D_dump_vect
235    | Opt_D_dump_avoid_vect
236    | Opt_D_dump_ticked
237    | Opt_D_dump_rtti
238    | Opt_D_source_stats
239    | Opt_D_verbose_core2core
240    | Opt_D_verbose_stg2stg
241    | Opt_D_dump_hi
242    | Opt_D_dump_hi_diffs
243    | Opt_D_dump_minimal_imports
244    | Opt_D_dump_mod_cycles
245    | Opt_D_dump_view_pattern_commoning
246    | Opt_D_faststring_stats
247    | Opt_DumpToFile                     -- ^ Append dump output to files instead of stdout.
248    | Opt_D_no_debug_output
249    | Opt_DoCoreLinting
250    | Opt_DoStgLinting
251    | Opt_DoCmmLinting
252    | Opt_DoAsmLinting
253    | Opt_NoLlvmMangler                 -- hidden flag
254
255    | Opt_WarnIsError                    -- -Werror; makes warnings fatal
256
257    | Opt_PrintExplicitForalls
258
259    -- optimisation opts
260    | Opt_Strictness
261    | Opt_FullLaziness
262    | Opt_FloatIn
263    | Opt_Specialise
264    | Opt_StaticArgumentTransformation
265    | Opt_CSE
266    | Opt_LiberateCase
267    | Opt_SpecConstr
268    | Opt_DoLambdaEtaExpansion
269    | Opt_IgnoreAsserts
270    | Opt_DoEtaReduction
271    | Opt_CaseMerge
272    | Opt_UnboxStrictFields
273    | Opt_DictsCheap
274    | Opt_EnableRewriteRules             -- Apply rewrite rules during simplification
275    | Opt_Vectorise
276    | Opt_AvoidVect
277    | Opt_RegsGraph                      -- do graph coloring register allocation
278    | Opt_RegsIterative                  -- do iterative coalescing graph coloring register allocation
279    | Opt_PedanticBottoms                -- Be picky about how we treat bottom
280    | Opt_LlvmTBAA                       -- Use LLVM TBAA infastructure for improving AA (hidden flag)
281    | Opt_RegLiveness                    -- Use the STG Reg liveness information (hidden flag)
282    | Opt_IrrefutableTuples
283    | Opt_CmmSink
284    | Opt_CmmElimCommonBlocks
285
286    -- Interface files
287    | Opt_IgnoreInterfacePragmas
288    | Opt_OmitInterfacePragmas
289    | Opt_ExposeAllUnfoldings
290
291    -- profiling opts
292    | Opt_AutoSccsOnIndividualCafs
293    | Opt_ProfCountEntries
294
295    -- misc opts
296    | Opt_Pp
297    | Opt_ForceRecomp
298    | Opt_ExcessPrecision
299    | Opt_EagerBlackHoling
300    | Opt_NoHsMain
301    | Opt_SplitObjs
302    | Opt_StgStats
303    | Opt_StgUnshare
304    | Opt_HideAllPackages
305    | Opt_PrintBindResult
306    | Opt_Haddock
307    | Opt_HaddockOptions
308    | Opt_Hpc_No_Auto
309    | Opt_BreakOnException
310    | Opt_BreakOnError
311    | Opt_PrintEvldWithShow
312    | Opt_PrintBindContents
313    | Opt_GenManifest
314    | Opt_EmbedManifest
315    | Opt_EmitExternalCore
316    | Opt_SharedImplib
317    | Opt_BuildingCabalPackage
318    | Opt_SSE2
319    | Opt_SSE4_2
320    | Opt_IgnoreDotGhci
321    | Opt_GhciSandbox
322    | Opt_GhciHistory
323    | Opt_HelpfulErrors
324    | Opt_DeferTypeErrors
325    | Opt_Parallel
326    | Opt_GranMacros
327    | Opt_PIC
328    | Opt_SccProfilingOn
329
330    -- output style opts
331    | Opt_PprCaseAsLet
332
333    -- temporary flags
334    | Opt_RunCPS
335    | Opt_RunCPSZ
336    | Opt_AutoLinkPackages
337    | Opt_ImplicitImportQualified
338    | Opt_TryNewCodeGen
339
340    -- keeping stuff
341    | Opt_KeepHiDiffs
342    | Opt_KeepHcFiles
343    | Opt_KeepSFiles
344    | Opt_KeepTmpFiles
345    | Opt_KeepRawTokenStream
346    | Opt_KeepLlvmFiles
347
348    -- safe haskell flags
349    | Opt_DistrustAllPackages
350    | Opt_PackageTrust
351
352    deriving (Eq, Show, Enum)
353
354 data WarningFlag =
355      Opt_WarnDuplicateExports
356    | Opt_WarnHiShadows
357    | Opt_WarnImplicitPrelude
358    | Opt_WarnIncompletePatterns
359    | Opt_WarnIncompleteUniPatterns
360    | Opt_WarnIncompletePatternsRecUpd
361    | Opt_WarnMissingFields
362    | Opt_WarnMissingImportList
363    | Opt_WarnMissingMethods
364    | Opt_WarnMissingSigs
365    | Opt_WarnMissingLocalSigs
366    | Opt_WarnNameShadowing
367    | Opt_WarnOverlappingPatterns
368    | Opt_WarnTypeDefaults
369    | Opt_WarnMonomorphism
370    | Opt_WarnUnusedBinds
371    | Opt_WarnUnusedImports
372    | Opt_WarnUnusedMatches
373    | Opt_WarnWarningsDeprecations
374    | Opt_WarnDeprecatedFlags
375    | Opt_WarnDodgyExports
376    | Opt_WarnDodgyImports
377    | Opt_WarnOrphans
378    | Opt_WarnAutoOrphans
379    | Opt_WarnIdentities
380    | Opt_WarnTabs
381    | Opt_WarnUnrecognisedPragmas
382    | Opt_WarnDodgyForeignImports
383    | Opt_WarnLazyUnliftedBindings
384    | Opt_WarnUnusedDoBind
385    | Opt_WarnWrongDoBind
386    | Opt_WarnAlternativeLayoutRuleTransitional
387    | Opt_WarnUnsafe
388    | Opt_WarnSafe
389    | Opt_WarnPointlessPragmas
390    | Opt_WarnUnsupportedCallingConventions
391    | Opt_WarnInlineRuleShadowing
392    deriving (Eq, Show, Enum)
393
394 data Language = Haskell98 | Haskell2010
395    deriving Enum
396
397 -- | The various Safe Haskell modes
398 data SafeHaskellMode
399    = Sf_None
400    | Sf_Unsafe
401    | Sf_Trustworthy
402    | Sf_Safe
403    | Sf_SafeInferred
404    deriving (Eq)
405
406 instance Show SafeHaskellMode where
407     show Sf_None         = "None"
408     show Sf_Unsafe       = "Unsafe"
409     show Sf_Trustworthy  = "Trustworthy"
410     show Sf_Safe         = "Safe"
411     show Sf_SafeInferred = "Safe-Inferred"
412
413 instance Outputable SafeHaskellMode where
414     ppr = text . show
415
416 data ExtensionFlag
417    = Opt_Cpp
418    | Opt_OverlappingInstances
419    | Opt_UndecidableInstances
420    | Opt_IncoherentInstances
421    | Opt_MonomorphismRestriction
422    | Opt_MonoPatBinds
423    | Opt_MonoLocalBinds
424    | Opt_RelaxedPolyRec           -- Deprecated
425    | Opt_ExtendedDefaultRules     -- Use GHC's extended rules for defaulting
426    | Opt_ForeignFunctionInterface
427    | Opt_UnliftedFFITypes
428    | Opt_InterruptibleFFI
429    | Opt_CApiFFI
430    | Opt_GHCForeignImportPrim
431    | Opt_ParallelArrays           -- Syntactic support for parallel arrays
432    | Opt_Arrows                   -- Arrow-notation syntax
433    | Opt_TemplateHaskell
434    | Opt_QuasiQuotes
435    | Opt_ImplicitParams
436    | Opt_ImplicitPrelude
437    | Opt_ScopedTypeVariables
438    | Opt_UnboxedTuples
439    | Opt_BangPatterns
440    | Opt_TypeFamilies
441    | Opt_OverloadedStrings
442    | Opt_DisambiguateRecordFields
443    | Opt_RecordWildCards
444    | Opt_RecordPuns
445    | Opt_ViewPatterns
446    | Opt_GADTs
447    | Opt_GADTSyntax
448    | Opt_NPlusKPatterns
449    | Opt_DoAndIfThenElse
450    | Opt_RebindableSyntax
451    | Opt_ConstraintKinds
452    | Opt_PolyKinds                -- Kind polymorphism
453    | Opt_DataKinds                -- Datatype promotion
454    | Opt_InstanceSigs
455  
456    | Opt_StandaloneDeriving
457    | Opt_DeriveDataTypeable
458    | Opt_DeriveFunctor
459    | Opt_DeriveTraversable
460    | Opt_DeriveFoldable
461    | Opt_DeriveGeneric            -- Allow deriving Generic/1
462    | Opt_DefaultSignatures        -- Allow extra signatures for defmeths
463
464    | Opt_TypeSynonymInstances
465    | Opt_FlexibleContexts
466    | Opt_FlexibleInstances
467    | Opt_ConstrainedClassMethods
468    | Opt_MultiParamTypeClasses
469    | Opt_FunctionalDependencies
470    | Opt_UnicodeSyntax
471    | Opt_PolymorphicComponents
472    | Opt_ExistentialQuantification
473    | Opt_MagicHash
474    | Opt_EmptyDataDecls
475    | Opt_KindSignatures
476    | Opt_ParallelListComp
477    | Opt_TransformListComp
478    | Opt_MonadComprehensions
479    | Opt_GeneralizedNewtypeDeriving
480    | Opt_RecursiveDo
481    | Opt_PostfixOperators
482    | Opt_TupleSections
483    | Opt_PatternGuards
484    | Opt_LiberalTypeSynonyms
485    | Opt_Rank2Types
486    | Opt_RankNTypes
487    | Opt_ImpredicativeTypes
488    | Opt_TypeOperators
489    | Opt_ExplicitNamespaces
490    | Opt_PackageImports
491    | Opt_ExplicitForAll
492    | Opt_AlternativeLayoutRule
493    | Opt_AlternativeLayoutRuleTransitional
494    | Opt_DatatypeContexts
495    | Opt_NondecreasingIndentation
496    | Opt_RelaxedLayout
497    | Opt_TraditionalRecordSyntax
498    | Opt_LambdaCase
499    | Opt_MultiWayIf
500    deriving (Eq, Enum, Show)
501
502 -- | Contains not only a collection of 'DynFlag's but also a plethora of
503 -- information relating to the compilation of a single file or GHC session
504 data DynFlags = DynFlags {
505   ghcMode               :: GhcMode,
506   ghcLink               :: GhcLink,
507   hscTarget             :: HscTarget,
508   settings              :: Settings,
509   hscOutName            :: String,      -- ^ Name of the output file
510   extCoreName           :: String,      -- ^ Name of the .hcr output file
511   verbosity             :: Int,         -- ^ Verbosity level: see Note [Verbosity levels]
512   optLevel              :: Int,         -- ^ Optimisation level
513   simplPhases           :: Int,         -- ^ Number of simplifier phases
514   maxSimplIterations    :: Int,         -- ^ Max simplifier iterations
515   shouldDumpSimplPhase  :: Maybe String,
516   ruleCheck             :: Maybe String,
517   strictnessBefore      :: [Int],       -- ^ Additional demand analysis
518
519   simplTickFactor       :: Int,         -- ^ Multiplier for simplifier ticks
520   specConstrThreshold   :: Maybe Int,   -- ^ Threshold for SpecConstr
521   specConstrCount       :: Maybe Int,   -- ^ Max number of specialisations for any one function
522   liberateCaseThreshold :: Maybe Int,   -- ^ Threshold for LiberateCase
523   floatLamArgs          :: Maybe Int,   -- ^ Arg count for lambda floating
524                                         --   See CoreMonad.FloatOutSwitches
525
526   cmdlineHcIncludes     :: [String],    -- ^ @\-\#includes@
527   importPaths           :: [FilePath],
528   mainModIs             :: Module,
529   mainFunIs             :: Maybe String,
530   ctxtStkDepth          :: Int,         -- ^ Typechecker context stack depth
531
532   thisPackage           :: PackageId,   -- ^ name of package currently being compiled
533
534   -- ways
535   ways                  :: [Way],       -- ^ Way flags from the command line
536   buildTag              :: String,      -- ^ The global \"way\" (e.g. \"p\" for prof)
537   rtsBuildTag           :: String,      -- ^ The RTS \"way\"
538
539   -- For object splitting
540   splitInfo             :: Maybe (String,Int),
541
542   -- paths etc.
543   objectDir             :: Maybe String,
544   dylibInstallName      :: Maybe String,
545   hiDir                 :: Maybe String,
546   stubDir               :: Maybe String,
547   dumpDir               :: Maybe String,
548
549   objectSuf             :: String,
550   hcSuf                 :: String,
551   hiSuf                 :: String,
552
553   outputFile            :: Maybe String,
554   outputHi              :: Maybe String,
555   dynLibLoader          :: DynLibLoader,
556
557   -- | This is set by 'DriverPipeline.runPipeline' based on where
558   --    its output is going.
559   dumpPrefix            :: Maybe FilePath,
560
561   -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
562   --    Set by @-ddump-file-prefix@
563   dumpPrefixForce       :: Maybe FilePath,
564
565   includePaths          :: [String],
566   libraryPaths          :: [String],
567   frameworkPaths        :: [String],    -- used on darwin only
568   cmdlineFrameworks     :: [String],    -- ditto
569
570   rtsOpts               :: Maybe String,
571   rtsOptsEnabled        :: RtsOptsEnabled,
572
573   hpcDir                :: String,      -- ^ Path to store the .mix files
574
575   -- Plugins
576   pluginModNames        :: [ModuleName],
577   pluginModNameOpts     :: [(ModuleName,String)],
578
579   --  For ghc -M
580   depMakefile           :: FilePath,
581   depIncludePkgDeps     :: Bool,
582   depExcludeMods        :: [ModuleName],
583   depSuffixes           :: [String],
584
585   --  Package flags
586   extraPkgConfs         :: [PkgConfRef] -> [PkgConfRef],
587         -- ^ The @-package-db@ flags given on the command line, in the order
588         -- they appeared.
589
590   packageFlags          :: [PackageFlag],
591         -- ^ The @-package@ and @-hide-package@ flags from the command-line
592
593   -- Package state
594   -- NB. do not modify this field, it is calculated by
595   -- Packages.initPackages and Packages.updatePackages.
596   pkgDatabase           :: Maybe [PackageConfig],
597   pkgState              :: PackageState,
598
599   -- Temporary files
600   -- These have to be IORefs, because the defaultCleanupHandler needs to
601   -- know what to clean when an exception happens
602   filesToClean          :: IORef [FilePath],
603   dirsToClean           :: IORef (Map FilePath FilePath),
604
605   -- Names of files which were generated from -ddump-to-file; used to
606   -- track which ones we need to truncate because it's our first run
607   -- through
608   generatedDumps        :: IORef (Set FilePath),
609
610   -- hsc dynamic flags
611   flags                 :: IntSet,
612   warningFlags          :: IntSet,
613   -- Don't change this without updating extensionFlags:
614   language              :: Maybe Language,
615   -- | Safe Haskell mode
616   safeHaskell           :: SafeHaskellMode,
617   -- We store the location of where some extension and flags were turned on so
618   -- we can produce accurate error messages when Safe Haskell fails due to
619   -- them.
620   thOnLoc               :: SrcSpan,
621   newDerivOnLoc         :: SrcSpan,
622   pkgTrustOnLoc         :: SrcSpan,
623   warnSafeOnLoc         :: SrcSpan,
624   warnUnsafeOnLoc       :: SrcSpan,
625   -- Don't change this without updating extensionFlags:
626   extensions            :: [OnOff ExtensionFlag],
627   -- extensionFlags should always be equal to
628   --     flattenExtensionFlags language extensions
629   extensionFlags        :: IntSet,
630
631   -- | MsgDoc output action: use "ErrUtils" instead of this if you can
632   log_action            :: LogAction,
633   flushOut              :: FlushOut,
634   flushErr              :: FlushErr,
635
636   haddockOptions        :: Maybe String,
637   ghciScripts           :: [String],
638
639   -- Output style options
640   pprUserLength         :: Int,
641   pprCols               :: Int,
642   traceLevel            :: Int, -- Standard level is 1. Less verbose is 0.
643
644   -- | what kind of {-# SCC #-} to add automatically
645   profAuto              :: ProfAuto,
646
647   interactivePrint      :: Maybe String,
648
649   llvmVersion           :: IORef (Int)
650  }
651
652 class HasDynFlags m where
653     getDynFlags :: m DynFlags
654
655 class ContainsDynFlags t where
656     extractDynFlags :: t -> DynFlags
657
658 data ProfAuto
659   = NoProfAuto         -- ^ no SCC annotations added
660   | ProfAutoAll        -- ^ top-level and nested functions are annotated
661   | ProfAutoTop        -- ^ top-level functions annotated only
662   | ProfAutoExports    -- ^ exported functions annotated only
663   | ProfAutoCalls      -- ^ annotate call-sites
664   deriving (Enum)
665
666 data Settings = Settings {
667   sTargetPlatform        :: Platform,    -- Filled in by SysTools
668   sGhcUsagePath          :: FilePath,    -- Filled in by SysTools
669   sGhciUsagePath         :: FilePath,    -- ditto
670   sTopDir                :: FilePath,
671   sTmpDir                :: String,      -- no trailing '/'
672   -- You shouldn't need to look things up in rawSettings directly.
673   -- They should have their own fields instead.
674   sRawSettings           :: [(String, String)],
675   sExtraGccViaCFlags     :: [String],
676   sSystemPackageConfig   :: FilePath,
677   sLdSupportsCompactUnwind :: Bool,
678   sLdSupportsBuildId       :: Bool,
679   sLdIsGnuLd               :: Bool,
680   -- commands for particular phases
681   sPgm_L                 :: String,
682   sPgm_P                 :: (String,[Option]),
683   sPgm_F                 :: String,
684   sPgm_c                 :: (String,[Option]),
685   sPgm_s                 :: (String,[Option]),
686   sPgm_a                 :: (String,[Option]),
687   sPgm_l                 :: (String,[Option]),
688   sPgm_dll               :: (String,[Option]),
689   sPgm_T                 :: String,
690   sPgm_sysman            :: String,
691   sPgm_windres           :: String,
692   sPgm_lo                :: (String,[Option]), -- LLVM: opt llvm optimiser
693   sPgm_lc                :: (String,[Option]), -- LLVM: llc static compiler
694   -- options for particular phases
695   sOpt_L                 :: [String],
696   sOpt_P                 :: [String],
697   sOpt_F                 :: [String],
698   sOpt_c                 :: [String],
699   sOpt_a                 :: [String],
700   sOpt_l                 :: [String],
701   sOpt_windres           :: [String],
702   sOpt_lo                :: [String], -- LLVM: llvm optimiser
703   sOpt_lc                :: [String]  -- LLVM: llc static compiler
704
705  }
706
707 targetPlatform :: DynFlags -> Platform
708 targetPlatform dflags = sTargetPlatform (settings dflags)
709
710 ghcUsagePath          :: DynFlags -> FilePath
711 ghcUsagePath dflags = sGhcUsagePath (settings dflags)
712 ghciUsagePath         :: DynFlags -> FilePath
713 ghciUsagePath dflags = sGhciUsagePath (settings dflags)
714 topDir                :: DynFlags -> FilePath
715 topDir dflags = sTopDir (settings dflags)
716 tmpDir                :: DynFlags -> String
717 tmpDir dflags = sTmpDir (settings dflags)
718 rawSettings           :: DynFlags -> [(String, String)]
719 rawSettings dflags = sRawSettings (settings dflags)
720 extraGccViaCFlags     :: DynFlags -> [String]
721 extraGccViaCFlags dflags = sExtraGccViaCFlags (settings dflags)
722 systemPackageConfig   :: DynFlags -> FilePath
723 systemPackageConfig dflags = sSystemPackageConfig (settings dflags)
724 pgm_L                 :: DynFlags -> String
725 pgm_L dflags = sPgm_L (settings dflags)
726 pgm_P                 :: DynFlags -> (String,[Option])
727 pgm_P dflags = sPgm_P (settings dflags)
728 pgm_F                 :: DynFlags -> String
729 pgm_F dflags = sPgm_F (settings dflags)
730 pgm_c                 :: DynFlags -> (String,[Option])
731 pgm_c dflags = sPgm_c (settings dflags)
732 pgm_s                 :: DynFlags -> (String,[Option])
733 pgm_s dflags = sPgm_s (settings dflags)
734 pgm_a                 :: DynFlags -> (String,[Option])
735 pgm_a dflags = sPgm_a (settings dflags)
736 pgm_l                 :: DynFlags -> (String,[Option])
737 pgm_l dflags = sPgm_l (settings dflags)
738 pgm_dll               :: DynFlags -> (String,[Option])
739 pgm_dll dflags = sPgm_dll (settings dflags)
740 pgm_T                 :: DynFlags -> String
741 pgm_T dflags = sPgm_T (settings dflags)
742 pgm_sysman            :: DynFlags -> String
743 pgm_sysman dflags = sPgm_sysman (settings dflags)
744 pgm_windres           :: DynFlags -> String
745 pgm_windres dflags = sPgm_windres (settings dflags)
746 pgm_lo                :: DynFlags -> (String,[Option])
747 pgm_lo dflags = sPgm_lo (settings dflags)
748 pgm_lc                :: DynFlags -> (String,[Option])
749 pgm_lc dflags = sPgm_lc (settings dflags)
750 opt_L                 :: DynFlags -> [String]
751 opt_L dflags = sOpt_L (settings dflags)
752 opt_P                 :: DynFlags -> [String]
753 opt_P dflags = sOpt_P (settings dflags)
754 opt_F                 :: DynFlags -> [String]
755 opt_F dflags = sOpt_F (settings dflags)
756 opt_c                 :: DynFlags -> [String]
757 opt_c dflags = sOpt_c (settings dflags)
758 opt_a                 :: DynFlags -> [String]
759 opt_a dflags = sOpt_a (settings dflags)
760 opt_l                 :: DynFlags -> [String]
761 opt_l dflags = sOpt_l (settings dflags)
762 opt_windres           :: DynFlags -> [String]
763 opt_windres dflags = sOpt_windres (settings dflags)
764 opt_lo                :: DynFlags -> [String]
765 opt_lo dflags = sOpt_lo (settings dflags)
766 opt_lc                :: DynFlags -> [String]
767 opt_lc dflags = sOpt_lc (settings dflags)
768
769 wayNames :: DynFlags -> [WayName]
770 wayNames = map wayName . ways
771
772 -- | The target code type of the compilation (if any).
773 --
774 -- Whenever you change the target, also make sure to set 'ghcLink' to
775 -- something sensible.
776 --
777 -- 'HscNothing' can be used to avoid generating any output, however, note
778 -- that:
779 --
780 --  * This will not run the desugaring step, thus no warnings generated in
781 --    this step will be output.  In particular, this includes warnings related
782 --    to pattern matching.  You can run the desugarer manually using
783 --    'GHC.desugarModule'.
784 --
785 --  * If a program uses Template Haskell the typechecker may try to run code
786 --    from an imported module.  This will fail if no code has been generated
787 --    for this module.  You can use 'GHC.needsTemplateHaskell' to detect
788 --    whether this might be the case and choose to either switch to a
789 --    different target or avoid typechecking such modules.  (The latter may be
790 --    preferable for security reasons.)
791 --
792 data HscTarget
793   = HscC           -- ^ Generate C code.
794   | HscAsm         -- ^ Generate assembly using the native code generator.
795   | HscLlvm        -- ^ Generate assembly using the llvm code generator.
796   | HscInterpreted -- ^ Generate bytecode.  (Requires 'LinkInMemory')
797   | HscNothing     -- ^ Don't generate any code.  See notes above.
798   deriving (Eq, Show)
799
800 showHscTargetFlag :: HscTarget -> String
801 showHscTargetFlag HscC           = "-fvia-c"
802 showHscTargetFlag HscAsm         = "-fasm"
803 showHscTargetFlag HscLlvm        = "-fllvm"
804 showHscTargetFlag HscInterpreted = "-fbyte-code"
805 showHscTargetFlag HscNothing     = "-fno-code"
806
807 -- | Will this target result in an object file on the disk?
808 isObjectTarget :: HscTarget -> Bool
809 isObjectTarget HscC     = True
810 isObjectTarget HscAsm   = True
811 isObjectTarget HscLlvm  = True
812 isObjectTarget _        = False
813
814 -- | Does this target retain *all* top-level bindings for a module,
815 -- rather than just the exported bindings, in the TypeEnv and compiled
816 -- code (if any)?  In interpreted mode we do this, so that GHCi can
817 -- call functions inside a module.  In HscNothing mode we also do it,
818 -- so that Haddock can get access to the GlobalRdrEnv for a module
819 -- after typechecking it.
820 targetRetainsAllBindings :: HscTarget -> Bool
821 targetRetainsAllBindings HscInterpreted = True
822 targetRetainsAllBindings HscNothing     = True
823 targetRetainsAllBindings _              = False
824
825 -- | The 'GhcMode' tells us whether we're doing multi-module
826 -- compilation (controlled via the "GHC" API) or one-shot
827 -- (single-module) compilation.  This makes a difference primarily to
828 -- the "Finder": in one-shot mode we look for interface files for
829 -- imported modules, but in multi-module mode we look for source files
830 -- in order to check whether they need to be recompiled.
831 data GhcMode
832   = CompManager         -- ^ @\-\-make@, GHCi, etc.
833   | OneShot             -- ^ @ghc -c Foo.hs@
834   | MkDepend            -- ^ @ghc -M@, see "Finder" for why we need this
835   deriving Eq
836
837 instance Outputable GhcMode where
838   ppr CompManager = ptext (sLit "CompManager")
839   ppr OneShot     = ptext (sLit "OneShot")
840   ppr MkDepend    = ptext (sLit "MkDepend")
841
842 isOneShot :: GhcMode -> Bool
843 isOneShot OneShot = True
844 isOneShot _other  = False
845
846 -- | What to do in the link step, if there is one.
847 data GhcLink
848   = NoLink              -- ^ Don't link at all
849   | LinkBinary          -- ^ Link object code into a binary
850   | LinkInMemory        -- ^ Use the in-memory dynamic linker (works for both
851                         --   bytecode and object code).
852   | LinkDynLib          -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
853   deriving (Eq, Show)
854
855 isNoLink :: GhcLink -> Bool
856 isNoLink NoLink = True
857 isNoLink _      = False
858
859 -- Is it worth evaluating this Bool and caching it in the DynFlags value
860 -- during initDynFlags?
861 doingTickyProfiling :: DynFlags -> Bool
862 doingTickyProfiling _ = opt_Ticky
863   -- XXX -ticky is a static flag, because it implies -debug which is also
864   -- static.  If the way flags were made dynamic, we could fix this.
865
866 data PackageFlag
867   = ExposePackage   String
868   | ExposePackageId String
869   | HidePackage     String
870   | IgnorePackage   String
871   | TrustPackage    String
872   | DistrustPackage String
873   deriving Eq
874
875 defaultHscTarget :: Platform -> HscTarget
876 defaultHscTarget = defaultObjectTarget
877
878 -- | The 'HscTarget' value corresponding to the default way to create
879 -- object files on the current platform.
880 defaultObjectTarget :: Platform -> HscTarget
881 defaultObjectTarget platform
882   | platformUnregisterised platform     =  HscC
883   | cGhcWithNativeCodeGen == "YES"      =  HscAsm
884   | otherwise                           =  HscLlvm
885
886 tablesNextToCode :: DynFlags -> Bool
887 tablesNextToCode dflags
888     = mkTablesNextToCode (platformUnregisterised (targetPlatform dflags))
889
890 -- Determines whether we will be compiling
891 -- info tables that reside just before the entry code, or with an
892 -- indirection to the entry code.  See TABLES_NEXT_TO_CODE in
893 -- includes/rts/storage/InfoTables.h.
894 mkTablesNextToCode :: Bool -> Bool
895 mkTablesNextToCode unregisterised
896     = not unregisterised && cGhcEnableTablesNextToCode == "YES"
897
898 data DynLibLoader
899   = Deployable
900   | SystemDependent
901   deriving Eq
902
903 data RtsOptsEnabled = RtsOptsNone | RtsOptsSafeOnly | RtsOptsAll
904   deriving (Show)
905
906 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
907 initDynFlags :: DynFlags -> IO DynFlags
908 initDynFlags dflags = do
909  -- someday these will be dynamic flags
910  ways <- readIORef v_Ways
911  refFilesToClean <- newIORef []
912  refDirsToClean <- newIORef Map.empty
913  refGeneratedDumps <- newIORef Set.empty
914  refLlvmVersion <- newIORef 28
915  return dflags{
916         ways           = ways,
917         buildTag       = mkBuildTag (filter (not . wayRTSOnly) ways),
918         rtsBuildTag    = mkBuildTag ways,
919         filesToClean   = refFilesToClean,
920         dirsToClean    = refDirsToClean,
921         generatedDumps = refGeneratedDumps,
922         llvmVersion    = refLlvmVersion
923         }
924
925 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
926 -- and must be fully initialized by 'GHC.newSession' first.
927 defaultDynFlags :: Settings -> DynFlags
928 defaultDynFlags mySettings =
929      DynFlags {
930         ghcMode                 = CompManager,
931         ghcLink                 = LinkBinary,
932         hscTarget               = defaultHscTarget (sTargetPlatform mySettings),
933         hscOutName              = "",
934         extCoreName             = "",
935         verbosity               = 0,
936         optLevel                = 0,
937         simplPhases             = 2,
938         maxSimplIterations      = 4,
939         shouldDumpSimplPhase    = Nothing,
940         ruleCheck               = Nothing,
941         simplTickFactor         = 100,
942         specConstrThreshold     = Just 2000,
943         specConstrCount         = Just 3,
944         liberateCaseThreshold   = Just 2000,
945         floatLamArgs            = Just 0, -- Default: float only if no fvs
946         strictnessBefore        = [],
947
948         cmdlineHcIncludes       = [],
949         importPaths             = ["."],
950         mainModIs               = mAIN,
951         mainFunIs               = Nothing,
952         ctxtStkDepth            = mAX_CONTEXT_REDUCTION_DEPTH,
953
954         thisPackage             = mainPackageId,
955
956         objectDir               = Nothing,
957         dylibInstallName        = Nothing,
958         hiDir                   = Nothing,
959         stubDir                 = Nothing,
960         dumpDir                 = Nothing,
961
962         objectSuf               = phaseInputExt StopLn,
963         hcSuf                   = phaseInputExt HCc,
964         hiSuf                   = "hi",
965
966         pluginModNames          = [],
967         pluginModNameOpts       = [],
968
969         outputFile              = Nothing,
970         outputHi                = Nothing,
971         dynLibLoader            = SystemDependent,
972         dumpPrefix              = Nothing,
973         dumpPrefixForce         = Nothing,
974         includePaths            = [],
975         libraryPaths            = [],
976         frameworkPaths          = [],
977         cmdlineFrameworks       = [],
978         rtsOpts                 = Nothing,
979         rtsOptsEnabled          = RtsOptsSafeOnly,
980
981         hpcDir                  = ".hpc",
982
983         extraPkgConfs           = id,
984         packageFlags            = [],
985         pkgDatabase             = Nothing,
986         pkgState                = panic "no package state yet: call GHC.setSessionDynFlags",
987         ways                    = panic "defaultDynFlags: No ways",
988         buildTag                = panic "defaultDynFlags: No buildTag",
989         rtsBuildTag             = panic "defaultDynFlags: No rtsBuildTag",
990         splitInfo               = Nothing,
991         settings                = mySettings,
992         -- ghc -M values
993         depMakefile       = "Makefile",
994         depIncludePkgDeps = False,
995         depExcludeMods    = [],
996         depSuffixes       = [],
997         -- end of ghc -M values
998         filesToClean   = panic "defaultDynFlags: No filesToClean",
999         dirsToClean    = panic "defaultDynFlags: No dirsToClean",
1000         generatedDumps = panic "defaultDynFlags: No generatedDumps",
1001         haddockOptions = Nothing,
1002         flags = IntSet.fromList (map fromEnum (defaultFlags (sTargetPlatform mySettings))),
1003         warningFlags = IntSet.fromList (map fromEnum standardWarnings),
1004         ghciScripts = [],
1005         language = Nothing,
1006         safeHaskell = Sf_SafeInferred,
1007         thOnLoc = noSrcSpan,
1008         newDerivOnLoc = noSrcSpan,
1009         pkgTrustOnLoc = noSrcSpan,
1010         warnSafeOnLoc = noSrcSpan,
1011         warnUnsafeOnLoc = noSrcSpan,
1012         extensions = [],
1013         extensionFlags = flattenExtensionFlags Nothing [],
1014         log_action = defaultLogAction,
1015         flushOut = defaultFlushOut,
1016         flushErr = defaultFlushErr,
1017         pprUserLength = 5,
1018         pprCols = 100,
1019         traceLevel = 1,
1020         profAuto = NoProfAuto,
1021         llvmVersion = panic "defaultDynFlags: No llvmVersion",
1022         interactivePrint = Nothing
1023       }
1024
1025 --------------------------------------------------------------------------
1026 -- Do not use tracingDynFlags!
1027 -- tracingDynFlags is a hack, necessary because we need to be able to
1028 -- show SDocs when tracing, but we don't always have DynFlags available.
1029 -- Do not use it if you can help it. It will not reflect options set
1030 -- by the commandline flags, and all fields may be either wrong or
1031 -- undefined.
1032 tracingDynFlags :: DynFlags
1033 tracingDynFlags = defaultDynFlags tracingSettings
1034
1035 tracingSettings :: Settings
1036 tracingSettings = trace "panic: Settings not defined in tracingDynFlags" $
1037                   Settings { sTargetPlatform = tracingPlatform }
1038                   -- Missing flags give a nice error
1039
1040 tracingPlatform :: Platform
1041 tracingPlatform = Platform { platformWordSize = 4, platformOS = OSUnknown }
1042                   -- Missing flags give a nice error
1043 --------------------------------------------------------------------------
1044
1045 type FatalMessager = String -> IO ()
1046 type LogAction = DynFlags -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO ()
1047
1048 defaultFatalMessager :: FatalMessager
1049 defaultFatalMessager = hPutStrLn stderr
1050
1051 defaultLogAction :: LogAction
1052 defaultLogAction dflags severity srcSpan style msg
1053     = case severity of
1054       SevOutput -> printSDoc msg style
1055       SevDump   -> printSDoc (msg $$ blankLine) style
1056       SevInfo   -> printErrs msg style
1057       SevFatal  -> printErrs msg style
1058       _         -> do hPutChar stderr '\n'
1059                       printErrs (mkLocMessage severity srcSpan msg) style
1060                       -- careful (#2302): printErrs prints in UTF-8, whereas
1061                       -- converting to string first and using hPutStr would
1062                       -- just emit the low 8 bits of each unicode char.
1063     where printSDoc = defaultLogActionHPrintDoc dflags stdout
1064           printErrs = defaultLogActionHPrintDoc dflags stderr
1065
1066 defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
1067 defaultLogActionHPrintDoc dflags h d sty
1068     = do let doc = runSDoc d (initSDocContext dflags sty)
1069          Pretty.printDoc Pretty.PageMode (pprCols dflags) h doc
1070          hFlush h
1071
1072 newtype FlushOut = FlushOut (IO ())
1073
1074 defaultFlushOut :: FlushOut
1075 defaultFlushOut = FlushOut $ hFlush stdout
1076
1077 newtype FlushErr = FlushErr (IO ())
1078
1079 defaultFlushErr :: FlushErr
1080 defaultFlushErr = FlushErr $ hFlush stderr
1081
1082 printOutputForUser :: DynFlags -> PrintUnqualified -> SDoc -> IO ()
1083 printOutputForUser = printSevForUser SevOutput
1084
1085 printInfoForUser :: DynFlags -> PrintUnqualified -> SDoc -> IO ()
1086 printInfoForUser = printSevForUser SevInfo
1087
1088 printSevForUser :: Severity -> DynFlags -> PrintUnqualified -> SDoc -> IO ()
1089 printSevForUser sev dflags unqual doc
1090     = log_action dflags dflags sev noSrcSpan (mkUserStyle unqual AllTheWay) doc
1091
1092 {-
1093 Note [Verbosity levels]
1094 ~~~~~~~~~~~~~~~~~~~~~~~
1095     0   |   print errors & warnings only
1096     1   |   minimal verbosity: print "compiling M ... done." for each module.
1097     2   |   equivalent to -dshow-passes
1098     3   |   equivalent to existing "ghc -v"
1099     4   |   "ghc -v -ddump-most"
1100     5   |   "ghc -v -ddump-all"
1101 -}
1102
1103 data OnOff a = On a
1104              | Off a
1105
1106 -- OnOffs accumulate in reverse order, so we use foldr in order to
1107 -- process them in the right order
1108 flattenExtensionFlags :: Maybe Language -> [OnOff ExtensionFlag] -> IntSet
1109 flattenExtensionFlags ml = foldr f defaultExtensionFlags
1110     where f (On f)  flags = IntSet.insert (fromEnum f) flags
1111           f (Off f) flags = IntSet.delete (fromEnum f) flags
1112           defaultExtensionFlags = IntSet.fromList (map fromEnum (languageExtensions ml))
1113
1114 languageExtensions :: Maybe Language -> [ExtensionFlag]
1115
1116 languageExtensions Nothing
1117     -- Nothing => the default case
1118     = Opt_NondecreasingIndentation -- This has been on by default for some time
1119     : delete Opt_DatatypeContexts  -- The Haskell' committee decided to
1120                                    -- remove datatype contexts from the
1121                                    -- language:
1122    -- http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html
1123       (languageExtensions (Just Haskell2010))
1124
1125    -- NB: MonoPatBinds is no longer the default
1126
1127 languageExtensions (Just Haskell98)
1128     = [Opt_ImplicitPrelude,
1129        Opt_MonomorphismRestriction,
1130        Opt_NPlusKPatterns,
1131        Opt_DatatypeContexts,
1132        Opt_TraditionalRecordSyntax,
1133        Opt_NondecreasingIndentation
1134            -- strictly speaking non-standard, but we always had this
1135            -- on implicitly before the option was added in 7.1, and
1136            -- turning it off breaks code, so we're keeping it on for
1137            -- backwards compatibility.  Cabal uses -XHaskell98 by
1138            -- default unless you specify another language.
1139       ]
1140
1141 languageExtensions (Just Haskell2010)
1142     = [Opt_ImplicitPrelude,
1143        Opt_MonomorphismRestriction,
1144        Opt_DatatypeContexts,
1145        Opt_TraditionalRecordSyntax,
1146        Opt_EmptyDataDecls,
1147        Opt_ForeignFunctionInterface,
1148        Opt_PatternGuards,
1149        Opt_DoAndIfThenElse,
1150        Opt_RelaxedPolyRec]
1151
1152 -- | Test whether a 'DynFlag' is set
1153 dopt :: DynFlag -> DynFlags -> Bool
1154 dopt f dflags  = fromEnum f `IntSet.member` flags dflags
1155
1156 -- | Set a 'DynFlag'
1157 dopt_set :: DynFlags -> DynFlag -> DynFlags
1158 dopt_set dfs f = dfs{ flags = IntSet.insert (fromEnum f) (flags dfs) }
1159
1160 -- | Unset a 'DynFlag'
1161 dopt_unset :: DynFlags -> DynFlag -> DynFlags
1162 dopt_unset dfs f = dfs{ flags = IntSet.delete (fromEnum f) (flags dfs) }
1163
1164 -- | Test whether a 'WarningFlag' is set
1165 wopt :: WarningFlag -> DynFlags -> Bool
1166 wopt f dflags  = fromEnum f `IntSet.member` warningFlags dflags
1167
1168 -- | Set a 'WarningFlag'
1169 wopt_set :: DynFlags -> WarningFlag -> DynFlags
1170 wopt_set dfs f = dfs{ warningFlags = IntSet.insert (fromEnum f) (warningFlags dfs) }
1171
1172 -- | Unset a 'WarningFlag'
1173 wopt_unset :: DynFlags -> WarningFlag -> DynFlags
1174 wopt_unset dfs f = dfs{ warningFlags = IntSet.delete (fromEnum f) (warningFlags dfs) }
1175
1176 -- | Test whether a 'ExtensionFlag' is set
1177 xopt :: ExtensionFlag -> DynFlags -> Bool
1178 xopt f dflags = fromEnum f `IntSet.member` extensionFlags dflags
1179
1180 -- | Set a 'ExtensionFlag'
1181 xopt_set :: DynFlags -> ExtensionFlag -> DynFlags
1182 xopt_set dfs f
1183     = let onoffs = On f : extensions dfs
1184       in dfs { extensions = onoffs,
1185                extensionFlags = flattenExtensionFlags (language dfs) onoffs }
1186
1187 -- | Unset a 'ExtensionFlag'
1188 xopt_unset :: DynFlags -> ExtensionFlag -> DynFlags
1189 xopt_unset dfs f
1190     = let onoffs = Off f : extensions dfs
1191       in dfs { extensions = onoffs,
1192                extensionFlags = flattenExtensionFlags (language dfs) onoffs }
1193
1194 lang_set :: DynFlags -> Maybe Language -> DynFlags
1195 lang_set dflags lang =
1196    dflags {
1197             language = lang,
1198             extensionFlags = flattenExtensionFlags lang (extensions dflags)
1199           }
1200
1201 -- | Set the Haskell language standard to use
1202 setLanguage :: Language -> DynP ()
1203 setLanguage l = upd (`lang_set` Just l)
1204
1205 -- | Some modules have dependencies on others through the DynFlags rather than textual imports
1206 dynFlagDependencies :: DynFlags -> [ModuleName]
1207 dynFlagDependencies = pluginModNames
1208
1209 -- | Is the -fpackage-trust mode on
1210 packageTrustOn :: DynFlags -> Bool
1211 packageTrustOn = dopt Opt_PackageTrust
1212
1213 -- | Is Safe Haskell on in some way (including inference mode)
1214 safeHaskellOn :: DynFlags -> Bool
1215 safeHaskellOn dflags = safeHaskell dflags /= Sf_None
1216
1217 -- | Is the Safe Haskell safe language in use
1218 safeLanguageOn :: DynFlags -> Bool
1219 safeLanguageOn dflags = safeHaskell dflags == Sf_Safe
1220
1221 -- | Is the Safe Haskell safe inference mode active
1222 safeInferOn :: DynFlags -> Bool
1223 safeInferOn dflags = safeHaskell dflags == Sf_SafeInferred
1224
1225 -- | Test if Safe Imports are on in some form
1226 safeImportsOn :: DynFlags -> Bool
1227 safeImportsOn dflags = safeHaskell dflags == Sf_Unsafe ||
1228                        safeHaskell dflags == Sf_Trustworthy ||
1229                        safeHaskell dflags == Sf_Safe
1230
1231 -- | Set a 'Safe Haskell' flag
1232 setSafeHaskell :: SafeHaskellMode -> DynP ()
1233 setSafeHaskell s = updM f
1234     where f dfs = do
1235               let sf = safeHaskell dfs
1236               safeM <- combineSafeFlags sf s
1237               return $ dfs { safeHaskell = safeM }
1238
1239 -- | Are all direct imports required to be safe for this Safe Haskell mode?
1240 -- Direct imports are when the code explicitly imports a module
1241 safeDirectImpsReq :: DynFlags -> Bool
1242 safeDirectImpsReq d = safeLanguageOn d
1243
1244 -- | Are all implicit imports required to be safe for this Safe Haskell mode?
1245 -- Implicit imports are things in the prelude. e.g System.IO when print is used.
1246 safeImplicitImpsReq :: DynFlags -> Bool
1247 safeImplicitImpsReq d = safeLanguageOn d
1248
1249 -- | Combine two Safe Haskell modes correctly. Used for dealing with multiple flags.
1250 -- This makes Safe Haskell very much a monoid but for now I prefer this as I don't
1251 -- want to export this functionality from the module but do want to export the
1252 -- type constructors.
1253 combineSafeFlags :: SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
1254 combineSafeFlags a b | a == Sf_SafeInferred = return b
1255                      | b == Sf_SafeInferred = return a
1256                      | a == Sf_None         = return b
1257                      | b == Sf_None         = return a
1258                      | a == b               = return a
1259                      | otherwise            = addErr errm >> return (panic errm)
1260     where errm = "Incompatible Safe Haskell flags! ("
1261                     ++ show a ++ ", " ++ show b ++ ")"
1262
1263 -- | A list of unsafe flags under Safe Haskell. Tuple elements are:
1264 --     * name of the flag
1265 --     * function to get srcspan that enabled the flag
1266 --     * function to test if the flag is on
1267 --     * function to turn the flag off
1268 unsafeFlags :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]
1269 unsafeFlags = [("-XGeneralizedNewtypeDeriving", newDerivOnLoc,
1270                    xopt Opt_GeneralizedNewtypeDeriving,
1271                    flip xopt_unset Opt_GeneralizedNewtypeDeriving),
1272                ("-XTemplateHaskell", thOnLoc,
1273                    xopt Opt_TemplateHaskell,
1274                    flip xopt_unset Opt_TemplateHaskell)]
1275
1276 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
1277 getOpts :: DynFlags             -- ^ 'DynFlags' to retrieve the options from
1278         -> (DynFlags -> [a])    -- ^ Relevant record accessor: one of the @opt_*@ accessors
1279         -> [a]                  -- ^ Correctly ordered extracted options
1280 getOpts dflags opts = reverse (opts dflags)
1281         -- We add to the options from the front, so we need to reverse the list
1282
1283 -- | Gets the verbosity flag for the current verbosity level. This is fed to
1284 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
1285 getVerbFlags :: DynFlags -> [String]
1286 getVerbFlags dflags
1287   | verbosity dflags >= 4 = ["-v"]
1288   | otherwise             = []
1289
1290 setObjectDir, setHiDir, setStubDir, setDumpDir, setOutputDir,
1291          setDylibInstallName,
1292          setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
1293          setPgmP, addOptl, addOptP,
1294          addCmdlineFramework, addHaddockOpts, addGhciScript, 
1295          setInteractivePrint
1296    :: String -> DynFlags -> DynFlags
1297 setOutputFile, setOutputHi, setDumpPrefixForce
1298    :: Maybe String -> DynFlags -> DynFlags
1299
1300 setObjectDir  f d = d{ objectDir  = Just f}
1301 setHiDir      f d = d{ hiDir      = Just f}
1302 setStubDir    f d = d{ stubDir    = Just f, includePaths = f : includePaths d }
1303   -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
1304   -- \#included from the .hc file when compiling via C (i.e. unregisterised
1305   -- builds).
1306 setDumpDir    f d = d{ dumpDir    = Just f}
1307 setOutputDir  f = setObjectDir f . setHiDir f . setStubDir f . setDumpDir f
1308 setDylibInstallName  f d = d{ dylibInstallName = Just f}
1309
1310 setObjectSuf  f d = d{ objectSuf  = f}
1311 setHiSuf      f d = d{ hiSuf      = f}
1312 setHcSuf      f d = d{ hcSuf      = f}
1313
1314 setOutputFile f d = d{ outputFile = f}
1315 setOutputHi   f d = d{ outputHi   = f}
1316
1317 addPluginModuleName :: String -> DynFlags -> DynFlags
1318 addPluginModuleName name d = d { pluginModNames = (mkModuleName name) : (pluginModNames d) }
1319
1320 addPluginModuleNameOption :: String -> DynFlags -> DynFlags
1321 addPluginModuleNameOption optflag d = d { pluginModNameOpts = (mkModuleName m, option) : (pluginModNameOpts d) }
1322   where (m, rest) = break (== ':') optflag
1323         option = case rest of
1324           [] -> "" -- should probably signal an error
1325           (_:plug_opt) -> plug_opt -- ignore the ':' from break
1326
1327 parseDynLibLoaderMode f d =
1328  case splitAt 8 f of
1329    ("deploy", "")       -> d{ dynLibLoader = Deployable }
1330    ("sysdep", "")       -> d{ dynLibLoader = SystemDependent }
1331    _                    -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
1332
1333 setDumpPrefixForce f d = d { dumpPrefixForce = f}
1334
1335 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
1336 -- Config.hs should really use Option.
1337 setPgmP   f = let (pgm:args) = words f in alterSettings (\s -> s { sPgm_P   = (pgm, map Option args)})
1338 addOptl   f = alterSettings (\s -> s { sOpt_l   = f : sOpt_l s})
1339 addOptP   f = alterSettings (\s -> s { sOpt_P   = f : sOpt_P s})
1340
1341
1342 setDepMakefile :: FilePath -> DynFlags -> DynFlags
1343 setDepMakefile f d = d { depMakefile = deOptDep f }
1344
1345 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
1346 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
1347
1348 addDepExcludeMod :: String -> DynFlags -> DynFlags
1349 addDepExcludeMod m d
1350     = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
1351
1352 addDepSuffix :: FilePath -> DynFlags -> DynFlags
1353 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
1354
1355 -- XXX Legacy code:
1356 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
1357 -- we need to strip the "-optdep" off of the arg
1358 deOptDep :: String -> String
1359 deOptDep x = case stripPrefix "-optdep" x of
1360              Just rest -> rest
1361              Nothing -> x
1362
1363 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
1364
1365 addHaddockOpts f d = d{ haddockOptions = Just f}
1366
1367 addGhciScript f d = d{ ghciScripts = f : ghciScripts d}
1368
1369 setInteractivePrint f d = d{ interactivePrint = Just f}
1370
1371 -- -----------------------------------------------------------------------------
1372 -- Command-line options
1373
1374 -- | When invoking external tools as part of the compilation pipeline, we
1375 -- pass these a sequence of options on the command-line. Rather than
1376 -- just using a list of Strings, we use a type that allows us to distinguish
1377 -- between filepaths and 'other stuff'. The reason for this is that
1378 -- this type gives us a handle on transforming filenames, and filenames only,
1379 -- to whatever format they're expected to be on a particular platform.
1380 data Option
1381  = FileOption -- an entry that _contains_ filename(s) / filepaths.
1382               String  -- a non-filepath prefix that shouldn't be
1383                       -- transformed (e.g., "/out=")
1384               String  -- the filepath/filename portion
1385  | Option     String
1386  deriving ( Eq )
1387
1388 showOpt :: Option -> String
1389 showOpt (FileOption pre f) = pre ++ f
1390 showOpt (Option s)  = s
1391
1392 -----------------------------------------------------------------------------
1393 -- Setting the optimisation level
1394
1395 updOptLevel :: Int -> DynFlags -> DynFlags
1396 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
1397 updOptLevel n dfs
1398   = dfs2{ optLevel = final_n }
1399   where
1400    final_n = max 0 (min 2 n)    -- Clamp to 0 <= n <= 2
1401    dfs1 = foldr (flip dopt_unset) dfs  remove_dopts
1402    dfs2 = foldr (flip dopt_set)   dfs1 extra_dopts
1403
1404    extra_dopts  = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
1405    remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
1406
1407 -- -----------------------------------------------------------------------------
1408 -- StgToDo:  abstraction of stg-to-stg passes to run.
1409
1410 data StgToDo
1411   = StgDoMassageForProfiling  -- should be (next to) last
1412   -- There's also setStgVarInfo, but its absolute "lastness"
1413   -- is so critical that it is hardwired in (no flag).
1414   | D_stg_stats
1415   | D_stg_unshare
1416
1417 getStgToDo :: DynFlags -> [StgToDo]
1418 getStgToDo dflags
1419   = todo3
1420   where
1421         stg_stats = dopt Opt_StgStats dflags
1422         stg_unshare = dopt Opt_StgUnshare dflags
1423
1424         todo1 = if stg_unshare then [D_stg_unshare] else []
1425         todo2 = if stg_stats then D_stg_stats : todo1 else todo1
1426
1427         todo3 | WayProf `elem` wayNames dflags
1428               = StgDoMassageForProfiling : todo2
1429               | otherwise
1430               = todo2
1431
1432 {- **********************************************************************
1433 %*                                                                      *
1434                 DynFlags parser
1435 %*                                                                      *
1436 %********************************************************************* -}
1437
1438 -- -----------------------------------------------------------------------------
1439 -- Parsing the dynamic flags.
1440
1441
1442 -- | Parse dynamic flags from a list of command line arguments.  Returns the
1443 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1444 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1445 -- flags or missing arguments).
1446 parseDynamicFlagsCmdLine :: Monad m => DynFlags -> [Located String]
1447                          -> m (DynFlags, [Located String], [Located String])
1448                             -- ^ Updated 'DynFlags', left-over arguments, and
1449                             -- list of warnings.
1450 parseDynamicFlagsCmdLine = parseDynamicFlagsFull flagsAll True
1451
1452
1453 -- | Like 'parseDynamicFlagsCmdLine' but does not allow the package flags
1454 -- (-package, -hide-package, -ignore-package, -hide-all-packages, -package-db).
1455 -- Used to parse flags set in a modules pragma.
1456 parseDynamicFilePragma :: Monad m => DynFlags -> [Located String]
1457                        -> m (DynFlags, [Located String], [Located String])
1458                           -- ^ Updated 'DynFlags', left-over arguments, and
1459                           -- list of warnings.
1460 parseDynamicFilePragma = parseDynamicFlagsFull flagsDynamic False
1461
1462
1463 -- | Parses the dynamically set flags for GHC. This is the most general form of
1464 -- the dynamic flag parser that the other methods simply wrap. It allows
1465 -- saying which flags are valid flags and indicating if we are parsing
1466 -- arguments from the command line or from a file pragma.
1467 parseDynamicFlagsFull :: Monad m
1468                   => [Flag (CmdLineP DynFlags)]    -- ^ valid flags to match against
1469                   -> Bool                          -- ^ are the arguments from the command line?
1470                   -> DynFlags                      -- ^ current dynamic flags
1471                   -> [Located String]              -- ^ arguments to parse
1472                   -> m (DynFlags, [Located String], [Located String])
1473 parseDynamicFlagsFull activeFlags cmdline dflags0 args = do
1474   -- XXX Legacy support code
1475   -- We used to accept things like
1476   --     optdep-f  -optdepdepend
1477   --     optdep-f  -optdep depend
1478   --     optdep -f -optdepdepend
1479   --     optdep -f -optdep depend
1480   -- but the spaces trip up proper argument handling. So get rid of them.
1481   let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1482       f (x : xs) = x : f xs
1483       f xs = xs
1484       args' = f args
1485
1486   let ((leftover, errs, warns), dflags1)
1487           = runCmdLine (processArgs activeFlags args') dflags0
1488   when (not (null errs)) $ ghcError $ errorsToGhcException errs
1489
1490   -- check for disabled flags in safe haskell
1491   let (dflags2, sh_warns) = safeFlagCheck cmdline dflags1
1492
1493   return (dflags2, leftover, sh_warns ++ warns)
1494
1495
1496 -- | Check (and potentially disable) any extensions that aren't allowed
1497 -- in safe mode.
1498 --
1499 -- The bool is to indicate if we are parsing command line flags (false means
1500 -- file pragma). This allows us to generate better warnings.
1501 safeFlagCheck :: Bool -> DynFlags -> (DynFlags, [Located String])
1502 safeFlagCheck _  dflags | not (safeLanguageOn dflags || safeInferOn dflags)
1503                         = (dflags, [])
1504
1505 -- safe or safe-infer ON
1506 safeFlagCheck cmdl dflags =
1507     case safeLanguageOn dflags of
1508         True -> (dflags', warns)
1509
1510         -- throw error if -fpackage-trust by itself with no safe haskell flag
1511         False | not cmdl && packageTrustOn dflags
1512               -> (dopt_unset dflags' Opt_PackageTrust,
1513                   [L (pkgTrustOnLoc dflags') $
1514                       "-fpackage-trust ignored;" ++
1515                       " must be specified with a Safe Haskell flag"]
1516                   )
1517
1518         False | null warns && safeInfOk
1519               -> (dflags', [])
1520
1521               | otherwise
1522               -> (dflags' { safeHaskell = Sf_None }, [])
1523                 -- Have we inferred Unsafe?
1524                 -- See Note [HscMain . Safe Haskell Inference]
1525     where
1526         -- TODO: Can we do better than this for inference?
1527         safeInfOk = not $ xopt Opt_OverlappingInstances dflags
1528
1529         (dflags', warns) = foldl check_method (dflags, []) unsafeFlags
1530
1531         check_method (df, warns) (str,loc,test,fix)
1532             | test df   = (apFix fix df, warns ++ safeFailure (loc dflags) str)
1533             | otherwise = (df, warns)
1534
1535         apFix f = if safeInferOn dflags then id else f
1536
1537         safeFailure loc str 
1538            = [L loc $ str ++ " is not allowed in Safe Haskell; ignoring " ++ str]
1539
1540 {- **********************************************************************
1541 %*                                                                      *
1542                 DynFlags specifications
1543 %*                                                                      *
1544 %********************************************************************* -}
1545
1546 -- | All dynamic flags option strings. These are the user facing strings for
1547 -- enabling and disabling options.
1548 allFlags :: [String]
1549 allFlags = map ('-':) $
1550            [ flagName flag | flag <- dynamic_flags ++ package_flags, ok (flagOptKind flag) ] ++
1551            map ("fno-"++) fflags ++
1552            map ("f"++) fflags ++
1553            map ("X"++) supportedExtensions
1554     where ok (PrefixPred _ _) = False
1555           ok _   = True
1556           fflags = fflags0 ++ fflags1 ++ fflags2
1557           fflags0 = [ name | (name, _, _) <- fFlags ]
1558           fflags1 = [ name | (name, _, _) <- fWarningFlags ]
1559           fflags2 = [ name | (name, _, _) <- fLangFlags ]
1560
1561 {-
1562  - Below we export user facing symbols for GHC dynamic flags for use with the
1563  - GHC API.
1564  -}
1565
1566 -- All dynamic flags present in GHC.
1567 flagsAll :: [Flag (CmdLineP DynFlags)]
1568 flagsAll     = package_flags ++ dynamic_flags
1569
1570 -- All dynamic flags, minus package flags, present in GHC.
1571 flagsDynamic :: [Flag (CmdLineP DynFlags)]
1572 flagsDynamic = dynamic_flags
1573
1574 -- ALl package flags present in GHC.
1575 flagsPackage :: [Flag (CmdLineP DynFlags)]
1576 flagsPackage = package_flags
1577
1578 --------------- The main flags themselves ------------------
1579 dynamic_flags :: [Flag (CmdLineP DynFlags)]
1580 dynamic_flags = [
1581     Flag "n"        (NoArg (addWarn "The -n flag is deprecated and no longer has any effect"))
1582   , Flag "cpp"      (NoArg (setExtensionFlag Opt_Cpp))
1583   , Flag "F"        (NoArg (setDynFlag Opt_Pp))
1584   , Flag "#include"
1585          (HasArg (\s -> do addCmdlineHCInclude s
1586                            addWarn "-#include and INCLUDE pragmas are deprecated: They no longer have any effect"))
1587   , Flag "v"        (OptIntSuffix setVerbosity)
1588
1589         ------- Specific phases  --------------------------------------------
1590     -- need to appear before -pgmL to be parsed as LLVM flags.
1591   , Flag "pgmlo"          (hasArg (\f -> alterSettings (\s -> s { sPgm_lo  = (f,[])})))
1592   , Flag "pgmlc"          (hasArg (\f -> alterSettings (\s -> s { sPgm_lc  = (f,[])})))
1593   , Flag "pgmL"           (hasArg (\f -> alterSettings (\s -> s { sPgm_L   = f})))
1594   , Flag "pgmP"           (hasArg setPgmP)
1595   , Flag "pgmF"           (hasArg (\f -> alterSettings (\s -> s { sPgm_F   = f})))
1596   , Flag "pgmc"           (hasArg (\f -> alterSettings (\s -> s { sPgm_c   = (f,[])})))
1597   , Flag "pgmm"           (HasArg (\_ -> addWarn "The -pgmm flag does nothing; it will be removed in a future GHC release"))
1598   , Flag "pgms"           (hasArg (\f -> alterSettings (\s -> s { sPgm_s   = (f,[])})))
1599   , Flag "pgma"           (hasArg (\f -> alterSettings (\s -> s { sPgm_a   = (f,[])})))
1600   , Flag "pgml"           (hasArg (\f -> alterSettings (\s -> s { sPgm_l   = (f,[])})))
1601   , Flag "pgmdll"         (hasArg (\f -> alterSettings (\s -> s { sPgm_dll = (f,[])})))
1602   , Flag "pgmwindres"     (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f})))
1603
1604     -- need to appear before -optl/-opta to be parsed as LLVM flags.
1605   , Flag "optlo"          (hasArg (\f -> alterSettings (\s -> s { sOpt_lo  = f : sOpt_lo s})))
1606   , Flag "optlc"          (hasArg (\f -> alterSettings (\s -> s { sOpt_lc  = f : sOpt_lc s})))
1607   , Flag "optL"           (hasArg (\f -> alterSettings (\s -> s { sOpt_L   = f : sOpt_L s})))
1608   , Flag "optP"           (hasArg addOptP)
1609   , Flag "optF"           (hasArg (\f -> alterSettings (\s -> s { sOpt_F   = f : sOpt_F s})))
1610   , Flag "optc"           (hasArg (\f -> alterSettings (\s -> s { sOpt_c   = f : sOpt_c s})))
1611   , Flag "optm"           (HasArg (\_ -> addWarn "The -optm flag does nothing; it will be removed in a future GHC release"))
1612   , Flag "opta"           (hasArg (\f -> alterSettings (\s -> s { sOpt_a   = f : sOpt_a s})))
1613   , Flag "optl"           (hasArg addOptl)
1614   , Flag "optwindres"     (hasArg (\f -> alterSettings (\s -> s { sOpt_windres = f : sOpt_windres s})))
1615
1616   , Flag "split-objs"
1617          (NoArg (if can_split
1618                  then setDynFlag Opt_SplitObjs
1619                  else addWarn "ignoring -fsplit-objs"))
1620
1621         -------- ghc -M -----------------------------------------------------
1622   , Flag "dep-suffix"     (hasArg addDepSuffix)
1623   , Flag "optdep-s"       (hasArgDF addDepSuffix "Use -dep-suffix instead")
1624   , Flag "dep-makefile"   (hasArg setDepMakefile)
1625   , Flag "optdep-f"       (hasArgDF setDepMakefile "Use -dep-makefile instead")
1626   , Flag "optdep-w"       (NoArg  (deprecate "doesn't do anything"))
1627   , Flag "include-pkg-deps"         (noArg (setDepIncludePkgDeps True))
1628   , Flag "optdep--include-prelude"  (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1629   , Flag "optdep--include-pkg-deps" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1630   , Flag "exclude-module"           (hasArg addDepExcludeMod)
1631   , Flag "optdep--exclude-module"   (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1632   , Flag "optdep-x"                 (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1633
1634         -------- Linking ----------------------------------------------------
1635   , Flag "no-link"            (noArg (\d -> d{ ghcLink=NoLink }))
1636   , Flag "shared"             (noArg (\d -> d{ ghcLink=LinkDynLib }))
1637   , Flag "dynload"            (hasArg parseDynLibLoaderMode)
1638   , Flag "dylib-install-name" (hasArg setDylibInstallName)
1639
1640         ------- Libraries ---------------------------------------------------
1641   , Flag "L"   (Prefix addLibraryPath)
1642   , Flag "l"   (hasArg (addOptl . ("-l" ++)))
1643
1644         ------- Frameworks --------------------------------------------------
1645         -- -framework-path should really be -F ...
1646   , Flag "framework-path" (HasArg addFrameworkPath)
1647   , Flag "framework"      (hasArg addCmdlineFramework)
1648
1649         ------- Output Redirection ------------------------------------------
1650   , Flag "odir"              (hasArg setObjectDir)
1651   , Flag "o"                 (sepArg (setOutputFile . Just))
1652   , Flag "ohi"               (hasArg (setOutputHi . Just ))
1653   , Flag "osuf"              (hasArg setObjectSuf)
1654   , Flag "hcsuf"             (hasArg setHcSuf)
1655   , Flag "hisuf"             (hasArg setHiSuf)
1656   , Flag "hidir"             (hasArg setHiDir)
1657   , Flag "tmpdir"            (hasArg setTmpDir)
1658   , Flag "stubdir"           (hasArg setStubDir)
1659   , Flag "dumpdir"           (hasArg setDumpDir)
1660   , Flag "outputdir"         (hasArg setOutputDir)
1661   , Flag "ddump-file-prefix" (hasArg (setDumpPrefixForce . Just))
1662
1663         ------- Keeping temporary files -------------------------------------
1664      -- These can be singular (think ghc -c) or plural (think ghc --make)
1665   , Flag "keep-hc-file"     (NoArg (setDynFlag Opt_KeepHcFiles))
1666   , Flag "keep-hc-files"    (NoArg (setDynFlag Opt_KeepHcFiles))
1667   , Flag "keep-s-file"      (NoArg (setDynFlag Opt_KeepSFiles))
1668   , Flag "keep-s-files"     (NoArg (setDynFlag Opt_KeepSFiles))
1669   , Flag "keep-raw-s-file"  (NoArg (addWarn "The -keep-raw-s-file flag does nothing; it will be removed in a future GHC release"))
1670   , Flag "keep-raw-s-files" (NoArg (addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1671   , Flag "keep-llvm-file"   (NoArg (do setObjTarget HscLlvm
1672                                        setDynFlag Opt_KeepLlvmFiles))
1673   , Flag "keep-llvm-files"  (NoArg (do setObjTarget HscLlvm
1674                                        setDynFlag Opt_KeepLlvmFiles))
1675      -- This only makes sense as plural
1676   , Flag "keep-tmp-files"   (NoArg (setDynFlag Opt_KeepTmpFiles))
1677
1678         ------- Miscellaneous ----------------------------------------------
1679   , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages))
1680   , Flag "no-hs-main"     (NoArg (setDynFlag Opt_NoHsMain))
1681   , Flag "with-rtsopts"   (HasArg setRtsOpts)
1682   , Flag "rtsopts"        (NoArg (setRtsOptsEnabled RtsOptsAll))
1683   , Flag "rtsopts=all"    (NoArg (setRtsOptsEnabled RtsOptsAll))
1684   , Flag "rtsopts=some"   (NoArg (setRtsOptsEnabled RtsOptsSafeOnly))
1685   , Flag "rtsopts=none"   (NoArg (setRtsOptsEnabled RtsOptsNone))
1686   , Flag "no-rtsopts"     (NoArg (setRtsOptsEnabled RtsOptsNone))
1687   , Flag "main-is"        (SepArg setMainIs)
1688   , Flag "haddock"        (NoArg (setDynFlag Opt_Haddock))
1689   , Flag "haddock-opts"   (hasArg addHaddockOpts)
1690   , Flag "hpcdir"         (SepArg setOptHpcDir)
1691   , Flag "ghci-script"    (hasArg addGhciScript)
1692   , Flag "interactive-print" (hasArg setInteractivePrint)
1693         ------- recompilation checker --------------------------------------
1694   , Flag "recomp"         (NoArg (do unSetDynFlag Opt_ForceRecomp
1695                                      deprecate "Use -fno-force-recomp instead"))
1696   , Flag "no-recomp"      (NoArg (do setDynFlag Opt_ForceRecomp
1697                                      deprecate "Use -fforce-recomp instead"))
1698
1699         ------ HsCpp opts ---------------------------------------------------
1700   , Flag "D"              (AnySuffix (upd . addOptP))
1701   , Flag "U"              (AnySuffix (upd . addOptP))
1702
1703         ------- Include/Import Paths ----------------------------------------
1704   , Flag "I"              (Prefix    addIncludePath)
1705   , Flag "i"              (OptPrefix addImportPath)
1706
1707         ------ Output style options -----------------------------------------
1708   , Flag "dppr-user-length" (intSuffix (\n d -> d{ pprUserLength = n }))
1709   , Flag "dppr-cols"        (intSuffix (\n d -> d{ pprCols = n }))
1710   , Flag "dtrace-level"     (intSuffix (\n d -> d{ traceLevel = n }))
1711
1712         ------ Debugging ----------------------------------------------------
1713   , Flag "dstg-stats"     (NoArg (setDynFlag Opt_StgStats))
1714   , Flag "dstg-unshare"     (NoArg (setDynFlag Opt_StgUnshare))
1715
1716   , Flag "ddump-cmm"               (setDumpFlag Opt_D_dump_cmm)
1717   , Flag "ddump-raw-cmm"           (setDumpFlag Opt_D_dump_raw_cmm)
1718   , Flag "ddump-cmmz"              (setDumpFlag Opt_D_dump_cmmz)
1719   , Flag "ddump-cmmz-cfg"          (setDumpFlag Opt_D_dump_cmmz_cbe)
1720   , Flag "ddump-cmmz-cbe"          (setDumpFlag Opt_D_dump_cmmz_cbe)
1721   , Flag "ddump-cmmz-spills"       (setDumpFlag Opt_D_dump_cmmz_spills)
1722   , Flag "ddump-cmmz-proc"         (setDumpFlag Opt_D_dump_cmmz_proc)
1723   , Flag "ddump-cmmz-rewrite"      (setDumpFlag Opt_D_dump_cmmz_rewrite)
1724   , Flag "ddump-cmmz-dead"         (setDumpFlag Opt_D_dump_cmmz_dead)
1725   , Flag "ddump-cmmz-stub"         (setDumpFlag Opt_D_dump_cmmz_stub)
1726   , Flag "ddump-cmmz-sp"           (setDumpFlag Opt_D_dump_cmmz_sp)
1727   , Flag "ddump-cmmz-procmap"      (setDumpFlag Opt_D_dump_cmmz_procmap)
1728   , Flag "ddump-cmmz-split"        (setDumpFlag Opt_D_dump_cmmz_split)
1729   , Flag "ddump-cmmz-lower"        (setDumpFlag Opt_D_dump_cmmz_lower)
1730   , Flag "ddump-cmmz-info"         (setDumpFlag Opt_D_dump_cmmz_info)
1731   , Flag "ddump-cmmz-cafs"         (setDumpFlag Opt_D_dump_cmmz_cafs)
1732   , Flag "ddump-core-stats"        (setDumpFlag Opt_D_dump_core_stats)
1733   , Flag "ddump-cps-cmm"           (setDumpFlag Opt_D_dump_cps_cmm)
1734   , Flag "ddump-cvt-cmm"           (setDumpFlag Opt_D_dump_cvt_cmm)
1735   , Flag "ddump-asm"               (setDumpFlag Opt_D_dump_asm)
1736   , Flag "ddump-asm-native"        (setDumpFlag Opt_D_dump_asm_native)
1737   , Flag "ddump-asm-liveness"      (setDumpFlag Opt_D_dump_asm_liveness)
1738   , Flag "ddump-asm-coalesce"      (setDumpFlag Opt_D_dump_asm_coalesce)
1739   , Flag "ddump-asm-regalloc"      (setDumpFlag Opt_D_dump_asm_regalloc)
1740   , Flag "ddump-asm-conflicts"     (setDumpFlag Opt_D_dump_asm_conflicts)
1741   , Flag "ddump-asm-regalloc-stages" (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1742   , Flag "ddump-asm-stats"         (setDumpFlag Opt_D_dump_asm_stats)
1743   , Flag "ddump-asm-expanded"      (setDumpFlag Opt_D_dump_asm_expanded)
1744   , Flag "ddump-llvm"              (NoArg (do setObjTarget HscLlvm
1745                                               setDumpFlag' Opt_D_dump_llvm))
1746   , Flag "ddump-cpranal"           (setDumpFlag Opt_D_dump_cpranal)
1747   , Flag "ddump-deriv"             (setDumpFlag Opt_D_dump_deriv)
1748   , Flag "ddump-ds"                (setDumpFlag Opt_D_dump_ds)
1749   , Flag "ddump-flatC"             (setDumpFlag Opt_D_dump_flatC)
1750   , Flag "ddump-foreign"           (setDumpFlag Opt_D_dump_foreign)
1751   , Flag "ddump-inlinings"         (setDumpFlag Opt_D_dump_inlinings)
1752   , Flag "ddump-rule-firings"      (setDumpFlag Opt_D_dump_rule_firings)
1753   , Flag "ddump-rule-rewrites"     (setDumpFlag Opt_D_dump_rule_rewrites)
1754   , Flag "ddump-occur-anal"        (setDumpFlag Opt_D_dump_occur_anal)
1755   , Flag "ddump-parsed"            (setDumpFlag Opt_D_dump_parsed)
1756   , Flag "ddump-rn"                (setDumpFlag Opt_D_dump_rn)
1757   , Flag "ddump-core-pipeline"     (setDumpFlag Opt_D_dump_core_pipeline)
1758   , Flag "ddump-simpl"             (setDumpFlag Opt_D_dump_simpl)
1759   , Flag "ddump-simpl-iterations"  (setDumpFlag Opt_D_dump_simpl_iterations)
1760   , Flag "ddump-simpl-phases"      (OptPrefix setDumpSimplPhases)
1761   , Flag "ddump-spec"              (setDumpFlag Opt_D_dump_spec)
1762   , Flag "ddump-prep"              (setDumpFlag Opt_D_dump_prep)
1763   , Flag "ddump-stg"               (setDumpFlag Opt_D_dump_stg)
1764   , Flag "ddump-stranal"           (setDumpFlag Opt_D_dump_stranal)
1765   , Flag "ddump-tc"                (setDumpFlag Opt_D_dump_tc)
1766   , Flag "ddump-types"             (setDumpFlag Opt_D_dump_types)
1767   , Flag "ddump-rules"             (setDumpFlag Opt_D_dump_rules)
1768   , Flag "ddump-cse"               (setDumpFlag Opt_D_dump_cse)
1769   , Flag "ddump-worker-wrapper"    (setDumpFlag Opt_D_dump_worker_wrapper)
1770   , Flag "ddump-rn-trace"          (setDumpFlag Opt_D_dump_rn_trace)
1771   , Flag "ddump-if-trace"          (setDumpFlag Opt_D_dump_if_trace)
1772   , Flag "ddump-cs-trace"          (setDumpFlag Opt_D_dump_cs_trace)
1773   , Flag "ddump-tc-trace"          (setDumpFlag Opt_D_dump_tc_trace)
1774   , Flag "ddump-vt-trace"          (setDumpFlag Opt_D_dump_vt_trace)
1775   , Flag "ddump-splices"           (setDumpFlag Opt_D_dump_splices)
1776   , Flag "ddump-rn-stats"          (setDumpFlag Opt_D_dump_rn_stats)
1777   , Flag "ddump-opt-cmm"           (setDumpFlag Opt_D_dump_opt_cmm)
1778   , Flag "ddump-simpl-stats"       (setDumpFlag Opt_D_dump_simpl_stats)
1779   , Flag "ddump-bcos"              (setDumpFlag Opt_D_dump_BCOs)
1780   , Flag "dsource-stats"           (setDumpFlag Opt_D_source_stats)
1781   , Flag "dverbose-core2core"      (NoArg (do setVerbosity (Just 2)
1782                                               setVerboseCore2Core))
1783   , Flag "dverbose-stg2stg"        (setDumpFlag Opt_D_verbose_stg2stg)
1784   , Flag "ddump-hi"                (setDumpFlag Opt_D_dump_hi)
1785   , Flag "ddump-minimal-imports"   (setDumpFlag Opt_D_dump_minimal_imports)
1786   , Flag "ddump-vect"              (setDumpFlag Opt_D_dump_vect)
1787   , Flag "ddump-avoid-vect"        (setDumpFlag Opt_D_dump_avoid_vect)
1788   , Flag "ddump-hpc"               (setDumpFlag Opt_D_dump_ticked) -- back compat
1789   , Flag "ddump-ticked"            (setDumpFlag Opt_D_dump_ticked)
1790   , Flag "ddump-mod-cycles"        (setDumpFlag Opt_D_dump_mod_cycles)
1791   , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1792   , Flag "ddump-to-file"           (setDumpFlag Opt_DumpToFile)
1793   , Flag "ddump-hi-diffs"          (setDumpFlag Opt_D_dump_hi_diffs)
1794   , Flag "ddump-rtti"              (setDumpFlag Opt_D_dump_rtti)
1795   , Flag "dcore-lint"              (NoArg (setDynFlag Opt_DoCoreLinting))
1796   , Flag "dstg-lint"               (NoArg (setDynFlag Opt_DoStgLinting))
1797   , Flag "dcmm-lint"               (NoArg (setDynFlag Opt_DoCmmLinting))
1798   , Flag "dasm-lint"               (NoArg (setDynFlag Opt_DoAsmLinting))
1799   , Flag "dshow-passes"            (NoArg (do forceRecompile
1800                                               setVerbosity $ Just 2))
1801   , Flag "dfaststring-stats"       (NoArg (setDynFlag Opt_D_faststring_stats))
1802   , Flag "dno-llvm-mangler"        (NoArg (setDynFlag Opt_NoLlvmMangler)) -- hidden flag
1803
1804         ------ Machine dependant (-m<blah>) stuff ---------------------------
1805
1806   , Flag "monly-2-regs" (NoArg (addWarn "The -monly-2-regs flag does nothing; it will be removed in a future GHC release"))
1807   , Flag "monly-3-regs" (NoArg (addWarn "The -monly-3-regs flag does nothing; it will be removed in a future GHC release"))
1808   , Flag "monly-4-regs" (NoArg (addWarn "The -monly-4-regs flag does nothing; it will be removed in a future GHC release"))
1809   , Flag "msse2"        (NoArg (setDynFlag Opt_SSE2))
1810   , Flag "msse4.2"      (NoArg (setDynFlag Opt_SSE4_2))
1811
1812      ------ Warning opts -------------------------------------------------
1813   , Flag "W"      (NoArg (mapM_ setWarningFlag minusWOpts))
1814   , Flag "Werror" (NoArg (setDynFlag           Opt_WarnIsError))
1815   , Flag "Wwarn"  (NoArg (unSetDynFlag         Opt_WarnIsError))
1816   , Flag "Wall"   (NoArg (mapM_ setWarningFlag minusWallOpts))
1817   , Flag "Wnot"   (NoArg (do upd (\dfs -> dfs {warningFlags = IntSet.empty})
1818                              deprecate "Use -w instead"))
1819   , Flag "w"      (NoArg (upd (\dfs -> dfs {warningFlags = IntSet.empty})))
1820
1821         ------ Plugin flags ------------------------------------------------
1822   , Flag "fplugin-opt" (hasArg addPluginModuleNameOption)
1823   , Flag "fplugin"     (hasArg addPluginModuleName)
1824
1825         ------ Optimisation flags ------------------------------------------
1826   , Flag "O"      (noArgM (setOptLevel 1))
1827   , Flag "Onot"   (noArgM (\dflags -> do deprecate "Use -O0 instead"
1828                                          setOptLevel 0 dflags))
1829   , Flag "Odph"   (noArgM setDPHOpt)
1830   , Flag "O"      (optIntSuffixM (\mb_n -> setOptLevel (mb_n `orElse` 1)))
1831                 -- If the number is missing, use 1
1832
1833   , Flag "fsimplifier-phases"          (intSuffix (\n d -> d{ simplPhases = n }))
1834   , Flag "fmax-simplifier-iterations"  (intSuffix (\n d -> d{ maxSimplIterations = n }))
1835   , Flag "fsimpl-tick-factor"          (intSuffix (\n d -> d{ simplTickFactor = n }))
1836   , Flag "fspec-constr-threshold"      (intSuffix (\n d -> d{ specConstrThreshold = Just n }))
1837   , Flag "fno-spec-constr-threshold"   (noArg (\d -> d{ specConstrThreshold = Nothing }))
1838   , Flag "fspec-constr-count"          (intSuffix (\n d -> d{ specConstrCount = Just n }))
1839   , Flag "fno-spec-constr-count"       (noArg (\d -> d{ specConstrCount = Nothing }))
1840   , Flag "fliberate-case-threshold"    (intSuffix (\n d -> d{ liberateCaseThreshold = Just n }))
1841   , Flag "fno-liberate-case-threshold" (noArg (\d -> d{ liberateCaseThreshold = Nothing }))
1842   , Flag "frule-check"                 (sepArg (\s d -> d{ ruleCheck = Just s }))
1843   , Flag "fcontext-stack"              (intSuffix (\n d -> d{ ctxtStkDepth = n }))
1844   , Flag "fstrictness-before"          (intSuffix (\n d -> d{ strictnessBefore = n : strictnessBefore d }))
1845   , Flag "ffloat-lam-args"             (intSuffix (\n d -> d{ floatLamArgs = Just n }))
1846   , Flag "ffloat-all-lams"             (noArg (\d -> d{ floatLamArgs = Nothing }))
1847
1848         ------ Profiling ----------------------------------------------------
1849
1850         -- OLD profiling flags
1851   , Flag "auto-all"              (noArg (\d -> d { profAuto = ProfAutoAll } ))
1852   , Flag "no-auto-all"           (noArg (\d -> d { profAuto = NoProfAuto } ))
1853   , Flag "auto"                  (noArg (\d -> d { profAuto = ProfAutoExports } ))
1854   , Flag "no-auto"               (noArg (\d -> d { profAuto = NoProfAuto } ))
1855   , Flag "caf-all"               (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1856   , Flag "no-caf-all"            (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1857
1858         -- NEW profiling flags
1859   , Flag "fprof-auto"             (noArg (\d -> d { profAuto = ProfAutoAll } ))
1860   , Flag "fprof-auto-top"         (noArg (\d -> d { profAuto = ProfAutoTop } ))
1861   , Flag "fprof-auto-exported"    (noArg (\d -> d { profAuto = ProfAutoExports } ))
1862   , Flag "fprof-auto-calls"       (noArg (\d -> d { profAuto = ProfAutoCalls } ))
1863   , Flag "fno-prof-auto"          (noArg (\d -> d { profAuto = NoProfAuto } ))
1864
1865         ------ Compiler flags -----------------------------------------------
1866
1867   , Flag "fasm"             (NoArg (setObjTarget HscAsm))
1868   , Flag "fvia-c"           (NoArg
1869          (addWarn "The -fvia-c flag does nothing; it will be removed in a future GHC release"))
1870   , Flag "fvia-C"           (NoArg
1871          (addWarn "The -fvia-C flag does nothing; it will be removed in a future GHC release"))
1872   , Flag "fllvm"            (NoArg (setObjTarget HscLlvm))
1873
1874   , Flag "fno-code"         (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1875                                        setTarget HscNothing))
1876   , Flag "fbyte-code"       (NoArg (setTarget HscInterpreted))
1877   , Flag "fobject-code"     (NoArg (setTargetWithPlatform defaultHscTarget))
1878   , Flag "fglasgow-exts"    (NoArg (enableGlasgowExts >> deprecate "Use individual extensions instead"))
1879   , Flag "fno-glasgow-exts" (NoArg (disableGlasgowExts >> deprecate "Use individual extensions instead"))
1880
1881         ------ Safe Haskell flags -------------------------------------------
1882   , Flag "fpackage-trust"   (NoArg setPackageTrust)
1883   , Flag "fno-safe-infer"   (NoArg (setSafeHaskell Sf_None))
1884   , Flag "fPIC"             (NoArg setFPIC)
1885   , Flag "fno-PIC"          (NoArg unSetFPIC)
1886  ]
1887  ++ map (mkFlag turnOn  ""     setDynFlag  ) negatableFlags
1888  ++ map (mkFlag turnOff "no-"  unSetDynFlag) negatableFlags
1889  ++ map (mkFlag turnOn  "d"    setDynFlag  ) dFlags
1890  ++ map (mkFlag turnOff "dno-" unSetDynFlag) dFlags
1891  ++ map (mkFlag turnOn  "f"    setDynFlag  ) fFlags
1892  ++ map (mkFlag turnOff "fno-" unSetDynFlag) fFlags
1893  ++ map (mkFlag turnOn  "f"    setWarningFlag  ) fWarningFlags
1894  ++ map (mkFlag turnOff "fno-" unSetWarningFlag) fWarningFlags
1895  ++ map (mkFlag turnOn  "f"    setExtensionFlag  ) fLangFlags
1896  ++ map (mkFlag turnOff "fno-" unSetExtensionFlag) fLangFlags
1897  ++ map (mkFlag turnOn  "X"    setExtensionFlag  ) xFlags
1898  ++ map (mkFlag turnOff "XNo"  unSetExtensionFlag) xFlags
1899  ++ map (mkFlag turnOn  "X"    setLanguage) languageFlags
1900  ++ map (mkFlag turnOn  "X"    setSafeHaskell) safeHaskellFlags
1901  ++ [ Flag "XGenerics"       (NoArg (deprecate "it does nothing; look into -XDefaultSignatures and -XDeriveGeneric for generic programming support."))
1902     , Flag "XNoGenerics"     (NoArg (deprecate "it does nothing; look into -XDefaultSignatures and -XDeriveGeneric for generic programming support.")) ]
1903
1904 package_flags :: [Flag (CmdLineP DynFlags)]
1905 package_flags = [
1906         ------- Packages ----------------------------------------------------
1907     Flag "package-db"            (HasArg (addPkgConfRef . PkgConfFile))
1908   , Flag "clear-package-db"      (NoArg clearPkgConf)
1909   , Flag "no-global-package-db"  (NoArg removeGlobalPkgConf)
1910   , Flag "no-user-package-db"    (NoArg removeUserPkgConf)
1911   , Flag "global-package-db"     (NoArg (addPkgConfRef GlobalPkgConf))
1912   , Flag "user-package-db"       (NoArg (addPkgConfRef UserPkgConf))
1913
1914     -- backwards compat with GHC<=7.4 :
1915   , Flag "package-conf"          (HasArg $ \path -> do
1916                                     addPkgConfRef (PkgConfFile path)
1917                                     deprecate "Use -package-db instead")
1918   , Flag "no-user-package-conf"  (NoArg $ do
1919                                     removeUserPkgConf
1920                                     deprecate "Use -no-user-package-db instead")
1921
1922   , Flag "package-name"          (hasArg setPackageName)
1923   , Flag "package-id"            (HasArg exposePackageId)
1924   , Flag "package"               (HasArg exposePackage)
1925   , Flag "hide-package"          (HasArg hidePackage)
1926   , Flag "hide-all-packages"     (NoArg (setDynFlag Opt_HideAllPackages))
1927   , Flag "ignore-package"        (HasArg ignorePackage)
1928   , Flag "syslib"                (HasArg (\s -> do exposePackage s
1929                                                    deprecate "Use -package instead"))
1930   , Flag "distrust-all-packages" (NoArg (setDynFlag Opt_DistrustAllPackages))
1931   , Flag "trust"                 (HasArg trustPackage)
1932   , Flag "distrust"              (HasArg distrustPackage)
1933   ]
1934
1935 type TurnOnFlag = Bool   -- True  <=> we are turning the flag on
1936                          -- False <=> we are turning the flag off
1937 turnOn  :: TurnOnFlag; turnOn  = True
1938 turnOff :: TurnOnFlag; turnOff = False
1939
1940 type FlagSpec flag
1941    = ( String   -- Flag in string form
1942      , flag     -- Flag in internal form
1943      , TurnOnFlag -> DynP ())    -- Extra action to run when the flag is found
1944                                  -- Typically, emit a warning or error
1945
1946 mkFlag :: TurnOnFlag            -- ^ True <=> it should be turned on
1947        -> String                -- ^ The flag prefix
1948        -> (flag -> DynP ())     -- ^ What to do when the flag is found
1949        -> FlagSpec flag         -- ^ Specification of this particular flag
1950        -> Flag (CmdLineP DynFlags)
1951 mkFlag turn_on flagPrefix f (name, flag, extra_action)
1952     = Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on))
1953
1954 deprecatedForExtension :: String -> TurnOnFlag -> DynP ()
1955 deprecatedForExtension lang turn_on
1956     = deprecate ("use -X"  ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1957     where
1958       flag | turn_on    = lang
1959            | otherwise = "No"++lang
1960
1961 useInstead :: String -> TurnOnFlag -> DynP ()
1962 useInstead flag turn_on
1963   = deprecate ("Use -f" ++ no ++ flag ++ " instead")
1964   where
1965     no = if turn_on then "" else "no-"
1966
1967 nop :: TurnOnFlag -> DynP ()
1968 nop _ = return ()
1969
1970 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1971 fWarningFlags :: [FlagSpec WarningFlag]
1972 fWarningFlags = [
1973   ( "warn-dodgy-foreign-imports",       Opt_WarnDodgyForeignImports, nop ),
1974   ( "warn-dodgy-exports",               Opt_WarnDodgyExports, nop ),
1975   ( "warn-dodgy-imports",               Opt_WarnDodgyImports, nop ),
1976   ( "warn-duplicate-exports",           Opt_WarnDuplicateExports, nop ),
1977   ( "warn-hi-shadowing",                Opt_WarnHiShadows, nop ),
1978   ( "warn-implicit-prelude",            Opt_WarnImplicitPrelude, nop ),
1979   ( "warn-incomplete-patterns",         Opt_WarnIncompletePatterns, nop ),
1980   ( "warn-incomplete-uni-patterns",     Opt_WarnIncompleteUniPatterns, nop ),
1981   ( "warn-incomplete-record-updates",   Opt_WarnIncompletePatternsRecUpd, nop ),
1982   ( "warn-missing-fields",              Opt_WarnMissingFields, nop ),
1983   ( "warn-missing-import-lists",        Opt_WarnMissingImportList, nop ),
1984   ( "warn-missing-methods",             Opt_WarnMissingMethods, nop ),
1985   ( "warn-missing-signatures",          Opt_WarnMissingSigs, nop ),
1986   ( "warn-missing-local-sigs",          Opt_WarnMissingLocalSigs, nop ),
1987   ( "warn-name-shadowing",              Opt_WarnNameShadowing, nop ),
1988   ( "warn-overlapping-patterns",        Opt_WarnOverlappingPatterns, nop ),
1989   ( "warn-type-defaults",               Opt_WarnTypeDefaults, nop ),
1990   ( "warn-monomorphism-restriction",    Opt_WarnMonomorphism, nop ),
1991   ( "warn-unused-binds",                Opt_WarnUnusedBinds, nop ),
1992   ( "warn-unused-imports",              Opt_WarnUnusedImports, nop ),
1993   ( "warn-unused-matches",              Opt_WarnUnusedMatches, nop ),
1994   ( "warn-warnings-deprecations",       Opt_WarnWarningsDeprecations, nop ),
1995   ( "warn-deprecations",                Opt_WarnWarningsDeprecations, nop ),
1996   ( "warn-deprecated-flags",            Opt_WarnDeprecatedFlags, nop ),
1997   ( "warn-orphans",                     Opt_WarnOrphans, nop ),
1998   ( "warn-identities",                  Opt_WarnIdentities, nop ),
1999   ( "warn-auto-orphans",                Opt_WarnAutoOrphans, nop ),
2000   ( "warn-tabs",                        Opt_WarnTabs, nop ),
2001   ( "warn-unrecognised-pragmas",        Opt_WarnUnrecognisedPragmas, nop ),
2002   ( "warn-lazy-unlifted-bindings",      Opt_WarnLazyUnliftedBindings, nop ),
2003   ( "warn-unused-do-bind",              Opt_WarnUnusedDoBind, nop ),
2004   ( "warn-wrong-do-bind",               Opt_WarnWrongDoBind, nop ),
2005   ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, nop ),
2006   ( "warn-unsafe",                      Opt_WarnUnsafe, setWarnUnsafe ),
2007   ( "warn-safe",                        Opt_WarnSafe, setWarnSafe ),
2008   ( "warn-pointless-pragmas",           Opt_WarnPointlessPragmas, nop ),
2009   ( "warn-unsupported-calling-conventions", Opt_WarnUnsupportedCallingConventions, nop ),
2010   ( "warn-inline-rule-shadowing",       Opt_WarnInlineRuleShadowing, nop ) ]
2011
2012 -- | These @-\<blah\>@ flags can all be reversed with @-no-\<blah\>@
2013 negatableFlags :: [FlagSpec DynFlag]
2014 negatableFlags = [
2015   ( "ignore-dot-ghci",                  Opt_IgnoreDotGhci, nop ) ]
2016
2017 -- | These @-d\<blah\>@ flags can all be reversed with @-dno-\<blah\>@
2018 dFlags :: [FlagSpec DynFlag]
2019 dFlags = [
2020   ( "ppr-case-as-let",                  Opt_PprCaseAsLet, nop ) ]
2021
2022 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
2023 fFlags :: [FlagSpec DynFlag]
2024 fFlags = [
2025   ( "print-explicit-foralls",           Opt_PrintExplicitForalls, nop ),
2026   ( "strictness",                       Opt_Strictness, nop ),
2027   ( "specialise",                       Opt_Specialise, nop ),
2028   ( "float-in",                         Opt_FloatIn, nop ),
2029   ( "static-argument-transformation",   Opt_StaticArgumentTransformation, nop ),
2030   ( "full-laziness",                    Opt_FullLaziness, nop ),
2031   ( "liberate-case",                    Opt_LiberateCase, nop ),
2032   ( "spec-constr",                      Opt_SpecConstr, nop ),
2033   ( "cse",                              Opt_CSE, nop ),
2034   ( "pedantic-bottoms",                 Opt_PedanticBottoms, nop ),
2035   ( "ignore-interface-pragmas",         Opt_IgnoreInterfacePragmas, nop ),
2036   ( "omit-interface-pragmas",           Opt_OmitInterfacePragmas, nop ),
2037   ( "expose-all-unfoldings",            Opt_ExposeAllUnfoldings, nop ),
2038   ( "do-lambda-eta-expansion",          Opt_DoLambdaEtaExpansion, nop ),
2039   ( "ignore-asserts",                   Opt_IgnoreAsserts, nop ),
2040   ( "do-eta-reduction",                 Opt_DoEtaReduction, nop ),
2041   ( "case-merge",                       Opt_CaseMerge, nop ),
2042   ( "unbox-strict-fields",              Opt_UnboxStrictFields, nop ),
2043   ( "dicts-cheap",                      Opt_DictsCheap, nop ),
2044   ( "excess-precision",                 Opt_ExcessPrecision, nop ),
2045   ( "eager-blackholing",                Opt_EagerBlackHoling, nop ),
2046   ( "print-bind-result",                Opt_PrintBindResult, nop ),
2047   ( "force-recomp",                     Opt_ForceRecomp, nop ),
2048   ( "hpc-no-auto",                      Opt_Hpc_No_Auto, nop ),
2049   ( "rewrite-rules",                    Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
2050   ( "enable-rewrite-rules",             Opt_EnableRewriteRules, nop ),
2051   ( "break-on-exception",               Opt_BreakOnException, nop ),
2052   ( "break-on-error",                   Opt_BreakOnError, nop ),
2053   ( "print-evld-with-show",             Opt_PrintEvldWithShow, nop ),
2054   ( "print-bind-contents",              Opt_PrintBindContents, nop ),
2055   ( "run-cps",                          Opt_RunCPS, nop ),
2056   ( "run-cpsz",                         Opt_RunCPSZ, nop ),
2057   ( "new-codegen",                      Opt_TryNewCodeGen, nop ),
2058   ( "vectorise",                        Opt_Vectorise, nop ),
2059   ( "avoid-vect",                       Opt_AvoidVect, nop ),
2060   ( "regs-graph",                       Opt_RegsGraph, nop ),
2061   ( "regs-iterative",                   Opt_RegsIterative, nop ),
2062   ( "llvm-tbaa",                        Opt_LlvmTBAA, nop), -- hidden flag
2063   ( "regs-liveness",                    Opt_RegLiveness, nop), -- hidden flag
2064   ( "irrefutable-tuples",               Opt_IrrefutableTuples, nop ),
2065   ( "cmm-sink",                         Opt_CmmSink, nop ),
2066   ( "cmm-elim-common-blocks",           Opt_CmmElimCommonBlocks, nop ),
2067   ( "gen-manifest",                     Opt_GenManifest, nop ),
2068   ( "embed-manifest",                   Opt_EmbedManifest, nop ),
2069   ( "ext-core",                         Opt_EmitExternalCore, nop ),
2070   ( "shared-implib",                    Opt_SharedImplib, nop ),
2071   ( "ghci-sandbox",                     Opt_GhciSandbox, nop ),
2072   ( "ghci-history",                     Opt_GhciHistory, nop ),
2073   ( "helpful-errors",                   Opt_HelpfulErrors, nop ),
2074   ( "defer-type-errors",                Opt_DeferTypeErrors, nop ),
2075   ( "parallel",                         Opt_Parallel, nop ),
2076   ( "scc-profiling",                    Opt_SccProfilingOn, nop ),
2077   ( "gransim",                          Opt_GranMacros, nop ),
2078   ( "building-cabal-package",           Opt_BuildingCabalPackage, nop ),
2079   ( "implicit-import-qualified",        Opt_ImplicitImportQualified, nop ),
2080   ( "prof-count-entries",               Opt_ProfCountEntries, nop ),
2081   ( "prof-cafs",                        Opt_AutoSccsOnIndividualCafs, nop )
2082   ]
2083
2084 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
2085 fLangFlags :: [FlagSpec ExtensionFlag]
2086 fLangFlags = [
2087   ( "th",                               Opt_TemplateHaskell,
2088     deprecatedForExtension "TemplateHaskell" >> checkTemplateHaskellOk ),
2089   ( "fi",                               Opt_ForeignFunctionInterface,
2090     deprecatedForExtension "ForeignFunctionInterface" ),
2091   ( "ffi",                              Opt_ForeignFunctionInterface,
2092     deprecatedForExtension "ForeignFunctionInterface" ),
2093   ( "arrows",                           Opt_Arrows,
2094     deprecatedForExtension "Arrows" ),
2095   ( "implicit-prelude",                 Opt_ImplicitPrelude,
2096     deprecatedForExtension "ImplicitPrelude" ),
2097   ( "bang-patterns",                    Opt_BangPatterns,
2098     deprecatedForExtension "BangPatterns" ),
2099   ( "monomorphism-restriction",         Opt_MonomorphismRestriction,
2100     deprecatedForExtension "MonomorphismRestriction" ),
2101   ( "mono-pat-binds",                   Opt_MonoPatBinds,
2102     deprecatedForExtension "MonoPatBinds" ),
2103   ( "extended-default-rules",           Opt_ExtendedDefaultRules,
2104     deprecatedForExtension "ExtendedDefaultRules" ),
2105   ( "implicit-params",                  Opt_ImplicitParams,
2106     deprecatedForExtension "ImplicitParams" ),
2107   ( "scoped-type-variables",            Opt_ScopedTypeVariables,
2108     deprecatedForExtension "ScopedTypeVariables" ),
2109   ( "parr",                             Opt_ParallelArrays,
2110     deprecatedForExtension "ParallelArrays" ),
2111   ( "PArr",                             Opt_ParallelArrays,
2112     deprecatedForExtension "ParallelArrays" ),
2113   ( "allow-overlapping-instances",      Opt_OverlappingInstances,
2114     deprecatedForExtension "OverlappingInstances" ),
2115   ( "allow-undecidable-instances",      Opt_UndecidableInstances,
2116     deprecatedForExtension "UndecidableInstances" ),
2117   ( "allow-incoherent-instances",       Opt_IncoherentInstances,
2118     deprecatedForExtension "IncoherentInstances" )
2119   ]
2120
2121 supportedLanguages :: [String]
2122 supportedLanguages = [ name | (name, _, _) <- languageFlags ]
2123
2124 supportedLanguageOverlays :: [String]
2125 supportedLanguageOverlays = [ name | (name, _, _) <- safeHaskellFlags ]
2126
2127 supportedExtensions :: [String]
2128 supportedExtensions = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
2129
2130 supportedLanguagesAndExtensions :: [String]
2131 supportedLanguagesAndExtensions =
2132     supportedLanguages ++ supportedLanguageOverlays ++ supportedExtensions
2133
2134 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
2135 languageFlags :: [FlagSpec Language]
2136 languageFlags = [
2137   ( "Haskell98",   Haskell98, nop ),
2138   ( "Haskell2010", Haskell2010, nop )
2139   ]
2140
2141 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
2142 -- They are used to place hard requirements on what GHC Haskell language
2143 -- features can be used.
2144 safeHaskellFlags :: [FlagSpec SafeHaskellMode]
2145 safeHaskellFlags = [mkF Sf_Unsafe, mkF Sf_Trustworthy, mkF Sf_Safe]
2146     where mkF flag = (show flag, flag, nop)
2147
2148 -- | These -X<blah> flags can all be reversed with -XNo<blah>
2149 xFlags :: [FlagSpec ExtensionFlag]
2150 xFlags = [
2151   ( "CPP",                              Opt_Cpp, nop ),
2152   ( "PostfixOperators",                 Opt_PostfixOperators, nop ),
2153   ( "TupleSections",                    Opt_TupleSections, nop ),
2154   ( "PatternGuards",                    Opt_PatternGuards, nop ),
2155   ( "UnicodeSyntax",                    Opt_UnicodeSyntax, nop ),
2156   ( "MagicHash",                        Opt_MagicHash, nop ),
2157   ( "PolymorphicComponents",            Opt_PolymorphicComponents, nop ),
2158   ( "ExistentialQuantification",        Opt_ExistentialQuantification, nop ),
2159   ( "KindSignatures",                   Opt_KindSignatures, nop ),
2160   ( "EmptyDataDecls",                   Opt_EmptyDataDecls, nop ),
2161   ( "ParallelListComp",                 Opt_ParallelListComp, nop ),
2162   ( "TransformListComp",                Opt_TransformListComp, nop ),
2163   ( "MonadComprehensions",              Opt_MonadComprehensions, nop),
2164   ( "ForeignFunctionInterface",         Opt_ForeignFunctionInterface, nop ),
2165   ( "UnliftedFFITypes",                 Opt_UnliftedFFITypes, nop ),
2166   ( "InterruptibleFFI",                 Opt_InterruptibleFFI, nop ),
2167   ( "CApiFFI",                          Opt_CApiFFI, nop ),
2168   ( "GHCForeignImportPrim",             Opt_GHCForeignImportPrim, nop ),
2169   ( "LiberalTypeSynonyms",              Opt_LiberalTypeSynonyms, nop ),
2170   ( "Rank2Types",                       Opt_Rank2Types, nop ),
2171   ( "RankNTypes",                       Opt_RankNTypes, nop ),
2172   ( "ImpredicativeTypes",               Opt_ImpredicativeTypes, nop),
2173   ( "TypeOperators",                    Opt_TypeOperators, nop ),
2174   ( "ExplicitNamespaces",               Opt_ExplicitNamespaces, nop ),
2175   ( "RecursiveDo",                      Opt_RecursiveDo, nop ),  -- Enables 'mdo' and 'rec'
2176   ( "DoRec",                            Opt_RecursiveDo, 
2177      deprecatedForExtension "RecursiveDo" ),
2178   ( "Arrows",                           Opt_Arrows, nop ),
2179   ( "ParallelArrays",                   Opt_ParallelArrays, nop ),
2180   ( "TemplateHaskell",                  Opt_TemplateHaskell, checkTemplateHaskellOk ),
2181   ( "QuasiQuotes",                      Opt_QuasiQuotes, nop ),
2182   ( "ImplicitPrelude",                  Opt_ImplicitPrelude, nop ),
2183   ( "RecordWildCards",                  Opt_RecordWildCards, nop ),
2184   ( "NamedFieldPuns",                   Opt_RecordPuns, nop ),
2185   ( "RecordPuns",                       Opt_RecordPuns,
2186     deprecatedForExtension "NamedFieldPuns" ),
2187   ( "DisambiguateRecordFields",         Opt_DisambiguateRecordFields, nop ),
2188   ( "OverloadedStrings",                Opt_OverloadedStrings, nop ),
2189   ( "GADTs",                            Opt_GADTs, nop ),
2190   ( "GADTSyntax",                       Opt_GADTSyntax, nop ),
2191   ( "ViewPatterns",                     Opt_ViewPatterns, nop ),
2192   ( "TypeFamilies",                     Opt_TypeFamilies, nop ),
2193   ( "BangPatterns",                     Opt_BangPatterns, nop ),
2194   ( "MonomorphismRestriction",          Opt_MonomorphismRestriction, nop ),
2195   ( "NPlusKPatterns",                   Opt_NPlusKPatterns, nop ),
2196   ( "DoAndIfThenElse",                  Opt_DoAndIfThenElse, nop ),
2197   ( "RebindableSyntax",                 Opt_RebindableSyntax, nop ),
2198   ( "ConstraintKinds",                  Opt_ConstraintKinds, nop ),
2199   ( "PolyKinds",                        Opt_PolyKinds, nop ),
2200   ( "DataKinds",                        Opt_DataKinds, nop ),
2201   ( "InstanceSigs",                     Opt_InstanceSigs, nop ),
2202   ( "MonoPatBinds",                     Opt_MonoPatBinds,
2203     \ turn_on -> when turn_on $ deprecate "Experimental feature now removed; has no effect" ),
2204   ( "ExplicitForAll",                   Opt_ExplicitForAll, nop ),
2205   ( "AlternativeLayoutRule",            Opt_AlternativeLayoutRule, nop ),
2206   ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, nop ),
2207   ( "DatatypeContexts",                 Opt_DatatypeContexts,
2208     \ turn_on -> when turn_on $ deprecate "It was widely considered a misfeature, and has been removed from the Haskell language." ),
2209   ( "NondecreasingIndentation",         Opt_NondecreasingIndentation, nop ),
2210   ( "RelaxedLayout",                    Opt_RelaxedLayout, nop ),
2211   ( "TraditionalRecordSyntax",          Opt_TraditionalRecordSyntax, nop ),
2212   ( "LambdaCase",                       Opt_LambdaCase, nop ),
2213   ( "MultiWayIf",                       Opt_MultiWayIf, nop ),
2214   ( "MonoLocalBinds",                   Opt_MonoLocalBinds, nop ),
2215   ( "RelaxedPolyRec",                   Opt_RelaxedPolyRec,
2216     \ turn_on -> if not turn_on
2217                  then deprecate "You can't turn off RelaxedPolyRec any more"
2218                  else return () ),
2219   ( "ExtendedDefaultRules",             Opt_ExtendedDefaultRules, nop ),
2220   ( "ImplicitParams",                   Opt_ImplicitParams, nop ),
2221   ( "ScopedTypeVariables",              Opt_ScopedTypeVariables, nop ),
2222
2223   ( "PatternSignatures",                Opt_ScopedTypeVariables,
2224     deprecatedForExtension "ScopedTypeVariables" ),
2225
2226   ( "UnboxedTuples",                    Opt_UnboxedTuples, nop ),
2227   ( "StandaloneDeriving",               Opt_StandaloneDeriving, nop ),
2228   ( "DeriveDataTypeable",               Opt_DeriveDataTypeable, nop ),
2229   ( "DeriveFunctor",                    Opt_DeriveFunctor, nop ),
2230   ( "DeriveTraversable",                Opt_DeriveTraversable, nop ),
2231   ( "DeriveFoldable",                   Opt_DeriveFoldable, nop ),
2232   ( "DeriveGeneric",                    Opt_DeriveGeneric, nop ),
2233   ( "DefaultSignatures",                Opt_DefaultSignatures, nop ),
2234   ( "TypeSynonymInstances",             Opt_TypeSynonymInstances, nop ),
2235   ( "FlexibleContexts",                 Opt_FlexibleContexts, nop ),
2236   ( "FlexibleInstances",                Opt_FlexibleInstances, nop ),
2237   ( "ConstrainedClassMethods",          Opt_ConstrainedClassMethods, nop ),
2238   ( "MultiParamTypeClasses",            Opt_MultiParamTypeClasses, nop ),
2239   ( "FunctionalDependencies",           Opt_FunctionalDependencies, nop ),
2240   ( "GeneralizedNewtypeDeriving",       Opt_GeneralizedNewtypeDeriving, setGenDeriving ),
2241   ( "OverlappingInstances",             Opt_OverlappingInstances, nop ),
2242   ( "UndecidableInstances",             Opt_UndecidableInstances, nop ),
2243   ( "IncoherentInstances",              Opt_IncoherentInstances, nop ),
2244   ( "PackageImports",                   Opt_PackageImports, nop )
2245   ]
2246
2247 defaultFlags :: Platform -> [DynFlag]
2248 defaultFlags platform
2249   = [ Opt_AutoLinkPackages,
2250
2251       Opt_SharedImplib,
2252
2253 #if GHC_DEFAULT_NEW_CODEGEN
2254       Opt_TryNewCodeGen,
2255 #endif
2256
2257       Opt_GenManifest,
2258       Opt_EmbedManifest,
2259       Opt_PrintBindContents,
2260       Opt_GhciSandbox,
2261       Opt_GhciHistory,
2262       Opt_HelpfulErrors,
2263       Opt_ProfCountEntries
2264     ]
2265
2266     ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
2267              -- The default -O0 options
2268
2269     ++ (case platformOS platform of
2270         OSDarwin ->
2271             case platformArch platform of
2272             ArchX86_64         -> [Opt_PIC]
2273             _ | not opt_Static -> [Opt_PIC]
2274             _                  -> []
2275         _ -> [])
2276
2277 impliedFlags :: [(ExtensionFlag, TurnOnFlag, ExtensionFlag)]
2278 impliedFlags
2279   = [ (Opt_RankNTypes,                turnOn, Opt_ExplicitForAll)
2280     , (Opt_Rank2Types,                turnOn, Opt_ExplicitForAll)
2281     , (Opt_ScopedTypeVariables,       turnOn, Opt_ExplicitForAll)
2282     , (Opt_LiberalTypeSynonyms,       turnOn, Opt_ExplicitForAll)
2283     , (Opt_ExistentialQuantification, turnOn, Opt_ExplicitForAll)
2284     , (Opt_PolymorphicComponents,     turnOn, Opt_ExplicitForAll)
2285     , (Opt_FlexibleInstances,         turnOn, Opt_TypeSynonymInstances)
2286     , (Opt_FunctionalDependencies,    turnOn, Opt_MultiParamTypeClasses)
2287
2288     , (Opt_RebindableSyntax, turnOff, Opt_ImplicitPrelude)      -- NB: turn off!
2289
2290     , (Opt_GADTs,            turnOn, Opt_GADTSyntax)
2291     , (Opt_GADTs,            turnOn, Opt_MonoLocalBinds)
2292     , (Opt_TypeFamilies,     turnOn, Opt_MonoLocalBinds)
2293
2294     , (Opt_TypeFamilies,     turnOn, Opt_KindSignatures)  -- Type families use kind signatures
2295     , (Opt_PolyKinds,        turnOn, Opt_KindSignatures)  -- Ditto polymorphic kinds
2296
2297     -- We turn this on so that we can export associated type
2298     -- type synonyms in subordinates (e.g. MyClass(type AssocType))
2299     , (Opt_TypeFamilies,     turnOn, Opt_ExplicitNamespaces)
2300     , (Opt_TypeOperators, turnOn, Opt_ExplicitNamespaces)
2301
2302     , (Opt_ImpredicativeTypes,  turnOn, Opt_RankNTypes)
2303
2304         -- Record wild-cards implies field disambiguation
2305         -- Otherwise if you write (C {..}) you may well get
2306         -- stuff like " 'a' not in scope ", which is a bit silly
2307         -- if the compiler has just filled in field 'a' of constructor 'C'
2308     , (Opt_RecordWildCards,     turnOn, Opt_DisambiguateRecordFields)
2309
2310     , (Opt_ParallelArrays, turnOn, Opt_ParallelListComp)
2311
2312     -- An implicit parameter constraint, `?x::Int`, is desugared into
2313     -- `IP "x" Int`, which requires a flexible context/instance.
2314     , (Opt_ImplicitParams, turnOn, Opt_FlexibleContexts)
2315     , (Opt_ImplicitParams, turnOn, Opt_FlexibleInstances)
2316   ]
2317
2318 optLevelFlags :: [([Int], DynFlag)]
2319 optLevelFlags
2320   = [ ([0],     Opt_IgnoreInterfacePragmas)
2321     , ([0],     Opt_OmitInterfacePragmas)
2322
2323     , ([1,2],   Opt_IgnoreAsserts)
2324     , ([1,2],   Opt_EnableRewriteRules)  -- Off for -O0; see Note [Scoping for Builtin rules]
2325                                          --              in PrelRules
2326     , ([1,2],   Opt_DoEtaReduction)
2327     , ([1,2],   Opt_CaseMerge)
2328     , ([1,2],   Opt_Strictness)
2329     , ([1,2],   Opt_CSE)
2330     , ([1,2],   Opt_FullLaziness)
2331     , ([1,2],   Opt_Specialise)
2332     , ([1,2],   Opt_FloatIn)
2333
2334     , ([2],     Opt_LiberateCase)
2335     , ([2],     Opt_SpecConstr)
2336     , ([2],     Opt_RegsGraph)
2337     , ([0,1,2], Opt_LlvmTBAA)
2338     , ([0,1,2], Opt_RegLiveness)
2339     , ([1,2],   Opt_CmmSink)
2340     , ([1,2],   Opt_CmmElimCommonBlocks)
2341
2342 --     , ([2],     Opt_StaticArgumentTransformation)
2343 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
2344 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
2345 -- several improvements to the heuristics, and I'm concerned that without
2346 -- those changes SAT will interfere with some attempts to write "high
2347 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
2348 -- this year. In particular, the version in HEAD lacks the tail call
2349 -- criterion, so many things that look like reasonable loops will be
2350 -- turned into functions with extra (unneccesary) thunk creation.
2351
2352     , ([0,1,2], Opt_DoLambdaEtaExpansion)
2353                 -- This one is important for a tiresome reason:
2354                 -- we want to make sure that the bindings for data
2355                 -- constructors are eta-expanded.  This is probably
2356                 -- a good thing anyway, but it seems fragile.
2357     ]
2358
2359 -- -----------------------------------------------------------------------------
2360 -- Standard sets of warning options
2361
2362 standardWarnings :: [WarningFlag]
2363 standardWarnings
2364     = [ Opt_WarnWarningsDeprecations,
2365         Opt_WarnDeprecatedFlags,
2366         Opt_WarnUnrecognisedPragmas,
2367         Opt_WarnOverlappingPatterns,
2368         Opt_WarnMissingFields,
2369         Opt_WarnMissingMethods,
2370         Opt_WarnDuplicateExports,
2371         Opt_WarnLazyUnliftedBindings,
2372         Opt_WarnDodgyForeignImports,
2373         Opt_WarnWrongDoBind,
2374         Opt_WarnAlternativeLayoutRuleTransitional,
2375         Opt_WarnPointlessPragmas,
2376         Opt_WarnUnsupportedCallingConventions,
2377         Opt_WarnInlineRuleShadowing
2378       ]
2379
2380 minusWOpts :: [WarningFlag]
2381 -- Things you get with -W
2382 minusWOpts
2383     = standardWarnings ++
2384       [ Opt_WarnUnusedBinds,
2385         Opt_WarnUnusedMatches,
2386         Opt_WarnUnusedImports,
2387         Opt_WarnIncompletePatterns,
2388         Opt_WarnDodgyExports,
2389         Opt_WarnDodgyImports
2390       ]
2391
2392 minusWallOpts :: [WarningFlag]
2393 -- Things you get with -Wall
2394 minusWallOpts
2395     = minusWOpts ++
2396       [ Opt_WarnTypeDefaults,
2397         Opt_WarnNameShadowing,
2398         Opt_WarnMissingSigs,
2399         Opt_WarnHiShadows,
2400         Opt_WarnOrphans,
2401         Opt_WarnUnusedDoBind
2402       ]
2403
2404 enableGlasgowExts :: DynP ()
2405 enableGlasgowExts = do setDynFlag Opt_PrintExplicitForalls
2406                        mapM_ setExtensionFlag glasgowExtsFlags
2407
2408 disableGlasgowExts :: DynP ()
2409 disableGlasgowExts = do unSetDynFlag Opt_PrintExplicitForalls
2410                         mapM_ unSetExtensionFlag glasgowExtsFlags
2411
2412 glasgowExtsFlags :: [ExtensionFlag]
2413 glasgowExtsFlags = [
2414              Opt_ForeignFunctionInterface
2415            , Opt_UnliftedFFITypes
2416            , Opt_ImplicitParams
2417            , Opt_ScopedTypeVariables
2418            , Opt_UnboxedTuples
2419            , Opt_TypeSynonymInstances
2420            , Opt_StandaloneDeriving
2421            , Opt_DeriveDataTypeable
2422            , Opt_DeriveFunctor
2423            , Opt_DeriveFoldable
2424            , Opt_DeriveTraversable
2425            , Opt_DeriveGeneric
2426            , Opt_FlexibleContexts
2427            , Opt_FlexibleInstances
2428            , Opt_ConstrainedClassMethods
2429            , Opt_MultiParamTypeClasses
2430            , Opt_FunctionalDependencies
2431            , Opt_MagicHash
2432            , Opt_PolymorphicComponents
2433            , Opt_ExistentialQuantification
2434            , Opt_UnicodeSyntax
2435            , Opt_PostfixOperators
2436            , Opt_PatternGuards
2437            , Opt_LiberalTypeSynonyms
2438            , Opt_RankNTypes
2439            , Opt_TypeOperators
2440            , Opt_ExplicitNamespaces
2441            , Opt_RecursiveDo
2442            , Opt_ParallelListComp
2443            , Opt_EmptyDataDecls
2444            , Opt_KindSignatures
2445            , Opt_GeneralizedNewtypeDeriving ]
2446
2447 #ifdef GHCI
2448 -- Consult the RTS to find whether GHC itself has been built profiled
2449 -- If so, you can't use Template Haskell
2450 foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt
2451
2452 rtsIsProfiled :: Bool
2453 rtsIsProfiled = unsafePerformIO rtsIsProfiledIO /= 0
2454 #endif
2455
2456 setWarnSafe :: Bool -> DynP ()
2457 setWarnSafe True  = getCurLoc >>= \l -> upd (\d -> d { warnSafeOnLoc = l })
2458 setWarnSafe False = return ()
2459
2460 setWarnUnsafe :: Bool -> DynP ()
2461 setWarnUnsafe True  = getCurLoc >>= \l -> upd (\d -> d { warnUnsafeOnLoc = l })
2462 setWarnUnsafe False = return ()
2463
2464 setPackageTrust :: DynP ()
2465 setPackageTrust = do
2466     setDynFlag Opt_PackageTrust
2467     l <- getCurLoc
2468     upd $ \d -> d { pkgTrustOnLoc = l }
2469
2470 setGenDeriving :: Bool -> DynP ()
2471 setGenDeriving True  = getCurLoc >>= \l -> upd (\d -> d { newDerivOnLoc = l })
2472 setGenDeriving False = return ()
2473
2474 checkTemplateHaskellOk :: Bool -> DynP ()
2475 #ifdef GHCI
2476 checkTemplateHaskellOk turn_on
2477   | turn_on && rtsIsProfiled
2478   = addErr "You can't use Template Haskell with a profiled compiler"
2479   | otherwise
2480   = getCurLoc >>= \l -> upd (\d -> d { thOnLoc = l })
2481 #else
2482 -- In stage 1 we don't know that the RTS has rts_isProfiled,
2483 -- so we simply say "ok".  It doesn't matter because TH isn't
2484 -- available in stage 1 anyway.
2485 checkTemplateHaskellOk _ = return ()
2486 #endif
2487
2488 {- **********************************************************************
2489 %*                                                                      *
2490                 DynFlags constructors
2491 %*                                                                      *
2492 %********************************************************************* -}
2493
2494 type DynP = EwM (CmdLineP DynFlags)
2495
2496 upd :: (DynFlags -> DynFlags) -> DynP ()
2497 upd f = liftEwM (do dflags <- getCmdLineState
2498                     putCmdLineState $! f dflags)
2499
2500 updM :: (DynFlags -> DynP DynFlags) -> DynP ()
2501 updM f = do dflags <- liftEwM getCmdLineState
2502             dflags' <- f dflags
2503             liftEwM $ putCmdLineState $! dflags'
2504
2505 --------------- Constructor functions for OptKind -----------------
2506 noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
2507 noArg fn = NoArg (upd fn)
2508
2509 noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
2510 noArgM fn = NoArg (updM fn)
2511
2512 noArgDF :: (DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
2513 noArgDF fn deprec = NoArg (upd fn >> deprecate deprec)
2514
2515 hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
2516 hasArg fn = HasArg (upd . fn)
2517
2518 hasArgDF :: (String -> DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
2519 hasArgDF fn deprec = HasArg (\s -> do upd (fn s)
2520                                       deprecate deprec)
2521
2522 sepArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
2523 sepArg fn = SepArg (upd . fn)
2524
2525 intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
2526 intSuffix fn = IntSuffix (\n -> upd (fn n))
2527
2528 optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)
2529               -> OptKind (CmdLineP DynFlags)
2530 optIntSuffixM fn = OptIntSuffix (\mi -> updM (fn mi))
2531
2532 setDumpFlag :: DynFlag -> OptKind (CmdLineP DynFlags)
2533 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
2534
2535 --------------------------
2536 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
2537 setDynFlag   f = upd (\dfs -> dopt_set dfs f)
2538 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
2539
2540 --------------------------
2541 setWarningFlag, unSetWarningFlag :: WarningFlag -> DynP ()
2542 setWarningFlag   f = upd (\dfs -> wopt_set dfs f)
2543 unSetWarningFlag f = upd (\dfs -> wopt_unset dfs f)
2544
2545 --------------------------
2546 setExtensionFlag, unSetExtensionFlag :: ExtensionFlag -> DynP ()
2547 setExtensionFlag f = do upd (\dfs -> xopt_set dfs f)
2548                         sequence_ deps
2549   where
2550     deps = [ if turn_on then setExtensionFlag   d
2551                         else unSetExtensionFlag d
2552            | (f', turn_on, d) <- impliedFlags, f' == f ]
2553         -- When you set f, set the ones it implies
2554         -- NB: use setExtensionFlag recursively, in case the implied flags
2555         --     implies further flags
2556
2557 unSetExtensionFlag f = upd (\dfs -> xopt_unset dfs f)
2558    -- When you un-set f, however, we don't un-set the things it implies
2559    --      (except for -fno-glasgow-exts, which is treated specially)
2560
2561 --------------------------
2562 alterSettings :: (Settings -> Settings) -> DynFlags -> DynFlags
2563 alterSettings f dflags = dflags { settings = f (settings dflags) }
2564
2565 --------------------------
2566 setDumpFlag' :: DynFlag -> DynP ()
2567 setDumpFlag' dump_flag
2568   = do setDynFlag dump_flag
2569        when want_recomp forceRecompile
2570   where
2571         -- Certain dumpy-things are really interested in what's going
2572         -- on during recompilation checking, so in those cases we
2573         -- don't want to turn it off.
2574     want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
2575                                        Opt_D_dump_hi_diffs]
2576
2577 forceRecompile :: DynP ()
2578 -- Whenver we -ddump, force recompilation (by switching off the
2579 -- recompilation checker), else you don't see the dump! However,
2580 -- don't switch it off in --make mode, else *everything* gets
2581 -- recompiled which probably isn't what you want
2582 forceRecompile = do dfs <- liftEwM getCmdLineState
2583                     when (force_recomp dfs) (setDynFlag Opt_ForceRecomp)
2584         where
2585           force_recomp dfs = isOneShot (ghcMode dfs)
2586
2587 setVerboseCore2Core :: DynP ()
2588 setVerboseCore2Core = do forceRecompile
2589                          setDynFlag Opt_D_verbose_core2core
2590                          upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
2591
2592 setDumpSimplPhases :: String -> DynP ()
2593 setDumpSimplPhases s = do forceRecompile
2594                           upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
2595   where
2596     spec = case s of { ('=' : s') -> s';  _ -> s }
2597
2598 setVerbosity :: Maybe Int -> DynP ()
2599 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2600
2601 addCmdlineHCInclude :: String -> DynP ()
2602 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes =  a : cmdlineHcIncludes s})
2603
2604 data PkgConfRef
2605   = GlobalPkgConf
2606   | UserPkgConf
2607   | PkgConfFile FilePath
2608
2609 addPkgConfRef :: PkgConfRef -> DynP ()
2610 addPkgConfRef p = upd $ \s -> s { extraPkgConfs = (p:) . extraPkgConfs s }
2611
2612 removeUserPkgConf :: DynP ()
2613 removeUserPkgConf = upd $ \s -> s { extraPkgConfs = filter isNotUser . extraPkgConfs s }
2614   where
2615     isNotUser UserPkgConf = False
2616     isNotUser _ = True
2617
2618 removeGlobalPkgConf :: DynP ()
2619 removeGlobalPkgConf = upd $ \s -> s { extraPkgConfs = filter isNotGlobal . extraPkgConfs s }
2620   where
2621     isNotGlobal GlobalPkgConf = False
2622     isNotGlobal _ = True
2623
2624 clearPkgConf :: DynP ()
2625 clearPkgConf = upd $ \s -> s { extraPkgConfs = const [] }
2626
2627 exposePackage, exposePackageId, hidePackage, ignorePackage,
2628         trustPackage, distrustPackage :: String -> DynP ()
2629 exposePackage p =
2630   upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2631 exposePackageId p =
2632   upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2633 hidePackage p =
2634   upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2635 ignorePackage p =
2636   upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2637 trustPackage p = exposePackage p >> -- both trust and distrust also expose a package
2638   upd (\s -> s{ packageFlags = TrustPackage p : packageFlags s })
2639 distrustPackage p = exposePackage p >>
2640   upd (\s -> s{ packageFlags = DistrustPackage p : packageFlags s })
2641
2642 setPackageName :: String -> DynFlags -> DynFlags
2643 setPackageName p s =  s{ thisPackage = stringToPackageId p }
2644
2645 -- If we're linking a binary, then only targets that produce object
2646 -- code are allowed (requests for other target types are ignored).
2647 setTarget :: HscTarget -> DynP ()
2648 setTarget l = setTargetWithPlatform (const l)
2649
2650 setTargetWithPlatform :: (Platform -> HscTarget) -> DynP ()
2651 setTargetWithPlatform f = upd set
2652   where
2653    set dfs = let l = f (targetPlatform dfs)
2654              in if ghcLink dfs /= LinkBinary || isObjectTarget l
2655                 then dfs{ hscTarget = l }
2656                 else dfs
2657
2658 -- Changes the target only if we're compiling object code.  This is
2659 -- used by -fasm and -fllvm, which switch from one to the other, but
2660 -- not from bytecode to object-code.  The idea is that -fasm/-fllvm
2661 -- can be safely used in an OPTIONS_GHC pragma.
2662 setObjTarget :: HscTarget -> DynP ()
2663 setObjTarget l = updM set
2664   where
2665    set dflags
2666      | isObjectTarget (hscTarget dflags)
2667        = case l of
2668          HscC
2669           | platformUnregisterised (targetPlatform dflags) ->
2670              do addWarn ("Compiler not unregisterised, so ignoring " ++ flag)
2671                 return dflags
2672          HscAsm
2673           | cGhcWithNativeCodeGen /= "YES" ->
2674              do addWarn ("Compiler has no native codegen, so ignoring " ++
2675                          flag)
2676                 return dflags
2677          HscLlvm
2678           | not ((arch == ArchX86_64) && (os == OSLinux || os == OSDarwin)) &&
2679             (not opt_Static || dopt Opt_PIC dflags)
2680             ->
2681              do addWarn ("Ignoring " ++ flag ++ " as it is incompatible with -fPIC and -dynamic on this platform")
2682                 return dflags
2683          _ -> return $ dflags { hscTarget = l }
2684      | otherwise = return dflags
2685      where platform = targetPlatform dflags
2686            arch = platformArch platform
2687            os   = platformOS   platform
2688            flag = showHscTargetFlag l
2689
2690 setFPIC :: DynP ()
2691 setFPIC = updM set
2692   where
2693    set dflags
2694     | cGhcWithNativeCodeGen == "YES" || platformUnregisterised (targetPlatform dflags)
2695        = let platform = targetPlatform dflags
2696          in case hscTarget dflags of
2697             HscLlvm
2698              | (platformArch platform == ArchX86_64) &&
2699                (platformOS platform `elem` [OSLinux, OSDarwin]) ->
2700                 do addWarn "Ignoring -fPIC as it is incompatible with LLVM on this platform"
2701                    return dflags
2702             _ -> return $ dopt_set dflags Opt_PIC
2703     | otherwise
2704        = ghcError $ CmdLineError "-fPIC is not supported on this platform"
2705
2706 unSetFPIC :: DynP ()
2707 unSetFPIC = updM set
2708   where
2709    set dflags
2710        = let platform = targetPlatform dflags
2711          in case platformOS platform of
2712             OSDarwin
2713              | platformArch platform == ArchX86_64 ->
2714                 do addWarn "Ignoring -fno-PIC on this platform"
2715                    return dflags
2716             _ | not opt_Static ->
2717                 do addWarn "Ignoring -fno-PIC as -fstatic is off"
2718                    return dflags
2719             _ -> return $ dopt_unset dflags Opt_PIC
2720
2721 setOptLevel :: Int -> DynFlags -> DynP DynFlags
2722 setOptLevel n dflags
2723    | hscTarget dflags == HscInterpreted && n > 0
2724         = do addWarn "-O conflicts with --interactive; -O ignored."
2725              return dflags
2726    | otherwise
2727         = return (updOptLevel n dflags)
2728
2729
2730 -- -Odph is equivalent to
2731 --
2732 --    -O2                               optimise as much as possible
2733 --    -fmax-simplifier-iterations20     this is necessary sometimes
2734 --    -fsimplifier-phases=3             we use an additional simplifier phase for fusion
2735 --
2736 setDPHOpt :: DynFlags -> DynP DynFlags
2737 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations  = 20
2738                                          , simplPhases         = 3
2739                                          })
2740
2741 setMainIs :: String -> DynP ()
2742 setMainIs arg
2743   | not (null main_fn) && isLower (head main_fn)
2744      -- The arg looked like "Foo.Bar.baz"
2745   = upd $ \d -> d{ mainFunIs = Just main_fn,
2746                    mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2747
2748   | isUpper (head arg)  -- The arg looked like "Foo" or "Foo.Bar"
2749   = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2750
2751   | otherwise                   -- The arg looked like "baz"
2752   = upd $ \d -> d{ mainFunIs = Just arg }
2753   where
2754     (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2755
2756 -----------------------------------------------------------------------------
2757 -- Paths & Libraries
2758
2759 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2760
2761 -- -i on its own deletes the import paths
2762 addImportPath "" = upd (\s -> s{importPaths = []})
2763 addImportPath p  = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2764
2765 addLibraryPath p =
2766   upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2767
2768 addIncludePath p =
2769   upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2770
2771 addFrameworkPath p =
2772   upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2773
2774 #ifndef mingw32_TARGET_OS
2775 split_marker :: Char
2776 split_marker = ':'   -- not configurable (ToDo)
2777 #endif
2778
2779 splitPathList :: String -> [String]
2780 splitPathList s = filter notNull (splitUp s)
2781                 -- empty paths are ignored: there might be a trailing
2782                 -- ':' in the initial list, for example.  Empty paths can
2783                 -- cause confusion when they are translated into -I options
2784                 -- for passing to gcc.
2785   where
2786 #ifndef mingw32_TARGET_OS
2787     splitUp xs = split split_marker xs
2788 #else
2789      -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2790      --
2791      -- That is, if "foo:bar:baz" is used, this interpreted as
2792      -- consisting of three entries, 'foo', 'bar', 'baz'.
2793      -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2794      -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2795      --
2796      -- Notice that no attempt is made to fully replace the 'standard'
2797      -- split marker ':' with the Windows / DOS one, ';'. The reason being
2798      -- that this will cause too much breakage for users & ':' will
2799      -- work fine even with DOS paths, if you're not insisting on being silly.
2800      -- So, use either.
2801     splitUp []             = []
2802     splitUp (x:':':div:xs) | div `elem` dir_markers
2803                            = ((x:':':div:p): splitUp rs)
2804                            where
2805                               (p,rs) = findNextPath xs
2806           -- we used to check for existence of the path here, but that
2807           -- required the IO monad to be threaded through the command-line
2808           -- parser which is quite inconvenient.  The
2809     splitUp xs = cons p (splitUp rs)
2810                where
2811                  (p,rs) = findNextPath xs
2812
2813                  cons "" xs = xs
2814                  cons x  xs = x:xs
2815
2816     -- will be called either when we've consumed nought or the
2817     -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2818     -- finding the next split marker.
2819     findNextPath xs =
2820         case break (`elem` split_markers) xs of
2821            (p, _:ds) -> (p, ds)
2822            (p, xs)   -> (p, xs)
2823
2824     split_markers :: [Char]
2825     split_markers = [':', ';']
2826
2827     dir_markers :: [Char]
2828     dir_markers = ['/', '\\']
2829 #endif
2830
2831 -- -----------------------------------------------------------------------------
2832 -- tmpDir, where we store temporary files.
2833
2834 setTmpDir :: FilePath -> DynFlags -> DynFlags
2835 setTmpDir dir = alterSettings (\s -> s { sTmpDir = normalise dir })
2836   -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2837   -- seem necessary now --SDM 7/2/2008
2838
2839 -----------------------------------------------------------------------------
2840 -- RTS opts
2841
2842 setRtsOpts :: String -> DynP ()
2843 setRtsOpts arg  = upd $ \ d -> d {rtsOpts = Just arg}
2844
2845 setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
2846 setRtsOptsEnabled arg  = upd $ \ d -> d {rtsOptsEnabled = arg}
2847
2848 -----------------------------------------------------------------------------
2849 -- Hpc stuff
2850
2851 setOptHpcDir :: String -> DynP ()
2852 setOptHpcDir arg  = upd $ \ d -> d{hpcDir = arg}
2853
2854 -----------------------------------------------------------------------------
2855 -- Via-C compilation stuff
2856
2857 -- There are some options that we need to pass to gcc when compiling
2858 -- Haskell code via C, but are only supported by recent versions of
2859 -- gcc.  The configure script decides which of these options we need,
2860 -- and puts them in the "settings" file in $topdir. The advantage of
2861 -- having these in a separate file is that the file can be created at
2862 -- install-time depending on the available gcc version, and even
2863 -- re-generated later if gcc is upgraded.
2864 --
2865 -- The options below are not dependent on the version of gcc, only the
2866 -- platform.
2867
2868 picCCOpts :: DynFlags -> [String]
2869 picCCOpts dflags
2870     = case platformOS (targetPlatform dflags) of
2871       OSDarwin
2872           -- Apple prefers to do things the other way round.
2873           -- PIC is on by default.
2874           -- -mdynamic-no-pic:
2875           --     Turn off PIC code generation.
2876           -- -fno-common:
2877           --     Don't generate "common" symbols - these are unwanted
2878           --     in dynamic libraries.
2879
2880        | dopt Opt_PIC dflags -> ["-fno-common", "-U __PIC__", "-D__PIC__"]
2881        | otherwise           -> ["-mdynamic-no-pic"]
2882       OSMinGW32 -- no -fPIC for Windows
2883        | dopt Opt_PIC dflags -> ["-U __PIC__", "-D__PIC__"]
2884        | otherwise           -> []
2885       _
2886       -- we need -fPIC for C files when we are compiling with -dynamic,
2887       -- otherwise things like stub.c files don't get compiled
2888       -- correctly.  They need to reference data in the Haskell
2889       -- objects, but can't without -fPIC.  See
2890       -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2891        | dopt Opt_PIC dflags || not opt_Static -> ["-fPIC", "-U __PIC__", "-D__PIC__"]
2892        | otherwise                             -> []
2893
2894 picPOpts :: DynFlags -> [String]
2895 picPOpts dflags
2896  | dopt Opt_PIC dflags = ["-U __PIC__", "-D__PIC__"]
2897  | otherwise           = []
2898
2899 -- -----------------------------------------------------------------------------
2900 -- Splitting
2901
2902 can_split :: Bool
2903 can_split = cSupportsSplitObjs == "YES"
2904
2905 -- -----------------------------------------------------------------------------
2906 -- Compiler Info
2907
2908 compilerInfo :: DynFlags -> [(String, String)]
2909 compilerInfo dflags
2910     = -- We always make "Project name" be first to keep parsing in
2911       -- other languages simple, i.e. when looking for other fields,
2912       -- you don't have to worry whether there is a leading '[' or not
2913       ("Project name",                 cProjectName)
2914       -- Next come the settings, so anything else can be overridden
2915       -- in the settings file (as "lookup" uses the first match for the
2916       -- key)
2917     : rawSettings dflags
2918    ++ [("Project version",             cProjectVersion),
2919        ("Booter version",              cBooterVersion),
2920        ("Stage",                       cStage),
2921        ("Build platform",              cBuildPlatformString),
2922        ("Host platform",               cHostPlatformString),
2923        ("Target platform",             cTargetPlatformString),
2924        ("Have interpreter",            cGhcWithInterpreter),
2925        ("Object splitting supported",  cSupportsSplitObjs),
2926        ("Have native code generator",  cGhcWithNativeCodeGen),
2927        ("Support SMP",                 cGhcWithSMP),
2928        ("Tables next to code",         cGhcEnableTablesNextToCode),
2929        ("RTS ways",                    cGhcRTSWays),
2930        ("Leading underscore",          cLeadingUnderscore),
2931        ("Debug on",                    show debugIsOn),
2932        ("LibDir",                      topDir dflags),
2933        ("Global Package DB",           systemPackageConfig dflags)
2934       ]
2935