compiler/main/DynFlags.hs

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