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