compiler/main/DynFlags.hs

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