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