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