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