compiler/main/DynFlags.hs

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