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