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