compiler/main/DynFlags.hs

   1 -- |
   2 -- Dynamic flags
   3 --
   4 --
   5 -- (c) The University of Glasgow 2005
   6 --
   7
   8 -- Most flags are dynamic flags, which means they can change from
   9 -- compilation to compilation using @OPTIONS_GHC@ pragmas, and in a
  10 -- multi-session GHC each session can be using different dynamic
  11 -- flags.  Dynamic flags can also be set at the prompt in GHCi.
  12 module DynFlags (
  13         -- * Dynamic flags and associated configuration types
  14         DynFlag(..),
  15         ExtensionFlag(..),
  16         glasgowExtsFlags,
  17         dopt,
  18         dopt_set,
  19         dopt_unset,
  20         xopt,
  21         xopt_set,
  22         xopt_unset,
  23         DynFlags(..),
  24         RtsOptsEnabled(..),
  25         HscTarget(..), isObjectTarget, defaultObjectTarget,
  26         GhcMode(..), isOneShot,
  27         GhcLink(..), isNoLink,
  28         PackageFlag(..),
  29         Option(..), showOpt,
  30         DynLibLoader(..),
  31         fFlags, fLangFlags, xFlags,
  32         DPHBackend(..), dphPackageMaybe,
  33         wayNames,
  34
  35         Settings(..),
  36         ghcUsagePath, ghciUsagePath, topDir, tmpDir, rawSettings,
  37         extraGccViaCFlags, systemPackageConfig,
  38         pgm_L, pgm_P, pgm_F, pgm_c, pgm_s, pgm_a, pgm_l, pgm_dll, pgm_T,
  39         pgm_sysman, pgm_windres, pgm_lo, pgm_lc,
  40         opt_L, opt_P, opt_F, opt_c, opt_m, opt_a, opt_l,
  41         opt_windres, opt_lo, opt_lc,
  42
  43
  44         -- ** Manipulating DynFlags
  45         defaultDynFlags,                -- Settings -> DynFlags
  46         initDynFlags,                   -- DynFlags -> IO DynFlags
  47
  48         getOpts,                        -- DynFlags -> (DynFlags -> [a]) -> [a]
  49         getVerbFlags,
  50         updOptLevel,
  51         setTmpDir,
  52         setPackageName,
  53         doingTickyProfiling,
  54
  55         -- ** Parsing DynFlags
  56         parseDynamicFlags,
  57         parseDynamicNoPackageFlags,
  58         allFlags,
  59
  60         supportedLanguagesAndExtensions,
  61
  62         -- ** DynFlag C compiler options
  63         picCCOpts,
  64
  65         -- * Configuration of the stg-to-stg passes
  66         StgToDo(..),
  67         getStgToDo,
  68
  69         -- * Compiler configuration suitable for display to the user
  70         compilerInfo
  71 #ifdef GHCI
  72 -- Only in stage 2 can we be sure that the RTS
  73 -- exposes the appropriate runtime boolean
  74         , rtsIsProfiled
  75 #endif
  76   ) where
  77
  78 #include "HsVersions.h"
  79
  80 import Platform
  81 import Module
  82 import PackageConfig
  83 import PrelNames        ( mAIN )
  84 import StaticFlags
  85 import {-# SOURCE #-} Packages (PackageState)
  86 import DriverPhases     ( Phase(..), phaseInputExt )
  87 import Config
  88 import CmdLineParser
  89 import Constants        ( mAX_CONTEXT_REDUCTION_DEPTH )
  90 import Panic
  91 import Util
  92 import Maybes           ( orElse )
  93 import SrcLoc
  94 import FastString
  95 import Outputable
  96 #ifdef GHCI
  97 import Foreign.C        ( CInt )
  98 #endif
  99 import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
 100
 101 #ifdef GHCI
 102 import System.IO.Unsafe ( unsafePerformIO )
 103 #endif
 104 import Data.IORef
 105 import Control.Monad    ( when )
 106
 107 import Data.Char
 108 import Data.List
 109 import Data.Map (Map)
 110 import qualified Data.Map as Map
 111 import Data.Set (Set)
 112 import qualified Data.Set as Set
 113 import System.FilePath
 114 import System.IO        ( stderr, hPutChar )
 115
 116 -- -----------------------------------------------------------------------------
 117 -- DynFlags
 118
 119 -- | Enumerates the simple on-or-off dynamic flags
 120 data DynFlag
 121
 122    -- debugging flags
 123    = Opt_D_dump_cmm
 124    | Opt_D_dump_raw_cmm
 125    | Opt_D_dump_cmmz
 126    | Opt_D_dump_cmmz_pretty
 127    -- All of the cmmz subflags (there are a lot!)  Automatically
 128    -- enabled if you run -ddump-cmmz
 129    | Opt_D_dump_cmmz_cbe
 130    | Opt_D_dump_cmmz_proc
 131    | Opt_D_dump_cmmz_spills
 132    | Opt_D_dump_cmmz_rewrite
 133    | Opt_D_dump_cmmz_dead
 134    | Opt_D_dump_cmmz_stub
 135    | Opt_D_dump_cmmz_sp
 136    | Opt_D_dump_cmmz_procmap
 137    | Opt_D_dump_cmmz_split
 138    | Opt_D_dump_cmmz_lower
 139    | Opt_D_dump_cmmz_info
 140    | Opt_D_dump_cmmz_cafs
 141    -- end cmmz subflags
 142    | Opt_D_dump_cps_cmm
 143    | Opt_D_dump_cvt_cmm
 144    | Opt_D_dump_asm
 145    | Opt_D_dump_asm_native
 146    | Opt_D_dump_asm_liveness
 147    | Opt_D_dump_asm_coalesce
 148    | Opt_D_dump_asm_regalloc
 149    | Opt_D_dump_asm_regalloc_stages
 150    | Opt_D_dump_asm_conflicts
 151    | Opt_D_dump_asm_stats
 152    | Opt_D_dump_asm_expanded
 153    | Opt_D_dump_llvm
 154    | Opt_D_dump_core_stats
 155    | Opt_D_dump_cpranal
 156    | Opt_D_dump_deriv
 157    | Opt_D_dump_ds
 158    | Opt_D_dump_flatC
 159    | Opt_D_dump_foreign
 160    | Opt_D_dump_inlinings
 161    | Opt_D_dump_rule_firings
 162    | Opt_D_dump_rule_rewrites
 163    | Opt_D_dump_occur_anal
 164    | Opt_D_dump_parsed
 165    | Opt_D_dump_rn
 166    | Opt_D_dump_simpl
 167    | Opt_D_dump_simpl_iterations
 168    | Opt_D_dump_simpl_phases
 169    | Opt_D_dump_spec
 170    | Opt_D_dump_prep
 171    | Opt_D_dump_stg
 172    | Opt_D_dump_stranal
 173    | Opt_D_dump_tc
 174    | Opt_D_dump_types
 175    | Opt_D_dump_rules
 176    | Opt_D_dump_cse
 177    | Opt_D_dump_worker_wrapper
 178    | Opt_D_dump_rn_trace
 179    | Opt_D_dump_rn_stats
 180    | Opt_D_dump_opt_cmm
 181    | Opt_D_dump_simpl_stats
 182    | Opt_D_dump_cs_trace        -- Constraint solver in type checker
 183    | Opt_D_dump_tc_trace
 184    | Opt_D_dump_if_trace
 185    | Opt_D_dump_vt_trace
 186    | Opt_D_dump_splices
 187    | Opt_D_dump_BCOs
 188    | Opt_D_dump_vect
 189    | Opt_D_dump_hpc
 190    | Opt_D_dump_rtti
 191    | Opt_D_source_stats
 192    | Opt_D_verbose_core2core
 193    | Opt_D_verbose_stg2stg
 194    | Opt_D_dump_hi
 195    | Opt_D_dump_hi_diffs
 196    | Opt_D_dump_minimal_imports
 197    | Opt_D_dump_mod_cycles
 198    | Opt_D_dump_view_pattern_commoning
 199    | Opt_D_faststring_stats
 200    | Opt_DumpToFile                     -- ^ Append dump output to files instead of stdout.
 201    | Opt_D_no_debug_output
 202    | Opt_DoCoreLinting
 203    | Opt_DoStgLinting
 204    | Opt_DoCmmLinting
 205    | Opt_DoAsmLinting
 206
 207    | Opt_F_coqpass                      -- run the core-to-core coqPass, but don't change anything (just "parse/unparse")
 208    | Opt_F_skolemize                    -- run the core-to-core coqPass, skolemizing the proof
 209    | Opt_F_flatten                      -- run the core-to-core coqPass, flattening the proof
 210    | Opt_F_simpleopt_before_flatten     -- run the "simplPgmOpt" before the coqPass
 211    | Opt_D_dump_proofs                  -- dump natural deduction typing proof of the coqpass input
 212    | Opt_D_coqpass                      -- run the core-to-string coqPass and dumps the result
 213
 214    | Opt_WarnIsError                    -- -Werror; makes warnings fatal
 215    | Opt_WarnDuplicateExports
 216    | Opt_WarnHiShadows
 217    | Opt_WarnImplicitPrelude
 218    | Opt_WarnIncompletePatterns
 219    | Opt_WarnIncompleteUniPatterns
 220    | Opt_WarnIncompletePatternsRecUpd
 221    | Opt_WarnMissingFields
 222    | Opt_WarnMissingImportList
 223    | Opt_WarnMissingMethods
 224    | Opt_WarnMissingSigs
 225    | Opt_WarnMissingLocalSigs
 226    | Opt_WarnNameShadowing
 227    | Opt_WarnOverlappingPatterns
 228    | Opt_WarnTypeDefaults
 229    | Opt_WarnMonomorphism
 230    | Opt_WarnUnusedBinds
 231    | Opt_WarnUnusedImports
 232    | Opt_WarnUnusedMatches
 233    | Opt_WarnWarningsDeprecations
 234    | Opt_WarnDeprecatedFlags
 235    | Opt_WarnDodgyExports
 236    | Opt_WarnDodgyImports
 237    | Opt_WarnOrphans
 238    | Opt_WarnAutoOrphans
 239    | Opt_WarnIdentities
 240    | Opt_WarnTabs
 241    | Opt_WarnUnrecognisedPragmas
 242    | Opt_WarnDodgyForeignImports
 243    | Opt_WarnLazyUnliftedBindings
 244    | Opt_WarnUnusedDoBind
 245    | Opt_WarnWrongDoBind
 246    | Opt_WarnAlternativeLayoutRuleTransitional
 247
 248    | Opt_PrintExplicitForalls
 249
 250    -- optimisation opts
 251    | Opt_Strictness
 252    | Opt_FullLaziness
 253    | Opt_FloatIn
 254    | Opt_Specialise
 255    | Opt_StaticArgumentTransformation
 256    | Opt_CSE
 257    | Opt_LiberateCase
 258    | Opt_SpecConstr
 259    | Opt_DoLambdaEtaExpansion
 260    | Opt_IgnoreAsserts
 261    | Opt_DoEtaReduction
 262    | Opt_CaseMerge
 263    | Opt_UnboxStrictFields
 264    | Opt_MethodSharing  -- Now a no-op; remove in GHC 7.2
 265    | Opt_DictsCheap
 266    | Opt_EnableRewriteRules             -- Apply rewrite rules during simplification
 267    | Opt_Vectorise
 268    | Opt_RegsGraph                      -- do graph coloring register allocation
 269    | Opt_RegsIterative                  -- do iterative coalescing graph coloring register allocation
 270
 271    -- Interface files
 272    | Opt_IgnoreInterfacePragmas
 273    | Opt_OmitInterfacePragmas
 274    | Opt_ExposeAllUnfoldings
 275
 276    -- profiling opts
 277    | Opt_AutoSccsOnAllToplevs
 278    | Opt_AutoSccsOnExportedToplevs
 279    | Opt_AutoSccsOnIndividualCafs
 280
 281    -- misc opts
 282    | Opt_Pp
 283    | Opt_ForceRecomp
 284    | Opt_ExcessPrecision
 285    | Opt_EagerBlackHoling
 286    | Opt_ReadUserPackageConf
 287    | Opt_NoHsMain
 288    | Opt_SplitObjs
 289    | Opt_StgStats
 290    | Opt_HideAllPackages
 291    | Opt_PrintBindResult
 292    | Opt_Haddock
 293    | Opt_HaddockOptions
 294    | Opt_Hpc_No_Auto
 295    | Opt_BreakOnException
 296    | Opt_BreakOnError
 297    | Opt_PrintEvldWithShow
 298    | Opt_PrintBindContents
 299    | Opt_GenManifest
 300    | Opt_EmbedManifest
 301    | Opt_EmitExternalCore
 302    | Opt_SharedImplib
 303    | Opt_BuildingCabalPackage
 304    | Opt_SSE2
 305    | Opt_GhciSandbox
 306    | Opt_HelpfulErrors
 307
 308         -- temporary flags
 309    | Opt_RunCPS
 310    | Opt_RunCPSZ
 311    | Opt_ConvertToZipCfgAndBack
 312    | Opt_AutoLinkPackages
 313    | Opt_ImplicitImportQualified
 314    | Opt_TryNewCodeGen
 315
 316    -- keeping stuff
 317    | Opt_KeepHiDiffs
 318    | Opt_KeepHcFiles
 319    | Opt_KeepSFiles
 320    | Opt_KeepTmpFiles
 321    | Opt_KeepRawTokenStream
 322    | Opt_KeepLlvmFiles
 323
 324    deriving (Eq, Show)
 325
 326 data Language = Haskell98 | Haskell2010
 327
 328 data ExtensionFlag
 329    = Opt_Cpp
 330    | Opt_OverlappingInstances
 331    | Opt_UndecidableInstances
 332    | Opt_IncoherentInstances
 333    | Opt_MonomorphismRestriction
 334    | Opt_MonoPatBinds
 335    | Opt_MonoLocalBinds
 336    | Opt_RelaxedPolyRec         -- Deprecated
 337    | Opt_ExtendedDefaultRules           -- Use GHC's extended rules for defaulting
 338    | Opt_ForeignFunctionInterface
 339    | Opt_UnliftedFFITypes
 340    | Opt_GHCForeignImportPrim
 341    | Opt_ParallelArrays                 -- Syntactic support for parallel arrays
 342    | Opt_Arrows                         -- Arrow-notation syntax
 343    | Opt_ModalTypes                     -- Heterogeneous Metaprogramming (modal types, brackets, escape, CSP)
 344    | Opt_TemplateHaskell
 345    | Opt_QuasiQuotes
 346    | Opt_ImplicitParams
 347    | Opt_ImplicitPrelude
 348    | Opt_ScopedTypeVariables
 349    | Opt_UnboxedTuples
 350    | Opt_BangPatterns
 351    | Opt_TypeFamilies
 352    | Opt_OverloadedStrings
 353    | Opt_DisambiguateRecordFields
 354    | Opt_RecordWildCards
 355    | Opt_RecordPuns
 356    | Opt_ViewPatterns
 357    | Opt_GADTs
 358    | Opt_GADTSyntax
 359    | Opt_NPlusKPatterns
 360    | Opt_DoAndIfThenElse
 361    | Opt_RebindableSyntax
 362
 363    | Opt_StandaloneDeriving
 364    | Opt_DeriveDataTypeable
 365    | Opt_DeriveFunctor
 366    | Opt_DeriveTraversable
 367    | Opt_DeriveFoldable
 368    | Opt_DeriveGeneric            -- Allow deriving Generic/1
 369    | Opt_DefaultSignatures        -- Allow extra signatures for defmeths
 370    | Opt_Generics                 -- Old generic classes, now deprecated
 371
 372    | Opt_TypeSynonymInstances
 373    | Opt_FlexibleContexts
 374    | Opt_FlexibleInstances
 375    | Opt_ConstrainedClassMethods
 376    | Opt_MultiParamTypeClasses
 377    | Opt_FunctionalDependencies
 378    | Opt_UnicodeSyntax
 379    | Opt_PolymorphicComponents
 380    | Opt_ExistentialQuantification
 381    | Opt_MagicHash
 382    | Opt_EmptyDataDecls
 383    | Opt_KindSignatures
 384    | Opt_ParallelListComp
 385    | Opt_TransformListComp
 386    | Opt_MonadComprehensions
 387    | Opt_GeneralizedNewtypeDeriving
 388    | Opt_RecursiveDo
 389    | Opt_DoRec
 390    | Opt_PostfixOperators
 391    | Opt_TupleSections
 392    | Opt_PatternGuards
 393    | Opt_LiberalTypeSynonyms
 394    | Opt_Rank2Types
 395    | Opt_RankNTypes
 396    | Opt_ImpredicativeTypes
 397    | Opt_TypeOperators
 398    | Opt_PackageImports
 399    | Opt_ExplicitForAll
 400    | Opt_AlternativeLayoutRule
 401    | Opt_AlternativeLayoutRuleTransitional
 402    | Opt_DatatypeContexts
 403    | Opt_NondecreasingIndentation
 404    | Opt_RelaxedLayout
 405    deriving (Eq, Show)
 406
 407 -- | Contains not only a collection of 'DynFlag's but also a plethora of
 408 -- information relating to the compilation of a single file or GHC session
 409 data DynFlags = DynFlags {
 410   ghcMode               :: GhcMode,
 411   ghcLink               :: GhcLink,
 412   hscTarget             :: HscTarget,
 413   hscOutName            :: String,      -- ^ Name of the output file
 414   extCoreName           :: String,      -- ^ Name of the .hcr output file
 415   verbosity             :: Int,         -- ^ Verbosity level: see Note [Verbosity levels]
 416   optLevel              :: Int,         -- ^ Optimisation level
 417   simplPhases           :: Int,         -- ^ Number of simplifier phases
 418   maxSimplIterations    :: Int,         -- ^ Max simplifier iterations
 419   shouldDumpSimplPhase  :: Maybe String,
 420   ruleCheck             :: Maybe String,
 421   strictnessBefore      :: [Int],       -- ^ Additional demand analysis
 422
 423   specConstrThreshold   :: Maybe Int,   -- ^ Threshold for SpecConstr
 424   specConstrCount       :: Maybe Int,   -- ^ Max number of specialisations for any one function
 425   liberateCaseThreshold :: Maybe Int,   -- ^ Threshold for LiberateCase
 426   floatLamArgs          :: Maybe Int,   -- ^ Arg count for lambda floating
 427                                         --   See CoreMonad.FloatOutSwitches
 428
 429   targetPlatform        :: Platform.Platform, -- ^ The platform we're compiling for. Used by the NCG.
 430   cmdlineHcIncludes     :: [String],    -- ^ @\-\#includes@
 431   importPaths           :: [FilePath],
 432   mainModIs             :: Module,
 433   mainFunIs             :: Maybe String,
 434   ctxtStkDepth          :: Int,         -- ^ Typechecker context stack depth
 435
 436   dphBackend            :: DPHBackend,
 437
 438   thisPackage           :: PackageId,   -- ^ name of package currently being compiled
 439
 440   -- ways
 441   ways                  :: [Way],       -- ^ Way flags from the command line
 442   buildTag              :: String,      -- ^ The global \"way\" (e.g. \"p\" for prof)
 443   rtsBuildTag           :: String,      -- ^ The RTS \"way\"
 444
 445   -- For object splitting
 446   splitInfo             :: Maybe (String,Int),
 447
 448   -- paths etc.
 449   objectDir             :: Maybe String,
 450   dylibInstallName      :: Maybe String,
 451   hiDir                 :: Maybe String,
 452   stubDir               :: Maybe String,
 453
 454   objectSuf             :: String,
 455   hcSuf                 :: String,
 456   hiSuf                 :: String,
 457
 458   outputFile            :: Maybe String,
 459   outputHi              :: Maybe String,
 460   dynLibLoader          :: DynLibLoader,
 461
 462   -- | This is set by 'DriverPipeline.runPipeline' based on where
 463   --    its output is going.
 464   dumpPrefix            :: Maybe FilePath,
 465
 466   -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
 467   --    Set by @-ddump-file-prefix@
 468   dumpPrefixForce       :: Maybe FilePath,
 469
 470   includePaths          :: [String],
 471   libraryPaths          :: [String],
 472   frameworkPaths        :: [String],    -- used on darwin only
 473   cmdlineFrameworks     :: [String],    -- ditto
 474
 475   rtsOpts               :: Maybe String,
 476   rtsOptsEnabled        :: RtsOptsEnabled,
 477
 478   hpcDir                :: String,      -- ^ Path to store the .mix files
 479
 480   settings              :: Settings,
 481
 482   --  For ghc -M
 483   depMakefile           :: FilePath,
 484   depIncludePkgDeps     :: Bool,
 485   depExcludeMods        :: [ModuleName],
 486   depSuffixes           :: [String],
 487
 488   --  Package flags
 489   extraPkgConfs         :: [FilePath],
 490         -- ^ The @-package-conf@ flags given on the command line, in the order
 491         -- they appeared.
 492
 493   packageFlags          :: [PackageFlag],
 494         -- ^ The @-package@ and @-hide-package@ flags from the command-line
 495
 496   -- Package state
 497   -- NB. do not modify this field, it is calculated by
 498   -- Packages.initPackages and Packages.updatePackages.
 499   pkgDatabase           :: Maybe [PackageConfig],
 500   pkgState              :: PackageState,
 501
 502   -- Temporary files
 503   -- These have to be IORefs, because the defaultCleanupHandler needs to
 504   -- know what to clean when an exception happens
 505   filesToClean          :: IORef [FilePath],
 506   dirsToClean           :: IORef (Map FilePath FilePath),
 507
 508   -- Names of files which were generated from -ddump-to-file; used to
 509   -- track which ones we need to truncate because it's our first run
 510   -- through
 511   generatedDumps        :: IORef (Set FilePath),
 512
 513   -- hsc dynamic flags
 514   flags                 :: [DynFlag],
 515   -- Don't change this without updating extensionFlags:
 516   language              :: Maybe Language,
 517   -- Don't change this without updating extensionFlags:
 518   extensions            :: [OnOff ExtensionFlag],
 519   -- extensionFlags should always be equal to
 520   --     flattenExtensionFlags language extensions
 521   extensionFlags        :: [ExtensionFlag],
 522
 523   -- | Message output action: use "ErrUtils" instead of this if you can
 524   log_action            :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
 525
 526   haddockOptions :: Maybe String
 527  }
 528
 529 data Settings = Settings {
 530   sGhcUsagePath          :: FilePath,    -- Filled in by SysTools
 531   sGhciUsagePath         :: FilePath,    -- ditto
 532   sTopDir                :: FilePath,
 533   sTmpDir                :: String,      -- no trailing '/'
 534   -- You shouldn't need to look things up in rawSettings directly.
 535   -- They should have their own fields instead.
 536   sRawSettings           :: [(String, String)],
 537   sExtraGccViaCFlags     :: [String],
 538   sSystemPackageConfig   :: FilePath,
 539   -- commands for particular phases
 540   sPgm_L                 :: String,
 541   sPgm_P                 :: (String,[Option]),
 542   sPgm_F                 :: String,
 543   sPgm_c                 :: (String,[Option]),
 544   sPgm_s                 :: (String,[Option]),
 545   sPgm_a                 :: (String,[Option]),
 546   sPgm_l                 :: (String,[Option]),
 547   sPgm_dll               :: (String,[Option]),
 548   sPgm_T                 :: String,
 549   sPgm_sysman            :: String,
 550   sPgm_windres           :: String,
 551   sPgm_lo                :: (String,[Option]), -- LLVM: opt llvm optimiser
 552   sPgm_lc                :: (String,[Option]), -- LLVM: llc static compiler
 553   -- options for particular phases
 554   sOpt_L                 :: [String],
 555   sOpt_P                 :: [String],
 556   sOpt_F                 :: [String],
 557   sOpt_c                 :: [String],
 558   sOpt_m                 :: [String],
 559   sOpt_a                 :: [String],
 560   sOpt_l                 :: [String],
 561   sOpt_windres           :: [String],
 562   sOpt_lo                :: [String], -- LLVM: llvm optimiser
 563   sOpt_lc                :: [String]  -- LLVM: llc static compiler
 564
 565  }
 566
 567 ghcUsagePath          :: DynFlags -> FilePath
 568 ghcUsagePath dflags = sGhcUsagePath (settings dflags)
 569 ghciUsagePath         :: DynFlags -> FilePath
 570 ghciUsagePath dflags = sGhciUsagePath (settings dflags)
 571 topDir                :: DynFlags -> FilePath
 572 topDir dflags = sTopDir (settings dflags)
 573 tmpDir                :: DynFlags -> String
 574 tmpDir dflags = sTmpDir (settings dflags)
 575 rawSettings           :: DynFlags -> [(String, String)]
 576 rawSettings dflags = sRawSettings (settings dflags)
 577 extraGccViaCFlags     :: DynFlags -> [String]
 578 extraGccViaCFlags dflags = sExtraGccViaCFlags (settings dflags)
 579 systemPackageConfig   :: DynFlags -> FilePath
 580 systemPackageConfig dflags = sSystemPackageConfig (settings dflags)
 581 pgm_L                 :: DynFlags -> String
 582 pgm_L dflags = sPgm_L (settings dflags)
 583 pgm_P                 :: DynFlags -> (String,[Option])
 584 pgm_P dflags = sPgm_P (settings dflags)
 585 pgm_F                 :: DynFlags -> String
 586 pgm_F dflags = sPgm_F (settings dflags)
 587 pgm_c                 :: DynFlags -> (String,[Option])
 588 pgm_c dflags = sPgm_c (settings dflags)
 589 pgm_s                 :: DynFlags -> (String,[Option])
 590 pgm_s dflags = sPgm_s (settings dflags)
 591 pgm_a                 :: DynFlags -> (String,[Option])
 592 pgm_a dflags = sPgm_a (settings dflags)
 593 pgm_l                 :: DynFlags -> (String,[Option])
 594 pgm_l dflags = sPgm_l (settings dflags)
 595 pgm_dll               :: DynFlags -> (String,[Option])
 596 pgm_dll dflags = sPgm_dll (settings dflags)
 597 pgm_T                 :: DynFlags -> String
 598 pgm_T dflags = sPgm_T (settings dflags)
 599 pgm_sysman            :: DynFlags -> String
 600 pgm_sysman dflags = sPgm_sysman (settings dflags)
 601 pgm_windres           :: DynFlags -> String
 602 pgm_windres dflags = sPgm_windres (settings dflags)
 603 pgm_lo                :: DynFlags -> (String,[Option])
 604 pgm_lo dflags = sPgm_lo (settings dflags)
 605 pgm_lc                :: DynFlags -> (String,[Option])
 606 pgm_lc dflags = sPgm_lc (settings dflags)
 607 opt_L                 :: DynFlags -> [String]
 608 opt_L dflags = sOpt_L (settings dflags)
 609 opt_P                 :: DynFlags -> [String]
 610 opt_P dflags = sOpt_P (settings dflags)
 611 opt_F                 :: DynFlags -> [String]
 612 opt_F dflags = sOpt_F (settings dflags)
 613 opt_c                 :: DynFlags -> [String]
 614 opt_c dflags = sOpt_c (settings dflags)
 615 opt_m                 :: DynFlags -> [String]
 616 opt_m dflags = sOpt_m (settings dflags)
 617 opt_a                 :: DynFlags -> [String]
 618 opt_a dflags = sOpt_a (settings dflags)
 619 opt_l                 :: DynFlags -> [String]
 620 opt_l dflags = sOpt_l (settings dflags)
 621 opt_windres           :: DynFlags -> [String]
 622 opt_windres dflags = sOpt_windres (settings dflags)
 623 opt_lo                :: DynFlags -> [String]
 624 opt_lo dflags = sOpt_lo (settings dflags)
 625 opt_lc                :: DynFlags -> [String]
 626 opt_lc dflags = sOpt_lc (settings dflags)
 627
 628 wayNames :: DynFlags -> [WayName]
 629 wayNames = map wayName . ways
 630
 631 -- | The target code type of the compilation (if any).
 632 --
 633 -- Whenever you change the target, also make sure to set 'ghcLink' to
 634 -- something sensible.
 635 --
 636 -- 'HscNothing' can be used to avoid generating any output, however, note
 637 -- that:
 638 --
 639 --  * This will not run the desugaring step, thus no warnings generated in
 640 --    this step will be output.  In particular, this includes warnings related
 641 --    to pattern matching.  You can run the desugarer manually using
 642 --    'GHC.desugarModule'.
 643 --
 644 --  * If a program uses Template Haskell the typechecker may try to run code
 645 --    from an imported module.  This will fail if no code has been generated
 646 --    for this module.  You can use 'GHC.needsTemplateHaskell' to detect
 647 --    whether this might be the case and choose to either switch to a
 648 --    different target or avoid typechecking such modules.  (The latter may
 649 --    preferable for security reasons.)
 650 --
 651 data HscTarget
 652   = HscC           -- ^ Generate C code.
 653   | HscAsm         -- ^ Generate assembly using the native code generator.
 654   | HscLlvm        -- ^ Generate assembly using the llvm code generator.
 655   | HscJava        -- ^ Generate Java bytecode.
 656   | HscInterpreted -- ^ Generate bytecode.  (Requires 'LinkInMemory')
 657   | HscNothing     -- ^ Don't generate any code.  See notes above.
 658   deriving (Eq, Show)
 659
 660 showHscTargetFlag :: HscTarget -> String
 661 showHscTargetFlag HscC           = "-fvia-c"
 662 showHscTargetFlag HscAsm         = "-fasm"
 663 showHscTargetFlag HscLlvm        = "-fllvm"
 664 showHscTargetFlag HscJava        = panic "No flag for HscJava"
 665 showHscTargetFlag HscInterpreted = "-fbyte-code"
 666 showHscTargetFlag HscNothing     = "-fno-code"
 667
 668 -- | Will this target result in an object file on the disk?
 669 isObjectTarget :: HscTarget -> Bool
 670 isObjectTarget HscC     = True
 671 isObjectTarget HscAsm   = True
 672 isObjectTarget HscLlvm  = True
 673 isObjectTarget _        = False
 674
 675 -- | The 'GhcMode' tells us whether we're doing multi-module
 676 -- compilation (controlled via the "GHC" API) or one-shot
 677 -- (single-module) compilation.  This makes a difference primarily to
 678 -- the "Finder": in one-shot mode we look for interface files for
 679 -- imported modules, but in multi-module mode we look for source files
 680 -- in order to check whether they need to be recompiled.
 681 data GhcMode
 682   = CompManager         -- ^ @\-\-make@, GHCi, etc.
 683   | OneShot             -- ^ @ghc -c Foo.hs@
 684   | MkDepend            -- ^ @ghc -M@, see "Finder" for why we need this
 685   deriving Eq
 686
 687 instance Outputable GhcMode where
 688   ppr CompManager = ptext (sLit "CompManager")
 689   ppr OneShot     = ptext (sLit "OneShot")
 690   ppr MkDepend    = ptext (sLit "MkDepend")
 691
 692 isOneShot :: GhcMode -> Bool
 693 isOneShot OneShot = True
 694 isOneShot _other  = False
 695
 696 -- | What to do in the link step, if there is one.
 697 data GhcLink
 698   = NoLink              -- ^ Don't link at all
 699   | LinkBinary          -- ^ Link object code into a binary
 700   | LinkInMemory        -- ^ Use the in-memory dynamic linker (works for both
 701                         --   bytecode and object code).
 702   | LinkDynLib          -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
 703   deriving (Eq, Show)
 704
 705 isNoLink :: GhcLink -> Bool
 706 isNoLink NoLink = True
 707 isNoLink _      = False
 708
 709 -- Is it worth evaluating this Bool and caching it in the DynFlags value
 710 -- during initDynFlags?
 711 doingTickyProfiling :: DynFlags -> Bool
 712 doingTickyProfiling _ = opt_Ticky
 713   -- XXX -ticky is a static flag, because it implies -debug which is also
 714   -- static.  If the way flags were made dynamic, we could fix this.
 715
 716 data PackageFlag
 717   = ExposePackage  String
 718   | ExposePackageId String
 719   | HidePackage    String
 720   | IgnorePackage  String
 721   deriving Eq
 722
 723 defaultHscTarget :: HscTarget
 724 defaultHscTarget = defaultObjectTarget
 725
 726 -- | The 'HscTarget' value corresponding to the default way to create
 727 -- object files on the current platform.
 728 defaultObjectTarget :: HscTarget
 729 defaultObjectTarget
 730   | cGhcUnregisterised    == "YES"      =  HscC
 731   | cGhcWithNativeCodeGen == "YES"      =  HscAsm
 732   | otherwise                           =  HscLlvm
 733
 734 data DynLibLoader
 735   = Deployable
 736   | SystemDependent
 737   deriving Eq
 738
 739 data RtsOptsEnabled = RtsOptsNone | RtsOptsSafeOnly | RtsOptsAll
 740   deriving (Show)
 741
 742 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
 743 initDynFlags :: DynFlags -> IO DynFlags
 744 initDynFlags dflags = do
 745  -- someday these will be dynamic flags
 746  ways <- readIORef v_Ways
 747  refFilesToClean <- newIORef []
 748  refDirsToClean <- newIORef Map.empty
 749  refGeneratedDumps <- newIORef Set.empty
 750  return dflags{
 751         ways            = ways,
 752         buildTag        = mkBuildTag (filter (not . wayRTSOnly) ways),
 753         rtsBuildTag     = mkBuildTag ways,
 754         filesToClean    = refFilesToClean,
 755         dirsToClean     = refDirsToClean,
 756         generatedDumps   = refGeneratedDumps
 757         }
 758
 759 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
 760 -- and must be fully initialized by 'GHC.newSession' first.
 761 defaultDynFlags :: Settings -> DynFlags
 762 defaultDynFlags mySettings =
 763      DynFlags {
 764         ghcMode                 = CompManager,
 765         ghcLink                 = LinkBinary,
 766         hscTarget               = defaultHscTarget,
 767         hscOutName              = "",
 768         extCoreName             = "",
 769         verbosity               = 0,
 770         optLevel                = 0,
 771         simplPhases             = 2,
 772         maxSimplIterations      = 4,
 773         shouldDumpSimplPhase    = Nothing,
 774         ruleCheck               = Nothing,
 775         specConstrThreshold     = Just 2000,
 776         specConstrCount         = Just 3,
 777         liberateCaseThreshold   = Just 2000,
 778         floatLamArgs            = Just 0,       -- Default: float only if no fvs
 779         strictnessBefore        = [],
 780
 781         targetPlatform          = defaultTargetPlatform,
 782         cmdlineHcIncludes       = [],
 783         importPaths             = ["."],
 784         mainModIs               = mAIN,
 785         mainFunIs               = Nothing,
 786         ctxtStkDepth            = mAX_CONTEXT_REDUCTION_DEPTH,
 787
 788         dphBackend              = DPHNone,
 789
 790         thisPackage             = mainPackageId,
 791
 792         objectDir               = Nothing,
 793         dylibInstallName        = Nothing,
 794         hiDir                   = Nothing,
 795         stubDir                 = Nothing,
 796
 797         objectSuf               = phaseInputExt StopLn,
 798         hcSuf                   = phaseInputExt HCc,
 799         hiSuf                   = "hi",
 800
 801         outputFile              = Nothing,
 802         outputHi                = Nothing,
 803         dynLibLoader            = SystemDependent,
 804         dumpPrefix              = Nothing,
 805         dumpPrefixForce         = Nothing,
 806         includePaths            = [],
 807         libraryPaths            = [],
 808         frameworkPaths          = [],
 809         cmdlineFrameworks       = [],
 810         rtsOpts                 = Nothing,
 811         rtsOptsEnabled          = RtsOptsSafeOnly,
 812
 813         hpcDir                  = ".hpc",
 814
 815         extraPkgConfs           = [],
 816         packageFlags            = [],
 817         pkgDatabase             = Nothing,
 818         pkgState                = panic "no package state yet: call GHC.setSessionDynFlags",
 819         ways                    = panic "defaultDynFlags: No ways",
 820         buildTag                = panic "defaultDynFlags: No buildTag",
 821         rtsBuildTag             = panic "defaultDynFlags: No rtsBuildTag",
 822         splitInfo               = Nothing,
 823         settings                = mySettings,
 824         -- ghc -M values
 825         depMakefile       = "Makefile",
 826         depIncludePkgDeps = False,
 827         depExcludeMods    = [],
 828         depSuffixes       = [],
 829         -- end of ghc -M values
 830         filesToClean   = panic "defaultDynFlags: No filesToClean",
 831         dirsToClean    = panic "defaultDynFlags: No dirsToClean",
 832         generatedDumps = panic "defaultDynFlags: No generatedDumps",
 833         haddockOptions = Nothing,
 834         flags = defaultFlags,
 835         language = Nothing,
 836         extensions = [],
 837         extensionFlags = flattenExtensionFlags Nothing [],
 838
 839         log_action = \severity srcSpan style msg ->
 840                         case severity of
 841                           SevOutput -> printSDoc msg style
 842                           SevInfo   -> printErrs msg style
 843                           SevFatal  -> printErrs msg style
 844                           _         -> do
 845                                 hPutChar stderr '\n'
 846                                 printErrs (mkLocMessage srcSpan msg) style
 847                      -- careful (#2302): printErrs prints in UTF-8, whereas
 848                      -- converting to string first and using hPutStr would
 849                      -- just emit the low 8 bits of each unicode char.
 850       }
 851
 852 {-
 853 Note [Verbosity levels]
 854 ~~~~~~~~~~~~~~~~~~~~~~~
 855     0   |   print errors & warnings only
 856     1   |   minimal verbosity: print "compiling M ... done." for each module.
 857     2   |   equivalent to -dshow-passes
 858     3   |   equivalent to existing "ghc -v"
 859     4   |   "ghc -v -ddump-most"
 860     5   |   "ghc -v -ddump-all"
 861 -}
 862
 863 data OnOff a = On a
 864              | Off a
 865
 866 -- OnOffs accumulate in reverse order, so we use foldr in order to
 867 -- process them in the right order
 868 flattenExtensionFlags :: Maybe Language -> [OnOff ExtensionFlag]
 869                       -> [ExtensionFlag]
 870 flattenExtensionFlags ml = foldr f defaultExtensionFlags
 871     where f (On f)  flags = f : delete f flags
 872           f (Off f) flags =     delete f flags
 873           defaultExtensionFlags = languageExtensions ml
 874
 875 languageExtensions :: Maybe Language -> [ExtensionFlag]
 876
 877 languageExtensions Nothing
 878     -- Nothing => the default case
 879     = Opt_MonoPatBinds   -- Experimentally, I'm making this non-standard
 880                          -- behaviour the default, to see if anyone notices
 881                          -- SLPJ July 06
 882       -- In due course I'd like Opt_MonoLocalBinds to be on by default
 883       -- But NB it's implied by GADTs etc
 884       -- SLPJ September 2010
 885     : Opt_NondecreasingIndentation -- This has been on by default for some time
 886     : delete Opt_DatatypeContexts  -- The Haskell' committee decided to
 887                                    -- remove datatype contexts from the
 888                                    -- language:
 889    -- http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html
 890       (languageExtensions (Just Haskell2010))
 891
 892 languageExtensions (Just Haskell98)
 893     = [Opt_ImplicitPrelude,
 894        Opt_MonomorphismRestriction,
 895        Opt_NPlusKPatterns,
 896        Opt_DatatypeContexts,
 897        Opt_NondecreasingIndentation
 898            -- strictly speaking non-standard, but we always had this
 899            -- on implicitly before the option was added in 7.1, and
 900            -- turning it off breaks code, so we're keeping it on for
 901            -- backwards compatibility.  Cabal uses -XHaskell98 by
 902            -- default unless you specify another language.
 903       ]
 904
 905 languageExtensions (Just Haskell2010)
 906     = [Opt_ImplicitPrelude,
 907        Opt_MonomorphismRestriction,
 908        Opt_DatatypeContexts,
 909        Opt_EmptyDataDecls,
 910        Opt_ForeignFunctionInterface,
 911        Opt_PatternGuards,
 912        Opt_DoAndIfThenElse,
 913        Opt_RelaxedPolyRec]
 914
 915 -- | Test whether a 'DynFlag' is set
 916 dopt :: DynFlag -> DynFlags -> Bool
 917 dopt f dflags  = f `elem` (flags dflags)
 918
 919 -- | Set a 'DynFlag'
 920 dopt_set :: DynFlags -> DynFlag -> DynFlags
 921 dopt_set dfs f = dfs{ flags = f : flags dfs }
 922
 923 -- | Unset a 'DynFlag'
 924 dopt_unset :: DynFlags -> DynFlag -> DynFlags
 925 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
 926
 927 -- | Test whether a 'ExtensionFlag' is set
 928 xopt :: ExtensionFlag -> DynFlags -> Bool
 929 xopt f dflags = f `elem` extensionFlags dflags
 930
 931 -- | Set a 'ExtensionFlag'
 932 xopt_set :: DynFlags -> ExtensionFlag -> DynFlags
 933 xopt_set dfs f
 934     = let onoffs = On f : extensions dfs
 935       in dfs { extensions = onoffs,
 936                extensionFlags = flattenExtensionFlags (language dfs) onoffs }
 937
 938 -- | Unset a 'ExtensionFlag'
 939 xopt_unset :: DynFlags -> ExtensionFlag -> DynFlags
 940 xopt_unset dfs f
 941     = let onoffs = Off f : extensions dfs
 942       in dfs { extensions = onoffs,
 943                extensionFlags = flattenExtensionFlags (language dfs) onoffs }
 944
 945 setLanguage :: Language -> DynP ()
 946 setLanguage l = upd f
 947     where f dfs = let mLang = Just l
 948                       oneoffs = extensions dfs
 949                   in dfs {
 950                          language = mLang,
 951                          extensionFlags = flattenExtensionFlags mLang oneoffs
 952                      }
 953
 954 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
 955 getOpts :: DynFlags             -- ^ 'DynFlags' to retrieve the options from
 956         -> (DynFlags -> [a])    -- ^ Relevant record accessor: one of the @opt_*@ accessors
 957         -> [a]                  -- ^ Correctly ordered extracted options
 958 getOpts dflags opts = reverse (opts dflags)
 959         -- We add to the options from the front, so we need to reverse the list
 960
 961 -- | Gets the verbosity flag for the current verbosity level. This is fed to
 962 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
 963 getVerbFlags :: DynFlags -> [String]
 964 getVerbFlags dflags
 965   | verbosity dflags >= 4 = ["-v"]
 966   | otherwise             = []
 967
 968 setObjectDir, setHiDir, setStubDir, setOutputDir, setDylibInstallName,
 969          setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
 970          setPgmP, addOptl, addOptP,
 971          addCmdlineFramework, addHaddockOpts
 972    :: String -> DynFlags -> DynFlags
 973 setOutputFile, setOutputHi, setDumpPrefixForce
 974    :: Maybe String -> DynFlags -> DynFlags
 975
 976 setObjectDir  f d = d{ objectDir  = Just f}
 977 setHiDir      f d = d{ hiDir      = Just f}
 978 setStubDir    f d = d{ stubDir    = Just f, includePaths = f : includePaths d }
 979   -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
 980   -- \#included from the .hc file when compiling via C (i.e. unregisterised
 981   -- builds).
 982 setOutputDir  f = setObjectDir f . setHiDir f . setStubDir f
 983 setDylibInstallName  f d = d{ dylibInstallName = Just f}
 984
 985 setObjectSuf  f d = d{ objectSuf  = f}
 986 setHiSuf      f d = d{ hiSuf      = f}
 987 setHcSuf      f d = d{ hcSuf      = f}
 988
 989 setOutputFile f d = d{ outputFile = f}
 990 setOutputHi   f d = d{ outputHi   = f}
 991
 992 parseDynLibLoaderMode f d =
 993  case splitAt 8 f of
 994    ("deploy", "")       -> d{ dynLibLoader = Deployable }
 995    ("sysdep", "")       -> d{ dynLibLoader = SystemDependent }
 996    _                    -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
 997
 998 setDumpPrefixForce f d = d { dumpPrefixForce = f}
 999
1000 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
1001 -- Config.hs should really use Option.
1002 setPgmP   f = let (pgm:args) = words f in alterSettings (\s -> s { sPgm_P   = (pgm, map Option args)})
1003 addOptl   f = alterSettings (\s -> s { sOpt_l   = f : sOpt_l s})
1004 addOptP   f = alterSettings (\s -> s { sOpt_P   = f : sOpt_P s})
1005
1006
1007 setDepMakefile :: FilePath -> DynFlags -> DynFlags
1008 setDepMakefile f d = d { depMakefile = deOptDep f }
1009
1010 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
1011 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
1012
1013 addDepExcludeMod :: String -> DynFlags -> DynFlags
1014 addDepExcludeMod m d
1015     = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
1016
1017 addDepSuffix :: FilePath -> DynFlags -> DynFlags
1018 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
1019
1020 -- XXX Legacy code:
1021 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
1022 -- we need to strip the "-optdep" off of the arg
1023 deOptDep :: String -> String
1024 deOptDep x = case stripPrefix "-optdep" x of
1025              Just rest -> rest
1026              Nothing -> x
1027
1028 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
1029
1030 addHaddockOpts f d = d{ haddockOptions = Just f}
1031
1032 -- -----------------------------------------------------------------------------
1033 -- Command-line options
1034
1035 -- | When invoking external tools as part of the compilation pipeline, we
1036 -- pass these a sequence of options on the command-line. Rather than
1037 -- just using a list of Strings, we use a type that allows us to distinguish
1038 -- between filepaths and 'other stuff'. The reason for this is that
1039 -- this type gives us a handle on transforming filenames, and filenames only,
1040 -- to whatever format they're expected to be on a particular platform.
1041 data Option
1042  = FileOption -- an entry that _contains_ filename(s) / filepaths.
1043               String  -- a non-filepath prefix that shouldn't be
1044                       -- transformed (e.g., "/out=")
1045               String  -- the filepath/filename portion
1046  | Option     String
1047
1048 showOpt :: Option -> String
1049 showOpt (FileOption pre f) = pre ++ f
1050 showOpt (Option s)  = s
1051
1052 -----------------------------------------------------------------------------
1053 -- Setting the optimisation level
1054
1055 updOptLevel :: Int -> DynFlags -> DynFlags
1056 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
1057 updOptLevel n dfs
1058   = dfs2{ optLevel = final_n }
1059   where
1060    final_n = max 0 (min 2 n)    -- Clamp to 0 <= n <= 2
1061    dfs1 = foldr (flip dopt_unset) dfs  remove_dopts
1062    dfs2 = foldr (flip dopt_set)   dfs1 extra_dopts
1063
1064    extra_dopts  = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
1065    remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
1066
1067 -- -----------------------------------------------------------------------------
1068 -- StgToDo:  abstraction of stg-to-stg passes to run.
1069
1070 data StgToDo
1071   = StgDoMassageForProfiling  -- should be (next to) last
1072   -- There's also setStgVarInfo, but its absolute "lastness"
1073   -- is so critical that it is hardwired in (no flag).
1074   | D_stg_stats
1075
1076 getStgToDo :: DynFlags -> [StgToDo]
1077 getStgToDo dflags
1078   = todo2
1079   where
1080         stg_stats = dopt Opt_StgStats dflags
1081
1082         todo1 = if stg_stats then [D_stg_stats] else []
1083
1084         todo2 | WayProf `elem` wayNames dflags
1085               = StgDoMassageForProfiling : todo1
1086               | otherwise
1087               = todo1
1088
1089 {- **********************************************************************
1090 %*                                                                      *
1091                 DynFlags parser
1092 %*                                                                      *
1093 %********************************************************************* -}
1094
1095 -- -----------------------------------------------------------------------------
1096 -- Parsing the dynamic flags.
1097
1098 -- | Parse dynamic flags from a list of command line arguments.  Returns the
1099 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1100 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1101 -- flags or missing arguments).
1102 parseDynamicFlags :: Monad m =>
1103                      DynFlags -> [Located String]
1104                   -> m (DynFlags, [Located String], [Located String])
1105                      -- ^ Updated 'DynFlags', left-over arguments, and
1106                      -- list of warnings.
1107 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1108
1109 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1110 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1111 parseDynamicNoPackageFlags :: Monad m =>
1112                      DynFlags -> [Located String]
1113                   -> m (DynFlags, [Located String], [Located String])
1114                      -- ^ Updated 'DynFlags', left-over arguments, and
1115                      -- list of warnings.
1116 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1117
1118 parseDynamicFlags_ :: Monad m =>
1119                       DynFlags -> [Located String] -> Bool
1120                   -> m (DynFlags, [Located String], [Located String])
1121 parseDynamicFlags_ dflags0 args pkg_flags = do
1122   -- XXX Legacy support code
1123   -- We used to accept things like
1124   --     optdep-f  -optdepdepend
1125   --     optdep-f  -optdep depend
1126   --     optdep -f -optdepdepend
1127   --     optdep -f -optdep depend
1128   -- but the spaces trip up proper argument handling. So get rid of them.
1129   let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1130       f (x : xs) = x : f xs
1131       f xs = xs
1132       args' = f args
1133
1134       -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1135       flag_spec | pkg_flags = package_flags ++ dynamic_flags
1136                 | otherwise = dynamic_flags
1137
1138   let ((leftover, errs, warns), dflags1)
1139           = runCmdLine (processArgs flag_spec args') dflags0
1140   when (not (null errs)) $ ghcError $ errorsToGhcException errs
1141
1142   return (dflags1, leftover, warns)
1143
1144
1145 {- **********************************************************************
1146 %*                                                                      *
1147                 DynFlags specifications
1148 %*                                                                      *
1149 %********************************************************************* -}
1150
1151 allFlags :: [String]
1152 allFlags = map ('-':) $
1153            [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1154            map ("fno-"++) flags ++
1155            map ("f"++) flags ++
1156            map ("f"++) flags' ++
1157            map ("X"++) supportedExtensions
1158     where ok (PrefixPred _ _) = False
1159           ok _ = True
1160           flags = [ name | (name, _, _) <- fFlags ]
1161           flags' = [ name | (name, _, _) <- fLangFlags ]
1162
1163 --------------- The main flags themselves ------------------
1164 dynamic_flags :: [Flag (CmdLineP DynFlags)]
1165 dynamic_flags = [
1166     Flag "n"        (NoArg (addWarn "The -n flag is deprecated and no longer has any effect"))
1167   , Flag "cpp"      (NoArg (setExtensionFlag Opt_Cpp))
1168   , Flag "F"        (NoArg (setDynFlag Opt_Pp))
1169   , Flag "#include"
1170          (HasArg (\s -> do { addCmdlineHCInclude s
1171                            ; addWarn "-#include and INCLUDE pragmas are deprecated: They no longer have any effect" }))
1172   , Flag "v"        (OptIntSuffix setVerbosity)
1173
1174         ------- Specific phases  --------------------------------------------
1175     -- need to appear before -pgmL to be parsed as LLVM flags.
1176   , Flag "pgmlo"          (hasArg (\f -> alterSettings (\s -> s { sPgm_lo  = (f,[])})))
1177   , Flag "pgmlc"          (hasArg (\f -> alterSettings (\s -> s { sPgm_lc  = (f,[])})))
1178   , Flag "pgmL"           (hasArg (\f -> alterSettings (\s -> s { sPgm_L   = f})))
1179   , Flag "pgmP"           (hasArg setPgmP)
1180   , Flag "pgmF"           (hasArg (\f -> alterSettings (\s -> s { sPgm_F   = f})))
1181   , Flag "pgmc"           (hasArg (\f -> alterSettings (\s -> s { sPgm_c   = (f,[])})))
1182   , Flag "pgmm"           (HasArg (\_ -> addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1183   , Flag "pgms"           (hasArg (\f -> alterSettings (\s -> s { sPgm_s   = (f,[])})))
1184   , Flag "pgma"           (hasArg (\f -> alterSettings (\s -> s { sPgm_a   = (f,[])})))
1185   , Flag "pgml"           (hasArg (\f -> alterSettings (\s -> s { sPgm_l   = (f,[])})))
1186   , Flag "pgmdll"         (hasArg (\f -> alterSettings (\s -> s { sPgm_dll = (f,[])})))
1187   , Flag "pgmwindres"     (hasArg (\f -> alterSettings (\s -> s { sPgm_windres = f})))
1188
1189     -- need to appear before -optl/-opta to be parsed as LLVM flags.
1190   , Flag "optlo"          (hasArg (\f -> alterSettings (\s -> s { sOpt_lo  = f : sOpt_lo s})))
1191   , Flag "optlc"          (hasArg (\f -> alterSettings (\s -> s { sOpt_lc  = f : sOpt_lc s})))
1192   , Flag "optL"           (hasArg (\f -> alterSettings (\s -> s { sOpt_L   = f : sOpt_L s})))
1193   , Flag "optP"           (hasArg addOptP)
1194   , Flag "optF"           (hasArg (\f -> alterSettings (\s -> s { sOpt_F   = f : sOpt_F s})))
1195   , Flag "optc"           (hasArg (\f -> alterSettings (\s -> s { sOpt_c   = f : sOpt_c s})))
1196   , Flag "optm"           (hasArg (\f -> alterSettings (\s -> s { sOpt_m   = f : sOpt_m s})))
1197   , Flag "opta"           (hasArg (\f -> alterSettings (\s -> s { sOpt_a   = f : sOpt_a s})))
1198   , Flag "optl"           (hasArg addOptl)
1199   , Flag "optwindres"     (hasArg (\f -> alterSettings (\s -> s { sOpt_windres = f : sOpt_windres s})))
1200
1201   , Flag "split-objs"
1202          (NoArg (if can_split
1203                  then setDynFlag Opt_SplitObjs
1204                  else addWarn "ignoring -fsplit-objs"))
1205
1206         -------- ghc -M -----------------------------------------------------
1207   , Flag "dep-suffix"     (hasArg addDepSuffix)
1208   , Flag "optdep-s"       (hasArgDF addDepSuffix "Use -dep-suffix instead")
1209   , Flag "dep-makefile"   (hasArg setDepMakefile)
1210   , Flag "optdep-f"       (hasArgDF setDepMakefile "Use -dep-makefile instead")
1211   , Flag "optdep-w"       (NoArg  (deprecate "doesn't do anything"))
1212   , Flag "include-pkg-deps"         (noArg (setDepIncludePkgDeps True))
1213   , Flag "optdep--include-prelude"  (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1214   , Flag "optdep--include-pkg-deps" (noArgDF (setDepIncludePkgDeps True) "Use -include-pkg-deps instead")
1215   , Flag "exclude-module"           (hasArg addDepExcludeMod)
1216   , Flag "optdep--exclude-module"   (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1217   , Flag "optdep-x"                 (hasArgDF addDepExcludeMod "Use -exclude-module instead")
1218
1219         -------- Linking ----------------------------------------------------
1220   , Flag "no-link"            (noArg (\d -> d{ ghcLink=NoLink }))
1221   , Flag "shared"             (noArg (\d -> d{ ghcLink=LinkDynLib }))
1222   , Flag "dynload"            (hasArg parseDynLibLoaderMode)
1223   , Flag "dylib-install-name" (hasArg setDylibInstallName)
1224
1225         ------- Libraries ---------------------------------------------------
1226   , Flag "L"   (Prefix addLibraryPath)
1227   , Flag "l"   (hasArg (addOptl . ("-l" ++)))
1228
1229         ------- Frameworks --------------------------------------------------
1230         -- -framework-path should really be -F ...
1231   , Flag "framework-path" (HasArg addFrameworkPath)
1232   , Flag "framework"      (hasArg addCmdlineFramework)
1233
1234         ------- Output Redirection ------------------------------------------
1235   , Flag "odir"              (hasArg setObjectDir)
1236   , Flag "o"                 (SepArg (upd . setOutputFile . Just))
1237   , Flag "ohi"               (hasArg (setOutputHi . Just ))
1238   , Flag "osuf"              (hasArg setObjectSuf)
1239   , Flag "hcsuf"             (hasArg setHcSuf)
1240   , Flag "hisuf"             (hasArg setHiSuf)
1241   , Flag "hidir"             (hasArg setHiDir)
1242   , Flag "tmpdir"            (hasArg setTmpDir)
1243   , Flag "stubdir"           (hasArg setStubDir)
1244   , Flag "outputdir"         (hasArg setOutputDir)
1245   , Flag "ddump-file-prefix" (hasArg (setDumpPrefixForce . Just))
1246
1247         ------- Keeping temporary files -------------------------------------
1248      -- These can be singular (think ghc -c) or plural (think ghc --make)
1249   , Flag "keep-hc-file"     (NoArg (setDynFlag Opt_KeepHcFiles))
1250   , Flag "keep-hc-files"    (NoArg (setDynFlag Opt_KeepHcFiles))
1251   , Flag "keep-s-file"      (NoArg (setDynFlag Opt_KeepSFiles))
1252   , Flag "keep-s-files"     (NoArg (setDynFlag Opt_KeepSFiles))
1253   , Flag "keep-raw-s-file"  (NoArg (addWarn "The -keep-raw-s-file flag does nothing; it will be removed in a future GHC release"))
1254   , Flag "keep-raw-s-files" (NoArg (addWarn "The -keep-raw-s-files flag does nothing; it will be removed in a future GHC release"))
1255   , Flag "keep-llvm-file"   (NoArg (setDynFlag Opt_KeepLlvmFiles))
1256   , Flag "keep-llvm-files"  (NoArg (setDynFlag Opt_KeepLlvmFiles))
1257      -- This only makes sense as plural
1258   , Flag "keep-tmp-files"   (NoArg (setDynFlag Opt_KeepTmpFiles))
1259
1260         ------- Miscellaneous ----------------------------------------------
1261   , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages))
1262   , Flag "no-hs-main"     (NoArg (setDynFlag Opt_NoHsMain))
1263   , Flag "with-rtsopts"   (HasArg setRtsOpts)
1264   , Flag "rtsopts"        (NoArg (setRtsOptsEnabled RtsOptsAll))
1265   , Flag "rtsopts=all"    (NoArg (setRtsOptsEnabled RtsOptsAll))
1266   , Flag "rtsopts=some"   (NoArg (setRtsOptsEnabled RtsOptsSafeOnly))
1267   , Flag "rtsopts=none"   (NoArg (setRtsOptsEnabled RtsOptsNone))
1268   , Flag "no-rtsopts"     (NoArg (setRtsOptsEnabled RtsOptsNone))
1269   , Flag "main-is"        (SepArg setMainIs)
1270   , Flag "haddock"        (NoArg (setDynFlag Opt_Haddock))
1271   , Flag "haddock-opts"   (hasArg addHaddockOpts)
1272   , Flag "hpcdir"         (SepArg setOptHpcDir)
1273
1274         ------- recompilation checker --------------------------------------
1275   , Flag "recomp"         (NoArg (do { unSetDynFlag Opt_ForceRecomp
1276                                      ; deprecate "Use -fno-force-recomp instead" }))
1277   , Flag "no-recomp"      (NoArg (do { setDynFlag Opt_ForceRecomp
1278                                      ; deprecate "Use -fforce-recomp instead" }))
1279
1280         ------ HsCpp opts ---------------------------------------------------
1281   , Flag "D"              (AnySuffix (upd . addOptP))
1282   , Flag "U"              (AnySuffix (upd . addOptP))
1283
1284         ------- Include/Import Paths ----------------------------------------
1285   , Flag "I"              (Prefix    addIncludePath)
1286   , Flag "i"              (OptPrefix addImportPath)
1287
1288         ------ Debugging ----------------------------------------------------
1289   , Flag "dstg-stats"     (NoArg (setDynFlag Opt_StgStats))
1290
1291   , Flag "ddump-cmm"               (setDumpFlag Opt_D_dump_cmm)
1292   , Flag "ddump-raw-cmm"           (setDumpFlag Opt_D_dump_raw_cmm)
1293   , Flag "ddump-cmmz"              (setDumpFlag Opt_D_dump_cmmz)
1294   , Flag "ddump-cmmz-pretty"       (setDumpFlag Opt_D_dump_cmmz_pretty)
1295   , Flag "ddump-cmmz-cbe"          (setDumpFlag Opt_D_dump_cmmz_cbe)
1296   , Flag "ddump-cmmz-spills"       (setDumpFlag Opt_D_dump_cmmz_spills)
1297   , Flag "ddump-cmmz-proc"         (setDumpFlag Opt_D_dump_cmmz_proc)
1298   , Flag "ddump-cmmz-rewrite"      (setDumpFlag Opt_D_dump_cmmz_rewrite)
1299   , Flag "ddump-cmmz-dead"         (setDumpFlag Opt_D_dump_cmmz_dead)
1300   , Flag "ddump-cmmz-stub"         (setDumpFlag Opt_D_dump_cmmz_stub)
1301   , Flag "ddump-cmmz-sp"           (setDumpFlag Opt_D_dump_cmmz_sp)
1302   , Flag "ddump-cmmz-procmap"      (setDumpFlag Opt_D_dump_cmmz_procmap)
1303   , Flag "ddump-cmmz-split"        (setDumpFlag Opt_D_dump_cmmz_split)
1304   , Flag "ddump-cmmz-lower"        (setDumpFlag Opt_D_dump_cmmz_lower)
1305   , Flag "ddump-cmmz-info"         (setDumpFlag Opt_D_dump_cmmz_info)
1306   , Flag "ddump-cmmz-cafs"         (setDumpFlag Opt_D_dump_cmmz_cafs)
1307   , Flag "ddump-core-stats"        (setDumpFlag Opt_D_dump_core_stats)
1308   , Flag "ddump-cps-cmm"           (setDumpFlag Opt_D_dump_cps_cmm)
1309   , Flag "ddump-cvt-cmm"           (setDumpFlag Opt_D_dump_cvt_cmm)
1310   , Flag "ddump-asm"               (setDumpFlag Opt_D_dump_asm)
1311   , Flag "ddump-asm-native"        (setDumpFlag Opt_D_dump_asm_native)
1312   , Flag "ddump-asm-liveness"      (setDumpFlag Opt_D_dump_asm_liveness)
1313   , Flag "ddump-asm-coalesce"      (setDumpFlag Opt_D_dump_asm_coalesce)
1314   , Flag "ddump-asm-regalloc"      (setDumpFlag Opt_D_dump_asm_regalloc)
1315   , Flag "ddump-asm-conflicts"     (setDumpFlag Opt_D_dump_asm_conflicts)
1316   , Flag "ddump-asm-regalloc-stages" (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1317   , Flag "ddump-asm-stats"         (setDumpFlag Opt_D_dump_asm_stats)
1318   , Flag "ddump-asm-expanded"      (setDumpFlag Opt_D_dump_asm_expanded)
1319   , Flag "ddump-llvm"              (NoArg (do { setObjTarget HscLlvm
1320                                               ; setDumpFlag' Opt_D_dump_llvm}))
1321   , Flag "ddump-cpranal"           (setDumpFlag Opt_D_dump_cpranal)
1322   , Flag "ddump-deriv"             (setDumpFlag Opt_D_dump_deriv)
1323   , Flag "ddump-ds"                (setDumpFlag Opt_D_dump_ds)
1324   , Flag "ddump-flatC"             (setDumpFlag Opt_D_dump_flatC)
1325   , Flag "ddump-foreign"           (setDumpFlag Opt_D_dump_foreign)
1326   , Flag "ddump-inlinings"         (setDumpFlag Opt_D_dump_inlinings)
1327   , Flag "ddump-rule-firings"      (setDumpFlag Opt_D_dump_rule_firings)
1328   , Flag "ddump-rule-rewrites"     (setDumpFlag Opt_D_dump_rule_rewrites)
1329   , Flag "ddump-occur-anal"        (setDumpFlag Opt_D_dump_occur_anal)
1330   , Flag "ddump-parsed"            (setDumpFlag Opt_D_dump_parsed)
1331   , Flag "ddump-rn"                (setDumpFlag Opt_D_dump_rn)
1332   , Flag "ddump-simpl"             (setDumpFlag Opt_D_dump_simpl)
1333   , Flag "ddump-simpl-iterations"  (setDumpFlag Opt_D_dump_simpl_iterations)
1334   , Flag "ddump-simpl-phases"      (OptPrefix setDumpSimplPhases)
1335   , Flag "ddump-spec"              (setDumpFlag Opt_D_dump_spec)
1336   , Flag "ddump-prep"              (setDumpFlag Opt_D_dump_prep)
1337   , Flag "ddump-stg"               (setDumpFlag Opt_D_dump_stg)
1338   , Flag "ddump-stranal"           (setDumpFlag Opt_D_dump_stranal)
1339   , Flag "ddump-tc"                (setDumpFlag Opt_D_dump_tc)
1340   , Flag "ddump-types"             (setDumpFlag Opt_D_dump_types)
1341   , Flag "ddump-rules"             (setDumpFlag Opt_D_dump_rules)
1342   , Flag "ddump-cse"               (setDumpFlag Opt_D_dump_cse)
1343   , Flag "ddump-worker-wrapper"    (setDumpFlag Opt_D_dump_worker_wrapper)
1344   , Flag "ddump-rn-trace"          (setDumpFlag Opt_D_dump_rn_trace)
1345   , Flag "ddump-if-trace"          (setDumpFlag Opt_D_dump_if_trace)
1346   , Flag "ddump-cs-trace"          (setDumpFlag Opt_D_dump_cs_trace)
1347   , Flag "ddump-tc-trace"          (setDumpFlag Opt_D_dump_tc_trace)
1348   , Flag "ddump-vt-trace"          (setDumpFlag Opt_D_dump_vt_trace)
1349   , Flag "ddump-splices"           (setDumpFlag Opt_D_dump_splices)
1350   , Flag "ddump-rn-stats"          (setDumpFlag Opt_D_dump_rn_stats)
1351   , Flag "ddump-opt-cmm"           (setDumpFlag Opt_D_dump_opt_cmm)
1352   , Flag "ddump-simpl-stats"       (setDumpFlag Opt_D_dump_simpl_stats)
1353   , Flag "ddump-bcos"              (setDumpFlag Opt_D_dump_BCOs)
1354   , Flag "dsource-stats"           (setDumpFlag Opt_D_source_stats)
1355   , Flag "dverbose-core2core"      (NoArg (do { setVerbosity (Just 2)
1356                                               ; setVerboseCore2Core }))
1357   , Flag "dverbose-stg2stg"        (setDumpFlag Opt_D_verbose_stg2stg)
1358   , Flag "ddump-hi"                (setDumpFlag Opt_D_dump_hi)
1359   , Flag "ddump-minimal-imports"   (setDumpFlag Opt_D_dump_minimal_imports)
1360   , Flag "ddump-vect"              (setDumpFlag Opt_D_dump_vect)
1361   , Flag "ddump-hpc"               (setDumpFlag Opt_D_dump_hpc)
1362   , Flag "ddump-mod-cycles"        (setDumpFlag Opt_D_dump_mod_cycles)
1363   , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1364   , Flag "ddump-to-file"           (setDumpFlag Opt_DumpToFile)
1365   , Flag "ddump-hi-diffs"          (setDumpFlag Opt_D_dump_hi_diffs)
1366   , Flag "ddump-rtti"              (setDumpFlag Opt_D_dump_rtti)
1367   , Flag "dcore-lint"              (NoArg (setDynFlag Opt_DoCoreLinting))
1368   , Flag "dstg-lint"               (NoArg (setDynFlag Opt_DoStgLinting))
1369   , Flag "dcmm-lint"               (NoArg (setDynFlag Opt_DoCmmLinting))
1370   , Flag "dasm-lint"               (NoArg (setDynFlag Opt_DoAsmLinting))
1371   , Flag "dshow-passes"            (NoArg (do forceRecompile
1372                                               setVerbosity (Just 2)))
1373   , Flag "dfaststring-stats"       (NoArg (setDynFlag Opt_D_faststring_stats))
1374
1375         ------ Coq-in-GHC ---------------------------
1376   , Flag "ddump-proofs"            (NoArg (setDynFlag Opt_D_dump_proofs))
1377   , Flag "ddump-coqpass"           (NoArg (setDynFlag Opt_D_coqpass))
1378   , Flag "fcoqpass"                (NoArg (setDynFlag Opt_F_coqpass))
1379   , Flag "fsimpleopt-before-flatten"                (NoArg (setDynFlag Opt_F_simpleopt_before_flatten))
1380   , Flag "fflatten"                (NoArg (do { setDynFlag Opt_F_coqpass ; setDynFlag Opt_F_flatten }))
1381   , Flag "funsafe-skolemize"       (NoArg (do { setDynFlag Opt_F_coqpass ; setDynFlag Opt_F_flatten ; setDynFlag Opt_F_skolemize }))
1382
1383         ------ Machine dependant (-m<blah>) stuff ---------------------------
1384
1385   , Flag "monly-2-regs" (NoArg (addWarn "The -monly-2-regs flag does nothing; it will be removed in a future GHC release"))
1386   , Flag "monly-3-regs" (NoArg (addWarn "The -monly-3-regs flag does nothing; it will be removed in a future GHC release"))
1387   , Flag "monly-4-regs" (NoArg (addWarn "The -monly-4-regs flag does nothing; it will be removed in a future GHC release"))
1388   , Flag "msse2"        (NoArg (setDynFlag Opt_SSE2))
1389
1390      ------ Warning opts -------------------------------------------------
1391   , Flag "W"      (NoArg (mapM_ setDynFlag   minusWOpts))
1392   , Flag "Werror" (NoArg (setDynFlag         Opt_WarnIsError))
1393   , Flag "Wwarn"  (NoArg (unSetDynFlag       Opt_WarnIsError))
1394   , Flag "Wall"   (NoArg (mapM_ setDynFlag   minusWallOpts))
1395   , Flag "Wnot"   (NoArg (do { mapM_ unSetDynFlag minusWallOpts
1396                              ; deprecate "Use -w instead" }))
1397   , Flag "w"      (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1398
1399         ------ Optimisation flags ------------------------------------------
1400   , Flag "O"      (noArgM (setOptLevel 1))
1401   , Flag "Onot"   (noArgM (\dflags -> do deprecate "Use -O0 instead"
1402                                          setOptLevel 0 dflags))
1403   , Flag "Odph"   (noArgM setDPHOpt)
1404   , Flag "O"      (optIntSuffixM (\mb_n -> setOptLevel (mb_n `orElse` 1)))
1405                 -- If the number is missing, use 1
1406
1407   , Flag "fsimplifier-phases"          (intSuffix (\n d -> d{ simplPhases = n }))
1408   , Flag "fmax-simplifier-iterations"  (intSuffix (\n d -> d{ maxSimplIterations = n }))
1409   , Flag "fspec-constr-threshold"      (intSuffix (\n d -> d{ specConstrThreshold = Just n }))
1410   , Flag "fno-spec-constr-threshold"   (noArg (\d -> d{ specConstrThreshold = Nothing }))
1411   , Flag "fspec-constr-count"          (intSuffix (\n d -> d{ specConstrCount = Just n }))
1412   , Flag "fno-spec-constr-count"       (noArg (\d -> d{ specConstrCount = Nothing }))
1413   , Flag "fliberate-case-threshold"    (intSuffix (\n d -> d{ liberateCaseThreshold = Just n }))
1414   , Flag "fno-liberate-case-threshold" (noArg (\d -> d{ liberateCaseThreshold = Nothing }))
1415   , Flag "frule-check"                 (SepArg (\s -> upd (\d -> d{ ruleCheck = Just s })))
1416   , Flag "fcontext-stack"              (intSuffix (\n d -> d{ ctxtStkDepth = n }))
1417   , Flag "fstrictness-before"          (intSuffix (\n d -> d{ strictnessBefore = n : strictnessBefore d }))
1418   , Flag "ffloat-lam-args"             (intSuffix (\n d -> d{ floatLamArgs = Just n }))
1419   , Flag "ffloat-all-lams"             (noArg (\d -> d{ floatLamArgs = Nothing }))
1420
1421         ------ Profiling ----------------------------------------------------
1422
1423   -- XXX Should the -f* flags be deprecated?
1424   -- They don't seem to be documented
1425   , Flag "fauto-sccs-on-all-toplevs"       (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1426   , Flag "auto-all"                        (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1427   , Flag "no-auto-all"                     (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1428   , Flag "fauto-sccs-on-exported-toplevs"  (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1429   , Flag "auto"                            (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1430   , Flag "no-auto"                         (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1431   , Flag "fauto-sccs-on-individual-cafs"   (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1432   , Flag "caf-all"                         (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1433   , Flag "no-caf-all"                      (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1434
1435         ------ DPH flags ----------------------------------------------------
1436
1437   , Flag "fdph-seq"         (NoArg (setDPHBackend DPHSeq))
1438   , Flag "fdph-par"         (NoArg (setDPHBackend DPHPar))
1439   , Flag "fdph-this"        (NoArg (setDPHBackend DPHThis))
1440   , Flag "fdph-none"        (NoArg (setDPHBackend DPHNone))
1441
1442         ------ Compiler flags -----------------------------------------------
1443
1444   , Flag "fasm"             (NoArg (setObjTarget HscAsm))
1445   , Flag "fvia-c"           (NoArg
1446          (addWarn "The -fvia-c flag does nothing; it will be removed in a future GHC release"))
1447   , Flag "fvia-C"           (NoArg
1448          (addWarn "The -fvia-C flag does nothing; it will be removed in a future GHC release"))
1449   , Flag "fllvm"            (NoArg (setObjTarget HscLlvm))
1450
1451   , Flag "fno-code"         (NoArg (do upd $ \d -> d{ ghcLink=NoLink }
1452                                        setTarget HscNothing))
1453   , Flag "fbyte-code"       (NoArg (setTarget HscInterpreted))
1454   , Flag "fobject-code"     (NoArg (setTarget defaultHscTarget))
1455   , Flag "fglasgow-exts"    (NoArg (enableGlasgowExts >> deprecate "Use individual extensions instead"))
1456   , Flag "fno-glasgow-exts" (NoArg (disableGlasgowExts >> deprecate "Use individual extensions instead"))
1457  ]
1458  ++ map (mkFlag turnOn  "f"    setDynFlag  ) fFlags
1459  ++ map (mkFlag turnOff "fno-" unSetDynFlag) fFlags
1460  ++ map (mkFlag turnOn  "f"    setExtensionFlag  ) fLangFlags
1461  ++ map (mkFlag turnOff "fno-" unSetExtensionFlag) fLangFlags
1462  ++ map (mkFlag turnOn  "X"    setExtensionFlag  ) xFlags
1463  ++ map (mkFlag turnOff "XNo"  unSetExtensionFlag) xFlags
1464  ++ map (mkFlag turnOn  "X"    setLanguage) languageFlags
1465
1466 package_flags :: [Flag (CmdLineP DynFlags)]
1467 package_flags = [
1468         ------- Packages ----------------------------------------------------
1469     Flag "package-conf"         (HasArg extraPkgConf_)
1470   , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1471   , Flag "package-name"         (hasArg setPackageName)
1472   , Flag "package-id"           (HasArg exposePackageId)
1473   , Flag "package"              (HasArg exposePackage)
1474   , Flag "hide-package"         (HasArg hidePackage)
1475   , Flag "hide-all-packages"    (NoArg (setDynFlag Opt_HideAllPackages))
1476   , Flag "ignore-package"       (HasArg ignorePackage)
1477   , Flag "syslib"               (HasArg (\s -> do { exposePackage s
1478                                                   ; deprecate "Use -package instead" }))
1479   ]
1480
1481 type TurnOnFlag = Bool   -- True  <=> we are turning the flag on
1482                          -- False <=> we are turning the flag off
1483 turnOn  :: TurnOnFlag; turnOn = True
1484 turnOff :: TurnOnFlag; turnOff = False
1485
1486 type FlagSpec flag
1487    = ( String   -- Flag in string form
1488      , flag     -- Flag in internal form
1489      , TurnOnFlag -> DynP ())    -- Extra action to run when the flag is found
1490                                  -- Typically, emit a warning or error
1491
1492 mkFlag :: TurnOnFlag            -- ^ True <=> it should be turned on
1493        -> String                -- ^ The flag prefix
1494        -> (flag -> DynP ())     -- ^ What to do when the flag is found
1495        -> FlagSpec flag         -- ^ Specification of this particular flag
1496        -> Flag (CmdLineP DynFlags)
1497 mkFlag turn_on flagPrefix f (name, flag, extra_action)
1498     = Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on))
1499
1500 deprecatedForExtension :: String -> TurnOnFlag -> DynP ()
1501 deprecatedForExtension lang turn_on
1502     = deprecate ("use -X"  ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead")
1503     where
1504       flag | turn_on    = lang
1505            | otherwise = "No"++lang
1506
1507 useInstead :: String -> TurnOnFlag -> DynP ()
1508 useInstead flag turn_on
1509   = deprecate ("Use -f" ++ no ++ flag ++ " instead")
1510   where
1511     no = if turn_on then "" else "no-"
1512
1513 nop :: TurnOnFlag -> DynP ()
1514 nop _ = return ()
1515
1516 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1517 fFlags :: [FlagSpec DynFlag]
1518 fFlags = [
1519   ( "warn-dodgy-foreign-imports",       Opt_WarnDodgyForeignImports, nop ),
1520   ( "warn-dodgy-exports",               Opt_WarnDodgyExports, nop ),
1521   ( "warn-dodgy-imports",               Opt_WarnDodgyImports, nop ),
1522   ( "warn-duplicate-exports",           Opt_WarnDuplicateExports, nop ),
1523   ( "warn-hi-shadowing",                Opt_WarnHiShadows, nop ),
1524   ( "warn-implicit-prelude",            Opt_WarnImplicitPrelude, nop ),
1525   ( "warn-incomplete-patterns",         Opt_WarnIncompletePatterns, nop ),
1526   ( "warn-incomplete-uni-patterns",     Opt_WarnIncompleteUniPatterns, nop ),
1527   ( "warn-incomplete-record-updates",   Opt_WarnIncompletePatternsRecUpd, nop ),
1528   ( "warn-missing-fields",              Opt_WarnMissingFields, nop ),
1529   ( "warn-missing-import-lists",        Opt_WarnMissingImportList, nop ),
1530   ( "warn-missing-methods",             Opt_WarnMissingMethods, nop ),
1531   ( "warn-missing-signatures",          Opt_WarnMissingSigs, nop ),
1532   ( "warn-missing-local-sigs",          Opt_WarnMissingLocalSigs, nop ),
1533   ( "warn-name-shadowing",              Opt_WarnNameShadowing, nop ),
1534   ( "warn-overlapping-patterns",        Opt_WarnOverlappingPatterns, nop ),
1535   ( "warn-type-defaults",               Opt_WarnTypeDefaults, nop ),
1536   ( "warn-monomorphism-restriction",    Opt_WarnMonomorphism, nop ),
1537   ( "warn-unused-binds",                Opt_WarnUnusedBinds, nop ),
1538   ( "warn-unused-imports",              Opt_WarnUnusedImports, nop ),
1539   ( "warn-unused-matches",              Opt_WarnUnusedMatches, nop ),
1540   ( "warn-warnings-deprecations",       Opt_WarnWarningsDeprecations, nop ),
1541   ( "warn-deprecations",                Opt_WarnWarningsDeprecations, nop ),
1542   ( "warn-deprecated-flags",            Opt_WarnDeprecatedFlags, nop ),
1543   ( "warn-orphans",                     Opt_WarnOrphans, nop ),
1544   ( "warn-identities",                  Opt_WarnIdentities, nop ),
1545   ( "warn-auto-orphans",                Opt_WarnAutoOrphans, nop ),
1546   ( "warn-tabs",                        Opt_WarnTabs, nop ),
1547   ( "warn-unrecognised-pragmas",        Opt_WarnUnrecognisedPragmas, nop ),
1548   ( "warn-lazy-unlifted-bindings",      Opt_WarnLazyUnliftedBindings, nop),
1549   ( "warn-unused-do-bind",              Opt_WarnUnusedDoBind, nop ),
1550   ( "warn-wrong-do-bind",               Opt_WarnWrongDoBind, nop ),
1551   ( "warn-alternative-layout-rule-transitional", Opt_WarnAlternativeLayoutRuleTransitional, nop ),
1552   ( "print-explicit-foralls",           Opt_PrintExplicitForalls, nop ),
1553   ( "strictness",                       Opt_Strictness, nop ),
1554   ( "specialise",                       Opt_Specialise, nop ),
1555   ( "float-in",                         Opt_FloatIn, nop ),
1556   ( "static-argument-transformation",   Opt_StaticArgumentTransformation, nop ),
1557   ( "full-laziness",                    Opt_FullLaziness, nop ),
1558   ( "liberate-case",                    Opt_LiberateCase, nop ),
1559   ( "spec-constr",                      Opt_SpecConstr, nop ),
1560   ( "cse",                              Opt_CSE, nop ),
1561   ( "ignore-interface-pragmas",         Opt_IgnoreInterfacePragmas, nop ),
1562   ( "omit-interface-pragmas",           Opt_OmitInterfacePragmas, nop ),
1563   ( "expose-all-unfoldings",            Opt_ExposeAllUnfoldings, nop ),
1564   ( "do-lambda-eta-expansion",          Opt_DoLambdaEtaExpansion, nop ),
1565   ( "ignore-asserts",                   Opt_IgnoreAsserts, nop ),
1566   ( "do-eta-reduction",                 Opt_DoEtaReduction, nop ),
1567   ( "case-merge",                       Opt_CaseMerge, nop ),
1568   ( "unbox-strict-fields",              Opt_UnboxStrictFields, nop ),
1569   ( "method-sharing",                   Opt_MethodSharing,
1570      \_ -> deprecate "doesn't do anything any more"),
1571      -- Remove altogether in GHC 7.2
1572   ( "dicts-cheap",                      Opt_DictsCheap, nop ),
1573   ( "excess-precision",                 Opt_ExcessPrecision, nop ),
1574   ( "eager-blackholing",                Opt_EagerBlackHoling, nop ),
1575   ( "print-bind-result",                Opt_PrintBindResult, nop ),
1576   ( "force-recomp",                     Opt_ForceRecomp, nop ),
1577   ( "hpc-no-auto",                      Opt_Hpc_No_Auto, nop ),
1578   ( "rewrite-rules",                    Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1579   ( "enable-rewrite-rules",             Opt_EnableRewriteRules, nop ),
1580   ( "break-on-exception",               Opt_BreakOnException, nop ),
1581   ( "break-on-error",                   Opt_BreakOnError, nop ),
1582   ( "print-evld-with-show",             Opt_PrintEvldWithShow, nop ),
1583   ( "print-bind-contents",              Opt_PrintBindContents, nop ),
1584   ( "run-cps",                          Opt_RunCPS, nop ),
1585   ( "run-cpsz",                         Opt_RunCPSZ, nop ),
1586   ( "new-codegen",                      Opt_TryNewCodeGen, nop ),
1587   ( "convert-to-zipper-and-back",       Opt_ConvertToZipCfgAndBack, nop ),
1588   ( "vectorise",                        Opt_Vectorise, nop ),
1589   ( "regs-graph",                       Opt_RegsGraph, nop ),
1590   ( "regs-iterative",                   Opt_RegsIterative, nop ),
1591   ( "gen-manifest",                     Opt_GenManifest, nop ),
1592   ( "embed-manifest",                   Opt_EmbedManifest, nop ),
1593   ( "ext-core",                         Opt_EmitExternalCore, nop ),
1594   ( "shared-implib",                    Opt_SharedImplib, nop ),
1595   ( "ghci-sandbox",                     Opt_GhciSandbox, nop ),
1596   ( "helpful-errors",                   Opt_HelpfulErrors, nop ),
1597   ( "building-cabal-package",           Opt_BuildingCabalPackage, nop ),
1598   ( "implicit-import-qualified",        Opt_ImplicitImportQualified, nop )
1599   ]
1600
1601 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1602 fLangFlags :: [FlagSpec ExtensionFlag]
1603 fLangFlags = [
1604   ( "th",                               Opt_TemplateHaskell,
1605     deprecatedForExtension "TemplateHaskell" >> checkTemplateHaskellOk ),
1606   ( "fi",                               Opt_ForeignFunctionInterface,
1607     deprecatedForExtension "ForeignFunctionInterface" ),
1608   ( "ffi",                              Opt_ForeignFunctionInterface,
1609     deprecatedForExtension "ForeignFunctionInterface" ),
1610   ( "arrows",                           Opt_Arrows,
1611     deprecatedForExtension "Arrows" ),
1612   ( "generics",                         Opt_Generics,
1613     deprecatedForExtension "Generics" ),
1614   ( "implicit-prelude",                 Opt_ImplicitPrelude,
1615     deprecatedForExtension "ImplicitPrelude" ),
1616   ( "bang-patterns",                    Opt_BangPatterns,
1617     deprecatedForExtension "BangPatterns" ),
1618   ( "monomorphism-restriction",         Opt_MonomorphismRestriction,
1619     deprecatedForExtension "MonomorphismRestriction" ),
1620   ( "mono-pat-binds",                   Opt_MonoPatBinds,
1621     deprecatedForExtension "MonoPatBinds" ),
1622   ( "extended-default-rules",           Opt_ExtendedDefaultRules,
1623     deprecatedForExtension "ExtendedDefaultRules" ),
1624   ( "implicit-params",                  Opt_ImplicitParams,
1625     deprecatedForExtension "ImplicitParams" ),
1626   ( "scoped-type-variables",            Opt_ScopedTypeVariables,
1627     deprecatedForExtension "ScopedTypeVariables" ),
1628   ( "parr",                             Opt_ParallelArrays,
1629     deprecatedForExtension "ParallelArrays" ),
1630   ( "PArr",                             Opt_ParallelArrays,
1631     deprecatedForExtension "ParallelArrays" ),
1632   ( "allow-overlapping-instances",      Opt_OverlappingInstances,
1633     deprecatedForExtension "OverlappingInstances" ),
1634   ( "allow-undecidable-instances",      Opt_UndecidableInstances,
1635     deprecatedForExtension "UndecidableInstances" ),
1636   ( "allow-incoherent-instances",       Opt_IncoherentInstances,
1637     deprecatedForExtension "IncoherentInstances" )
1638   ]
1639
1640 supportedLanguages :: [String]
1641 supportedLanguages = [ name | (name, _, _) <- languageFlags ]
1642
1643 supportedExtensions :: [String]
1644 supportedExtensions = [ name' | (name, _, _) <- xFlags, name' <- [name, "No" ++ name] ]
1645
1646 supportedLanguagesAndExtensions :: [String]
1647 supportedLanguagesAndExtensions = supportedLanguages ++ supportedExtensions
1648
1649 -- | These -X<blah> flags cannot be reversed with -XNo<blah>
1650 languageFlags :: [FlagSpec Language]
1651 languageFlags = [
1652   ( "Haskell98",                        Haskell98, nop ),
1653   ( "Haskell2010",                      Haskell2010, nop )
1654   ]
1655
1656 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1657 xFlags :: [FlagSpec ExtensionFlag]
1658 xFlags = [
1659   ( "CPP",                              Opt_Cpp, nop ),
1660   ( "PostfixOperators",                 Opt_PostfixOperators, nop ),
1661   ( "TupleSections",                    Opt_TupleSections, nop ),
1662   ( "PatternGuards",                    Opt_PatternGuards, nop ),
1663   ( "UnicodeSyntax",                    Opt_UnicodeSyntax, nop ),
1664   ( "MagicHash",                        Opt_MagicHash, nop ),
1665   ( "PolymorphicComponents",            Opt_PolymorphicComponents, nop ),
1666   ( "ExistentialQuantification",        Opt_ExistentialQuantification, nop ),
1667   ( "KindSignatures",                   Opt_KindSignatures, nop ),
1668   ( "EmptyDataDecls",                   Opt_EmptyDataDecls, nop ),
1669   ( "ParallelListComp",                 Opt_ParallelListComp, nop ),
1670   ( "TransformListComp",                Opt_TransformListComp, nop ),
1671   ( "MonadComprehensions",              Opt_MonadComprehensions, nop),
1672   ( "ForeignFunctionInterface",         Opt_ForeignFunctionInterface, nop ),
1673   ( "UnliftedFFITypes",                 Opt_UnliftedFFITypes, nop ),
1674   ( "GHCForeignImportPrim",             Opt_GHCForeignImportPrim, nop ),
1675   ( "LiberalTypeSynonyms",              Opt_LiberalTypeSynonyms, nop ),
1676   ( "Rank2Types",                       Opt_Rank2Types, nop ),
1677   ( "RankNTypes",                       Opt_RankNTypes, nop ),
1678   ( "ImpredicativeTypes",               Opt_ImpredicativeTypes, nop),
1679   ( "TypeOperators",                    Opt_TypeOperators, nop ),
1680   ( "RecursiveDo",                      Opt_RecursiveDo,     -- Enables 'mdo'
1681     deprecatedForExtension "DoRec"),
1682   ( "DoRec",                            Opt_DoRec, nop ),    -- Enables 'rec' keyword
1683   ( "Arrows",                           Opt_Arrows, nop ),
1684   ( "ModalTypes",                       Opt_ModalTypes, nop ),
1685   ( "ParallelArrays",                   Opt_ParallelArrays, nop ),
1686   ( "TemplateHaskell",                  Opt_TemplateHaskell, checkTemplateHaskellOk ),
1687   ( "QuasiQuotes",                      Opt_QuasiQuotes, nop ),
1688   ( "Generics",                         Opt_Generics,
1689     \ _ -> deprecate "it does nothing; look into -XDefaultSignatures and -XDeriveGeneric for generic programming support." ),
1690   ( "ImplicitPrelude",                  Opt_ImplicitPrelude, nop ),
1691   ( "RecordWildCards",                  Opt_RecordWildCards, nop ),
1692   ( "NamedFieldPuns",                   Opt_RecordPuns, nop ),
1693   ( "RecordPuns",                       Opt_RecordPuns,
1694     deprecatedForExtension "NamedFieldPuns" ),
1695   ( "DisambiguateRecordFields",         Opt_DisambiguateRecordFields, nop ),
1696   ( "OverloadedStrings",                Opt_OverloadedStrings, nop ),
1697   ( "GADTs",                            Opt_GADTs, nop ),
1698   ( "GADTSyntax",                       Opt_GADTSyntax, nop ),
1699   ( "ViewPatterns",                     Opt_ViewPatterns, nop ),
1700   ( "TypeFamilies",                     Opt_TypeFamilies, nop ),
1701   ( "BangPatterns",                     Opt_BangPatterns, nop ),
1702   ( "MonomorphismRestriction",          Opt_MonomorphismRestriction, nop ),
1703   ( "NPlusKPatterns",                   Opt_NPlusKPatterns, nop ),
1704   ( "DoAndIfThenElse",                  Opt_DoAndIfThenElse, nop ),
1705   ( "RebindableSyntax",                 Opt_RebindableSyntax, nop ),
1706   ( "MonoPatBinds",                     Opt_MonoPatBinds, nop ),
1707   ( "ExplicitForAll",                   Opt_ExplicitForAll, nop ),
1708   ( "AlternativeLayoutRule",            Opt_AlternativeLayoutRule, nop ),
1709   ( "AlternativeLayoutRuleTransitional",Opt_AlternativeLayoutRuleTransitional, nop ),
1710   ( "DatatypeContexts",                 Opt_DatatypeContexts, nop ),
1711   ( "NondecreasingIndentation",         Opt_NondecreasingIndentation, nop ),
1712   ( "RelaxedLayout",                    Opt_RelaxedLayout, nop ),
1713   ( "MonoLocalBinds",                   Opt_MonoLocalBinds, nop ),
1714   ( "RelaxedPolyRec",                   Opt_RelaxedPolyRec,
1715     \ turn_on -> if not turn_on
1716                  then deprecate "You can't turn off RelaxedPolyRec any more"
1717                  else return () ),
1718   ( "ExtendedDefaultRules",             Opt_ExtendedDefaultRules, nop ),
1719   ( "ImplicitParams",                   Opt_ImplicitParams, nop ),
1720   ( "ScopedTypeVariables",              Opt_ScopedTypeVariables, nop ),
1721
1722   ( "PatternSignatures",                Opt_ScopedTypeVariables,
1723     deprecatedForExtension "ScopedTypeVariables" ),
1724
1725   ( "UnboxedTuples",                    Opt_UnboxedTuples, nop ),
1726   ( "StandaloneDeriving",               Opt_StandaloneDeriving, nop ),
1727   ( "DeriveDataTypeable",               Opt_DeriveDataTypeable, nop ),
1728   ( "DeriveFunctor",                    Opt_DeriveFunctor, nop ),
1729   ( "DeriveTraversable",                Opt_DeriveTraversable, nop ),
1730   ( "DeriveFoldable",                   Opt_DeriveFoldable, nop ),
1731   ( "DeriveGeneric",                    Opt_DeriveGeneric, nop ),
1732   ( "DefaultSignatures",                Opt_DefaultSignatures, nop ),
1733   ( "TypeSynonymInstances",             Opt_TypeSynonymInstances, nop ),
1734   ( "FlexibleContexts",                 Opt_FlexibleContexts, nop ),
1735   ( "FlexibleInstances",                Opt_FlexibleInstances, nop ),
1736   ( "ConstrainedClassMethods",          Opt_ConstrainedClassMethods, nop ),
1737   ( "MultiParamTypeClasses",            Opt_MultiParamTypeClasses, nop ),
1738   ( "FunctionalDependencies",           Opt_FunctionalDependencies, nop ),
1739   ( "GeneralizedNewtypeDeriving",       Opt_GeneralizedNewtypeDeriving, nop ),
1740   ( "OverlappingInstances",             Opt_OverlappingInstances, nop ),
1741   ( "UndecidableInstances",             Opt_UndecidableInstances, nop ),
1742   ( "IncoherentInstances",              Opt_IncoherentInstances, nop ),
1743   ( "PackageImports",                   Opt_PackageImports, nop )
1744   ]
1745
1746 defaultFlags :: [DynFlag]
1747 defaultFlags
1748   = [ Opt_AutoLinkPackages,
1749       Opt_ReadUserPackageConf,
1750
1751       Opt_SharedImplib,
1752
1753 #if GHC_DEFAULT_NEW_CODEGEN
1754       Opt_TryNewCodeGen,
1755 #endif
1756
1757       Opt_GenManifest,
1758       Opt_EmbedManifest,
1759       Opt_PrintBindContents,
1760       Opt_GhciSandbox,
1761       Opt_HelpfulErrors
1762     ]
1763
1764     ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
1765              -- The default -O0 options
1766
1767     ++ standardWarnings
1768
1769 impliedFlags :: [(ExtensionFlag, TurnOnFlag, ExtensionFlag)]
1770 impliedFlags
1771   = [ (Opt_RankNTypes,                turnOn, Opt_ExplicitForAll)
1772     , (Opt_Rank2Types,                turnOn, Opt_ExplicitForAll)
1773     , (Opt_ScopedTypeVariables,       turnOn, Opt_ExplicitForAll)
1774     , (Opt_LiberalTypeSynonyms,       turnOn, Opt_ExplicitForAll)
1775     , (Opt_ExistentialQuantification, turnOn, Opt_ExplicitForAll)
1776     , (Opt_PolymorphicComponents,     turnOn, Opt_ExplicitForAll)
1777     , (Opt_FlexibleInstances,         turnOn, Opt_TypeSynonymInstances)
1778     , (Opt_FunctionalDependencies,    turnOn, Opt_MultiParamTypeClasses)
1779
1780     , (Opt_ModalTypes,                 turnOn,  Opt_RankNTypes)
1781     , (Opt_ModalTypes,                 turnOn,  Opt_ExplicitForAll)
1782     --, (Opt_ModalTypes,                 turnOn,  Opt_RebindableSyntax)
1783     , (Opt_ModalTypes,                 turnOff, Opt_MonomorphismRestriction)
1784
1785     , (Opt_RebindableSyntax, turnOff, Opt_ImplicitPrelude)      -- NB: turn off!
1786
1787     , (Opt_GADTs,            turnOn, Opt_GADTSyntax)
1788     , (Opt_GADTs,            turnOn, Opt_MonoLocalBinds)
1789     , (Opt_TypeFamilies,     turnOn, Opt_MonoLocalBinds)
1790
1791     , (Opt_TypeFamilies,     turnOn, Opt_KindSignatures)  -- Type families use kind signatures
1792                                                      -- all over the place
1793
1794     , (Opt_ImpredicativeTypes,  turnOn, Opt_RankNTypes)
1795
1796         -- Record wild-cards implies field disambiguation
1797         -- Otherwise if you write (C {..}) you may well get
1798         -- stuff like " 'a' not in scope ", which is a bit silly
1799         -- if the compiler has just filled in field 'a' of constructor 'C'
1800     , (Opt_RecordWildCards,     turnOn, Opt_DisambiguateRecordFields)
1801
1802     , (Opt_ParallelArrays, turnOn, Opt_ParallelListComp)
1803   ]
1804
1805 optLevelFlags :: [([Int], DynFlag)]
1806 optLevelFlags
1807   = [ ([0],     Opt_IgnoreInterfacePragmas)
1808     , ([0],     Opt_OmitInterfacePragmas)
1809
1810     , ([1,2],   Opt_IgnoreAsserts)
1811     , ([1,2],   Opt_EnableRewriteRules)  -- Off for -O0; see Note [Scoping for Builtin rules]
1812                                          --              in PrelRules
1813     , ([1,2],   Opt_DoEtaReduction)
1814     , ([1,2],   Opt_CaseMerge)
1815     , ([1,2],   Opt_Strictness)
1816     , ([1,2],   Opt_CSE)
1817     , ([1,2],   Opt_FullLaziness)
1818     , ([1,2],   Opt_Specialise)
1819     , ([1,2],   Opt_FloatIn)
1820
1821     , ([2],     Opt_LiberateCase)
1822     , ([2],     Opt_SpecConstr)
1823     , ([2],     Opt_RegsGraph)
1824
1825 --     , ([2],     Opt_StaticArgumentTransformation)
1826 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
1827 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
1828 -- several improvements to the heuristics, and I'm concerned that without
1829 -- those changes SAT will interfere with some attempts to write "high
1830 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
1831 -- this year. In particular, the version in HEAD lacks the tail call
1832 -- criterion, so many things that look like reasonable loops will be
1833 -- turned into functions with extra (unneccesary) thunk creation.
1834
1835     , ([0,1,2], Opt_DoLambdaEtaExpansion)
1836                 -- This one is important for a tiresome reason:
1837                 -- we want to make sure that the bindings for data
1838                 -- constructors are eta-expanded.  This is probably
1839                 -- a good thing anyway, but it seems fragile.
1840     ]
1841
1842 -- -----------------------------------------------------------------------------
1843 -- Standard sets of warning options
1844
1845 standardWarnings :: [DynFlag]
1846 standardWarnings
1847     = [ Opt_WarnWarningsDeprecations,
1848         Opt_WarnDeprecatedFlags,
1849         Opt_WarnUnrecognisedPragmas,
1850         Opt_WarnOverlappingPatterns,
1851         Opt_WarnMissingFields,
1852         Opt_WarnMissingMethods,
1853         Opt_WarnDuplicateExports,
1854         Opt_WarnLazyUnliftedBindings,
1855         Opt_WarnDodgyForeignImports,
1856         Opt_WarnWrongDoBind,
1857         Opt_WarnAlternativeLayoutRuleTransitional
1858       ]
1859
1860 minusWOpts :: [DynFlag]
1861 -- Things you get with -W
1862 minusWOpts
1863     = standardWarnings ++
1864       [ Opt_WarnUnusedBinds,
1865         Opt_WarnUnusedMatches,
1866         Opt_WarnUnusedImports,
1867         Opt_WarnIncompletePatterns,
1868         Opt_WarnDodgyExports,
1869         Opt_WarnDodgyImports
1870       ]
1871
1872 minusWallOpts :: [DynFlag]
1873 -- Things you get with -Wall
1874 minusWallOpts
1875     = minusWOpts ++
1876       [ Opt_WarnTypeDefaults,
1877         Opt_WarnNameShadowing,
1878         Opt_WarnMissingSigs,
1879         Opt_WarnHiShadows,
1880         Opt_WarnOrphans,
1881         Opt_WarnUnusedDoBind
1882       ]
1883
1884 minuswRemovesOpts :: [DynFlag]
1885 -- minuswRemovesOpts should be every warning option
1886 minuswRemovesOpts
1887     = minusWallOpts ++
1888       [Opt_WarnTabs,
1889        Opt_WarnIncompletePatternsRecUpd,
1890        Opt_WarnIncompleteUniPatterns,
1891        Opt_WarnMonomorphism,
1892        Opt_WarnUnrecognisedPragmas,
1893        Opt_WarnAutoOrphans,
1894        Opt_WarnImplicitPrelude
1895      ]
1896
1897 enableGlasgowExts :: DynP ()
1898 enableGlasgowExts = do setDynFlag Opt_PrintExplicitForalls
1899                        mapM_ setExtensionFlag glasgowExtsFlags
1900
1901 disableGlasgowExts :: DynP ()
1902 disableGlasgowExts = do unSetDynFlag Opt_PrintExplicitForalls
1903                         mapM_ unSetExtensionFlag glasgowExtsFlags
1904
1905 glasgowExtsFlags :: [ExtensionFlag]
1906 glasgowExtsFlags = [
1907              Opt_ForeignFunctionInterface
1908            , Opt_UnliftedFFITypes
1909            , Opt_ImplicitParams
1910            , Opt_ScopedTypeVariables
1911            , Opt_UnboxedTuples
1912            , Opt_TypeSynonymInstances
1913            , Opt_StandaloneDeriving
1914            , Opt_DeriveDataTypeable
1915            , Opt_DeriveFunctor
1916            , Opt_DeriveFoldable
1917            , Opt_DeriveTraversable
1918            , Opt_DeriveGeneric
1919            , Opt_FlexibleContexts
1920            , Opt_FlexibleInstances
1921            , Opt_ConstrainedClassMethods
1922            , Opt_MultiParamTypeClasses
1923            , Opt_FunctionalDependencies
1924            , Opt_MagicHash
1925            , Opt_PolymorphicComponents
1926            , Opt_ExistentialQuantification
1927            , Opt_UnicodeSyntax
1928            , Opt_PostfixOperators
1929            , Opt_PatternGuards
1930            , Opt_LiberalTypeSynonyms
1931            , Opt_RankNTypes
1932            , Opt_TypeOperators
1933            , Opt_DoRec
1934            , Opt_ParallelListComp
1935            , Opt_EmptyDataDecls
1936            , Opt_KindSignatures
1937            , Opt_GeneralizedNewtypeDeriving ]
1938
1939 #ifdef GHCI
1940 -- Consult the RTS to find whether GHC itself has been built profiled
1941 -- If so, you can't use Template Haskell
1942 foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt
1943
1944 rtsIsProfiled :: Bool
1945 rtsIsProfiled = unsafePerformIO rtsIsProfiledIO /= 0
1946 #endif
1947
1948 checkTemplateHaskellOk :: Bool -> DynP ()
1949 #ifdef GHCI
1950 checkTemplateHaskellOk turn_on
1951   | turn_on && rtsIsProfiled
1952   = addErr "You can't use Template Haskell with a profiled compiler"
1953   | otherwise
1954   = return ()
1955 #else
1956 -- In stage 1 we don't know that the RTS has rts_isProfiled,
1957 -- so we simply say "ok".  It doesn't matter because TH isn't
1958 -- available in stage 1 anyway.
1959 checkTemplateHaskellOk _ = return ()
1960 #endif
1961
1962 {- **********************************************************************
1963 %*                                                                      *
1964                 DynFlags constructors
1965 %*                                                                      *
1966 %********************************************************************* -}
1967
1968 type DynP = EwM (CmdLineP DynFlags)
1969
1970 upd :: (DynFlags -> DynFlags) -> DynP ()
1971 upd f = liftEwM (do dflags <- getCmdLineState
1972                     putCmdLineState $! f dflags)
1973
1974 updM :: (DynFlags -> DynP DynFlags) -> DynP ()
1975 updM f = do dflags <- liftEwM getCmdLineState
1976             dflags' <- f dflags
1977             liftEwM $ putCmdLineState $! dflags'
1978
1979 --------------- Constructor functions for OptKind -----------------
1980 noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1981 noArg fn = NoArg (upd fn)
1982
1983 noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
1984 noArgM fn = NoArg (updM fn)
1985
1986 noArgDF :: (DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1987 noArgDF fn deprec = NoArg (upd fn >> deprecate deprec)
1988
1989 hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1990 hasArg fn = HasArg (upd . fn)
1991
1992 hasArgDF :: (String -> DynFlags -> DynFlags) -> String -> OptKind (CmdLineP DynFlags)
1993 hasArgDF fn deprec = HasArg (\s -> do { upd (fn s)
1994                                       ; deprecate deprec })
1995
1996 intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
1997 intSuffix fn = IntSuffix (\n -> upd (fn n))
1998
1999 optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)
2000               -> OptKind (CmdLineP DynFlags)
2001 optIntSuffixM fn = OptIntSuffix (\mi -> updM (fn mi))
2002
2003 setDumpFlag :: DynFlag -> OptKind (CmdLineP DynFlags)
2004 setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)
2005
2006 --------------------------
2007 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
2008 setDynFlag   f = upd (\dfs -> dopt_set dfs f)
2009 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
2010
2011 --------------------------
2012 setExtensionFlag, unSetExtensionFlag :: ExtensionFlag -> DynP ()
2013 setExtensionFlag f = do { upd (\dfs -> xopt_set dfs f)
2014                         ; sequence_ deps }
2015   where
2016     deps = [ if turn_on then setExtensionFlag   d
2017                         else unSetExtensionFlag d
2018            | (f', turn_on, d) <- impliedFlags, f' == f ]
2019         -- When you set f, set the ones it implies
2020         -- NB: use setExtensionFlag recursively, in case the implied flags
2021         --     implies further flags
2022
2023 unSetExtensionFlag f = upd (\dfs -> xopt_unset dfs f)
2024    -- When you un-set f, however, we don't un-set the things it implies
2025    --      (except for -fno-glasgow-exts, which is treated specially)
2026
2027 --------------------------
2028 alterSettings :: (Settings -> Settings) -> DynFlags -> DynFlags
2029 alterSettings f dflags = dflags { settings = f (settings dflags) }
2030
2031 --------------------------
2032 setDumpFlag' :: DynFlag -> DynP ()
2033 setDumpFlag' dump_flag
2034   = do { setDynFlag dump_flag
2035        ; when want_recomp forceRecompile }
2036   where
2037         -- Certain dumpy-things are really interested in what's going
2038         -- on during recompilation checking, so in those cases we
2039         -- don't want to turn it off.
2040     want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
2041                                        Opt_D_dump_hi_diffs]
2042
2043 forceRecompile :: DynP ()
2044 -- Whenver we -ddump, force recompilation (by switching off the
2045 -- recompilation checker), else you don't see the dump! However,
2046 -- don't switch it off in --make mode, else *everything* gets
2047 -- recompiled which probably isn't what you want
2048 forceRecompile = do { dfs <- liftEwM getCmdLineState
2049                     ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
2050         where
2051           force_recomp dfs = isOneShot (ghcMode dfs)
2052
2053 setVerboseCore2Core :: DynP ()
2054 setVerboseCore2Core = do forceRecompile
2055                          setDynFlag Opt_D_verbose_core2core
2056                          upd (\dfs -> dfs { shouldDumpSimplPhase = Nothing })
2057
2058 setDumpSimplPhases :: String -> DynP ()
2059 setDumpSimplPhases s = do forceRecompile
2060                           upd (\dfs -> dfs { shouldDumpSimplPhase = Just spec })
2061   where
2062     spec = case s of { ('=' : s') -> s';  _ -> s }
2063
2064 setVerbosity :: Maybe Int -> DynP ()
2065 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2066
2067 addCmdlineHCInclude :: String -> DynP ()
2068 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes =  a : cmdlineHcIncludes s})
2069
2070 extraPkgConf_ :: FilePath -> DynP ()
2071 extraPkgConf_  p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2072
2073 exposePackage, exposePackageId, hidePackage, ignorePackage :: String -> DynP ()
2074 exposePackage p =
2075   upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2076 exposePackageId p =
2077   upd (\s -> s{ packageFlags = ExposePackageId p : packageFlags s })
2078 hidePackage p =
2079   upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2080 ignorePackage p =
2081   upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2082
2083 setPackageName :: String -> DynFlags -> DynFlags
2084 setPackageName p s =  s{ thisPackage = stringToPackageId p }
2085
2086 -- If we're linking a binary, then only targets that produce object
2087 -- code are allowed (requests for other target types are ignored).
2088 setTarget :: HscTarget -> DynP ()
2089 setTarget l = upd set
2090   where
2091    set dfs
2092      | ghcLink dfs /= LinkBinary || isObjectTarget l  = dfs{ hscTarget = l }
2093      | otherwise = dfs
2094
2095 -- Changes the target only if we're compiling object code.  This is
2096 -- used by -fasm and -fllvm, which switch from one to the other, but
2097 -- not from bytecode to object-code.  The idea is that -fasm/-fllvm
2098 -- can be safely used in an OPTIONS_GHC pragma.
2099 setObjTarget :: HscTarget -> DynP ()
2100 setObjTarget l = updM set
2101   where
2102    set dflags
2103      | isObjectTarget (hscTarget dflags)
2104        = case l of
2105          HscC
2106           | cGhcUnregisterised /= "YES" ->
2107              do addWarn ("Compiler not unregisterised, so ignoring " ++ flag)
2108                 return dflags
2109          HscAsm
2110           | cGhcWithNativeCodeGen /= "YES" ->
2111              do addWarn ("Compiler has no native codegen, so ignoring " ++
2112                          flag)
2113                 return dflags
2114          HscLlvm
2115           | cGhcUnregisterised == "YES" ->
2116              do addWarn ("Compiler unregisterised, so ignoring " ++ flag)
2117                 return dflags
2118           | not ((arch == ArchX86_64) && (os == OSLinux || os == OSDarwin)) &&
2119             (not opt_Static || opt_PIC)
2120             ->
2121              do addWarn ("Ignoring " ++ flag ++ " as it is incompatible with -fPIC and -dynamic on this platform")
2122                 return dflags
2123          _ -> return $ dflags { hscTarget = l }
2124      | otherwise = return dflags
2125      where platform = targetPlatform dflags
2126            arch = platformArch platform
2127            os   = platformOS   platform
2128            flag = showHscTargetFlag l
2129
2130 setOptLevel :: Int -> DynFlags -> DynP DynFlags
2131 setOptLevel n dflags
2132    | hscTarget dflags == HscInterpreted && n > 0
2133         = do addWarn "-O conflicts with --interactive; -O ignored."
2134              return dflags
2135    | otherwise
2136         = return (updOptLevel n dflags)
2137
2138
2139 -- -Odph is equivalent to
2140 --
2141 --    -O2                               optimise as much as possible
2142 --    -fmax-simplifier-iterations20     this is necessary sometimes
2143 --    -fsimplifier-phases=3             we use an additional simplifier phase for fusion
2144 --
2145 setDPHOpt :: DynFlags -> DynP DynFlags
2146 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations  = 20
2147                                          , simplPhases         = 3
2148                                          })
2149
2150 -- Determines the package used by the vectoriser for the symbols of the vectorised code.
2151 -- 'DPHNone' indicates that no data-parallel backend library is available; hence, the
2152 -- vectoriser cannot be used.
2153 --
2154 data DPHBackend = DPHPar    -- "dph-par"
2155                 | DPHSeq    -- "dph-seq"
2156                 | DPHThis   -- the currently compiled package
2157                 | DPHNone   -- no DPH library available
2158         deriving(Eq, Ord, Enum, Show)
2159
2160 setDPHBackend :: DPHBackend -> DynP ()
2161 setDPHBackend backend = upd $ \dflags -> dflags { dphBackend = backend }
2162
2163 -- Query the DPH backend package to be used by the vectoriser and desugaring of DPH syntax.
2164 --
2165 dphPackageMaybe :: DynFlags -> Maybe PackageId
2166 dphPackageMaybe dflags
2167   = case dphBackend dflags of
2168       DPHPar  -> Just dphParPackageId
2169       DPHSeq  -> Just dphSeqPackageId
2170       DPHThis -> Just (thisPackage dflags)
2171       DPHNone -> Nothing
2172
2173 setMainIs :: String -> DynP ()
2174 setMainIs arg
2175   | not (null main_fn) && isLower (head main_fn)
2176      -- The arg looked like "Foo.Bar.baz"
2177   = upd $ \d -> d{ mainFunIs = Just main_fn,
2178                    mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2179
2180   | isUpper (head arg)  -- The arg looked like "Foo" or "Foo.Bar"
2181   = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2182
2183   | otherwise                   -- The arg looked like "baz"
2184   = upd $ \d -> d{ mainFunIs = Just arg }
2185   where
2186     (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2187
2188 -----------------------------------------------------------------------------
2189 -- Paths & Libraries
2190
2191 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2192
2193 -- -i on its own deletes the import paths
2194 addImportPath "" = upd (\s -> s{importPaths = []})
2195 addImportPath p  = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2196
2197 addLibraryPath p =
2198   upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2199
2200 addIncludePath p =
2201   upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2202
2203 addFrameworkPath p =
2204   upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2205
2206 #ifndef mingw32_TARGET_OS
2207 split_marker :: Char
2208 split_marker = ':'   -- not configurable (ToDo)
2209 #endif
2210
2211 splitPathList :: String -> [String]
2212 splitPathList s = filter notNull (splitUp s)
2213                 -- empty paths are ignored: there might be a trailing
2214                 -- ':' in the initial list, for example.  Empty paths can
2215                 -- cause confusion when they are translated into -I options
2216                 -- for passing to gcc.
2217   where
2218 #ifndef mingw32_TARGET_OS
2219     splitUp xs = split split_marker xs
2220 #else
2221      -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2222      --
2223      -- That is, if "foo:bar:baz" is used, this interpreted as
2224      -- consisting of three entries, 'foo', 'bar', 'baz'.
2225      -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2226      -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2227      --
2228      -- Notice that no attempt is made to fully replace the 'standard'
2229      -- split marker ':' with the Windows / DOS one, ';'. The reason being
2230      -- that this will cause too much breakage for users & ':' will
2231      -- work fine even with DOS paths, if you're not insisting on being silly.
2232      -- So, use either.
2233     splitUp []             = []
2234     splitUp (x:':':div:xs) | div `elem` dir_markers
2235                            = ((x:':':div:p): splitUp rs)
2236                            where
2237                               (p,rs) = findNextPath xs
2238           -- we used to check for existence of the path here, but that
2239           -- required the IO monad to be threaded through the command-line
2240           -- parser which is quite inconvenient.  The
2241     splitUp xs = cons p (splitUp rs)
2242                where
2243                  (p,rs) = findNextPath xs
2244
2245                  cons "" xs = xs
2246                  cons x  xs = x:xs
2247
2248     -- will be called either when we've consumed nought or the
2249     -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2250     -- finding the next split marker.
2251     findNextPath xs =
2252         case break (`elem` split_markers) xs of
2253            (p, _:ds) -> (p, ds)
2254            (p, xs)   -> (p, xs)
2255
2256     split_markers :: [Char]
2257     split_markers = [':', ';']
2258
2259     dir_markers :: [Char]
2260     dir_markers = ['/', '\\']
2261 #endif
2262
2263 -- -----------------------------------------------------------------------------
2264 -- tmpDir, where we store temporary files.
2265
2266 setTmpDir :: FilePath -> DynFlags -> DynFlags
2267 setTmpDir dir = alterSettings (\s -> s { sTmpDir = normalise dir })
2268   -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2269   -- seem necessary now --SDM 7/2/2008
2270
2271 -----------------------------------------------------------------------------
2272 -- RTS opts
2273
2274 setRtsOpts :: String -> DynP ()
2275 setRtsOpts arg  = upd $ \ d -> d {rtsOpts = Just arg}
2276
2277 setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
2278 setRtsOptsEnabled arg  = upd $ \ d -> d {rtsOptsEnabled = arg}
2279
2280 -----------------------------------------------------------------------------
2281 -- Hpc stuff
2282
2283 setOptHpcDir :: String -> DynP ()
2284 setOptHpcDir arg  = upd $ \ d -> d{hpcDir = arg}
2285
2286 -----------------------------------------------------------------------------
2287 -- Via-C compilation stuff
2288
2289 -- There are some options that we need to pass to gcc when compiling
2290 -- Haskell code via C, but are only supported by recent versions of
2291 -- gcc.  The configure script decides which of these options we need,
2292 -- and puts them in the "settings" file in $topdir. The advantage of
2293 -- having these in a separate file is that the file can be created at
2294 -- install-time depending on the available gcc version, and even
2295 -- re-generated later if gcc is upgraded.
2296 --
2297 -- The options below are not dependent on the version of gcc, only the
2298 -- platform.
2299
2300 picCCOpts :: DynFlags -> [String]
2301 picCCOpts _dflags
2302 #if darwin_TARGET_OS
2303       -- Apple prefers to do things the other way round.
2304       -- PIC is on by default.
2305       -- -mdynamic-no-pic:
2306       --     Turn off PIC code generation.
2307       -- -fno-common:
2308       --     Don't generate "common" symbols - these are unwanted
2309       --     in dynamic libraries.
2310
2311     | opt_PIC
2312         = ["-fno-common", "-U __PIC__","-D__PIC__"]
2313     | otherwise
2314         = ["-mdynamic-no-pic"]
2315 #elif mingw32_TARGET_OS
2316       -- no -fPIC for Windows
2317     | opt_PIC
2318         = ["-U __PIC__","-D__PIC__"]
2319     | otherwise
2320         = []
2321 #else
2322       -- we need -fPIC for C files when we are compiling with -dynamic,
2323       -- otherwise things like stub.c files don't get compiled
2324       -- correctly.  They need to reference data in the Haskell
2325       -- objects, but can't without -fPIC.  See
2326       -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/PositionIndependentCode
2327     | opt_PIC || not opt_Static
2328         = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2329     | otherwise
2330         = []
2331 #endif
2332
2333 -- -----------------------------------------------------------------------------
2334 -- Splitting
2335
2336 can_split :: Bool
2337 can_split = cSupportsSplitObjs == "YES"
2338
2339 -- -----------------------------------------------------------------------------
2340 -- Compiler Info
2341
2342 compilerInfo :: DynFlags -> [(String, String)]
2343 compilerInfo dflags
2344     = -- We always make "Project name" be first to keep parsing in
2345       -- other languages simple, i.e. when looking for other fields,
2346       -- you don't have to worry whether there is a leading '[' or not
2347       ("Project name",                 cProjectName)
2348       -- Next come the settings, so anything else can be overridden
2349       -- in the settings file (as "lookup" uses the first match for the
2350       -- key)
2351     : rawSettings dflags
2352    ++ [("Project version",             cProjectVersion),
2353        ("Booter version",              cBooterVersion),
2354        ("Stage",                       cStage),
2355        ("Build platform",              cBuildPlatformString),
2356        ("Host platform",               cHostPlatformString),
2357        ("Target platform",             cTargetPlatformString),
2358        ("Have interpreter",            cGhcWithInterpreter),
2359        ("Object splitting supported",  cSupportsSplitObjs),
2360        ("Have native code generator",  cGhcWithNativeCodeGen),
2361        ("Support SMP",                 cGhcWithSMP),
2362        ("Unregisterised",              cGhcUnregisterised),
2363        ("Tables next to code",         cGhcEnableTablesNextToCode),
2364        ("RTS ways",                    cGhcRTSWays),
2365        ("Leading underscore",          cLeadingUnderscore),
2366        ("Debug on",                    show debugIsOn),
2367        ("LibDir",                      topDir dflags),
2368        ("Global Package DB",           systemPackageConfig dflags),
2369        ("Gcc Linker flags",            show cGccLinkerOpts),
2370        ("Ld Linker flags",             show cLdLinkerOpts)
2371       ]
2372