compiler/main/DynFlags.hs

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