compiler/main/DynFlags.hs

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