compiler/main/DynFlags.hs

   1
   2 -- |
   3 -- Dynamic flags
   4 --
   5 --
   6 -- (c) The University of Glasgow 2005
   7 --
   8
   9 -- Most flags are dynamic flags, which means they can change from
  10 -- compilation to compilation using @OPTIONS_GHC@ pragmas, and in a
  11 -- multi-session GHC each session can be using different dynamic
  12 -- flags.  Dynamic flags can also be set at the prompt in GHCi.
  13 module DynFlags (
  14         -- * Dynamic flags and associated configuration types
  15         DynFlag(..),
  16         DynFlags(..),
  17         HscTarget(..), isObjectTarget, defaultObjectTarget,
  18         GhcMode(..), isOneShot,
  19         GhcLink(..), isNoLink,
  20         PackageFlag(..),
  21         Option(..),
  22         DynLibLoader(..),
  23         fFlags, xFlags,
  24         dphPackage,
  25
  26         -- ** Manipulating DynFlags
  27         defaultDynFlags,                -- DynFlags
  28         initDynFlags,                   -- DynFlags -> IO DynFlags
  29
  30         dopt,                           -- DynFlag -> DynFlags -> Bool
  31         dopt_set, dopt_unset,           -- DynFlags -> DynFlag -> DynFlags
  32         getOpts,                        -- DynFlags -> (DynFlags -> [a]) -> [a]
  33         getVerbFlag,
  34         getMainFun,
  35         updOptLevel,
  36         setTmpDir,
  37         setPackageName,
  38
  39         -- ** Parsing DynFlags
  40         parseDynamicFlags,
  41         parseDynamicNoPackageFlags,
  42         allFlags,
  43
  44         supportedLanguages, languageOptions,
  45
  46         -- ** DynFlag C compiler options
  47         machdepCCOpts, picCCOpts,
  48
  49         -- * Configuration of the core-to-core passes
  50         CoreToDo(..),
  51         SimplifierMode(..),
  52         SimplifierSwitch(..),
  53         FloatOutSwitches(..),
  54         getCoreToDo,
  55
  56         -- * Configuration of the stg-to-stg passes
  57         StgToDo(..),
  58         getStgToDo,
  59
  60         -- * Compiler configuration suitable for display to the user
  61         compilerInfo
  62   ) where
  63
  64 #include "HsVersions.h"
  65
  66 import Module
  67 import PackageConfig
  68 import PrelNames        ( mAIN, main_RDR_Unqual )
  69 import RdrName          ( RdrName, mkRdrUnqual )
  70 import OccName          ( mkVarOccFS )
  71 #ifdef i386_TARGET_ARCH
  72 import StaticFlags      ( opt_Static )
  73 #endif
  74 import StaticFlags      ( opt_PIC, WayName(..), v_Ways, v_Build_tag,
  75                           v_RTS_Build_tag )
  76 import {-# SOURCE #-} Packages (PackageState)
  77 import DriverPhases     ( Phase(..), phaseInputExt )
  78 import Config
  79 import CmdLineParser
  80 import Constants        ( mAX_CONTEXT_REDUCTION_DEPTH )
  81 import Panic
  82 import UniqFM           ( UniqFM )
  83 import Util
  84 import Maybes           ( orElse )
  85 import SrcLoc
  86 import FastString
  87 import Outputable
  88 import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
  89
  90 import Data.IORef       ( readIORef )
  91 import Control.Monad    ( when )
  92
  93 import Data.Char
  94 import System.FilePath
  95 import System.IO        ( stderr, hPutChar )
  96
  97 -- -----------------------------------------------------------------------------
  98 -- DynFlags
  99
 100 -- | Enumerates the simple on-or-off dynamic flags
 101 data DynFlag
 102
 103    -- debugging flags
 104    = Opt_D_dump_cmm
 105    | Opt_D_dump_cmmz
 106    | Opt_D_dump_cmmz_pretty
 107    | Opt_D_dump_cps_cmm
 108    | Opt_D_dump_cvt_cmm
 109    | Opt_D_dump_asm
 110    | Opt_D_dump_asm_native
 111    | Opt_D_dump_asm_liveness
 112    | Opt_D_dump_asm_coalesce
 113    | Opt_D_dump_asm_regalloc
 114    | Opt_D_dump_asm_regalloc_stages
 115    | Opt_D_dump_asm_conflicts
 116    | Opt_D_dump_asm_stats
 117    | Opt_D_dump_cpranal
 118    | Opt_D_dump_deriv
 119    | Opt_D_dump_ds
 120    | Opt_D_dump_flatC
 121    | Opt_D_dump_foreign
 122    | Opt_D_dump_inlinings
 123    | Opt_D_dump_rule_firings
 124    | Opt_D_dump_occur_anal
 125    | Opt_D_dump_parsed
 126    | Opt_D_dump_rn
 127    | Opt_D_dump_simpl
 128    | Opt_D_dump_simpl_iterations
 129    | Opt_D_dump_simpl_phases
 130    | Opt_D_dump_spec
 131    | Opt_D_dump_prep
 132    | Opt_D_dump_stg
 133    | Opt_D_dump_stranal
 134    | Opt_D_dump_tc
 135    | Opt_D_dump_types
 136    | Opt_D_dump_rules
 137    | Opt_D_dump_cse
 138    | Opt_D_dump_worker_wrapper
 139    | Opt_D_dump_rn_trace
 140    | Opt_D_dump_rn_stats
 141    | Opt_D_dump_opt_cmm
 142    | Opt_D_dump_simpl_stats
 143    | Opt_D_dump_tc_trace
 144    | Opt_D_dump_if_trace
 145    | Opt_D_dump_splices
 146    | Opt_D_dump_BCOs
 147    | Opt_D_dump_vect
 148    | Opt_D_dump_hpc
 149    | Opt_D_dump_rtti
 150    | Opt_D_source_stats
 151    | Opt_D_verbose_core2core
 152    | Opt_D_verbose_stg2stg
 153    | Opt_D_dump_hi
 154    | Opt_D_dump_hi_diffs
 155    | Opt_D_dump_minimal_imports
 156    | Opt_D_dump_mod_cycles
 157    | Opt_D_dump_view_pattern_commoning
 158    | Opt_D_faststring_stats
 159    | Opt_DumpToFile                     -- ^ Append dump output to files instead of stdout.
 160    | Opt_D_no_debug_output
 161    | Opt_DoCoreLinting
 162    | Opt_DoStgLinting
 163    | Opt_DoCmmLinting
 164    | Opt_DoAsmLinting
 165
 166    | Opt_WarnIsError                    -- -Werror; makes warnings fatal
 167    | Opt_WarnDuplicateExports
 168    | Opt_WarnHiShadows
 169    | Opt_WarnImplicitPrelude
 170    | Opt_WarnIncompletePatterns
 171    | Opt_WarnIncompletePatternsRecUpd
 172    | Opt_WarnMissingFields
 173    | Opt_WarnMissingMethods
 174    | Opt_WarnMissingSigs
 175    | Opt_WarnNameShadowing
 176    | Opt_WarnOverlappingPatterns
 177    | Opt_WarnSimplePatterns
 178    | Opt_WarnTypeDefaults
 179    | Opt_WarnMonomorphism
 180    | Opt_WarnUnusedBinds
 181    | Opt_WarnUnusedImports
 182    | Opt_WarnUnusedMatches
 183    | Opt_WarnWarningsDeprecations
 184    | Opt_WarnDeprecatedFlags
 185    | Opt_WarnDodgyImports
 186    | Opt_WarnOrphans
 187    | Opt_WarnTabs
 188    | Opt_WarnUnrecognisedPragmas
 189    | Opt_WarnDodgyForeignImports
 190
 191    -- language opts
 192    | Opt_OverlappingInstances
 193    | Opt_UndecidableInstances
 194    | Opt_IncoherentInstances
 195    | Opt_MonomorphismRestriction
 196    | Opt_MonoPatBinds
 197    | Opt_ExtendedDefaultRules           -- Use GHC's extended rules for defaulting
 198    | Opt_ForeignFunctionInterface
 199    | Opt_UnliftedFFITypes
 200    | Opt_PArr                           -- Syntactic support for parallel arrays
 201    | Opt_Arrows                         -- Arrow-notation syntax
 202    | Opt_TemplateHaskell
 203    | Opt_QuasiQuotes
 204    | Opt_ImplicitParams
 205    | Opt_Generics                       -- "Derivable type classes"
 206    | Opt_ImplicitPrelude
 207    | Opt_ScopedTypeVariables
 208    | Opt_UnboxedTuples
 209    | Opt_BangPatterns
 210    | Opt_TypeFamilies
 211    | Opt_OverloadedStrings
 212    | Opt_DisambiguateRecordFields
 213    | Opt_RecordWildCards
 214    | Opt_RecordPuns
 215    | Opt_ViewPatterns
 216    | Opt_GADTs
 217    | Opt_RelaxedPolyRec
 218    | Opt_StandaloneDeriving
 219    | Opt_DeriveDataTypeable
 220    | Opt_TypeSynonymInstances
 221    | Opt_FlexibleContexts
 222    | Opt_FlexibleInstances
 223    | Opt_ConstrainedClassMethods
 224    | Opt_MultiParamTypeClasses
 225    | Opt_FunctionalDependencies
 226    | Opt_UnicodeSyntax
 227    | Opt_PolymorphicComponents
 228    | Opt_ExistentialQuantification
 229    | Opt_MagicHash
 230    | Opt_EmptyDataDecls
 231    | Opt_KindSignatures
 232    | Opt_ParallelListComp
 233    | Opt_TransformListComp
 234    | Opt_GeneralizedNewtypeDeriving
 235    | Opt_RecursiveDo
 236    | Opt_PostfixOperators
 237    | Opt_PatternGuards
 238    | Opt_LiberalTypeSynonyms
 239    | Opt_Rank2Types
 240    | Opt_RankNTypes
 241    | Opt_ImpredicativeTypes
 242    | Opt_TypeOperators
 243    | Opt_PackageImports
 244    | Opt_NewQualifiedOperators
 245
 246    | Opt_PrintExplicitForalls
 247
 248    -- optimisation opts
 249    | Opt_Strictness
 250    | Opt_FullLaziness
 251    | Opt_StaticArgumentTransformation
 252    | Opt_CSE
 253    | Opt_LiberateCase
 254    | Opt_SpecConstr
 255    | Opt_IgnoreInterfacePragmas
 256    | Opt_OmitInterfacePragmas
 257    | Opt_DoLambdaEtaExpansion
 258    | Opt_IgnoreAsserts
 259    | Opt_DoEtaReduction
 260    | Opt_CaseMerge
 261    | Opt_UnboxStrictFields
 262    | Opt_MethodSharing
 263    | Opt_DictsCheap
 264    | Opt_EnableRewriteRules             -- Apply rewrite rules during simplification
 265    | Opt_Vectorise
 266    | Opt_RegsGraph                      -- do graph coloring register allocation
 267    | Opt_RegsIterative                  -- do iterative coalescing graph coloring register allocation
 268
 269    -- misc opts
 270    | Opt_Cpp
 271    | Opt_Pp
 272    | Opt_ForceRecomp
 273    | Opt_DryRun
 274    | Opt_DoAsmMangling
 275    | Opt_ExcessPrecision
 276    | Opt_ReadUserPackageConf
 277    | Opt_NoHsMain
 278    | Opt_SplitObjs
 279    | Opt_StgStats
 280    | Opt_HideAllPackages
 281    | Opt_PrintBindResult
 282    | Opt_Haddock
 283    | Opt_HaddockOptions
 284    | Opt_Hpc_No_Auto
 285    | Opt_BreakOnException
 286    | Opt_BreakOnError
 287    | Opt_PrintEvldWithShow
 288    | Opt_PrintBindContents
 289    | Opt_GenManifest
 290    | Opt_EmbedManifest
 291    | Opt_RunCPSZ
 292    | Opt_ConvertToZipCfgAndBack
 293    | Opt_AutoLinkPackages
 294    | Opt_ImplicitImportQualified
 295
 296    -- keeping stuff
 297    | Opt_KeepHiDiffs
 298    | Opt_KeepHcFiles
 299    | Opt_KeepSFiles
 300    | Opt_KeepRawSFiles
 301    | Opt_KeepTmpFiles
 302    | Opt_KeepRawTokenStream
 303
 304    deriving (Eq, Show)
 305
 306 -- | Contains not only a collection of 'DynFlag's but also a plethora of
 307 -- information relating to the compilation of a single file or GHC session
 308 data DynFlags = DynFlags {
 309   ghcMode               :: GhcMode,
 310   ghcLink               :: GhcLink,
 311   coreToDo              :: Maybe [CoreToDo], -- reserved for -Ofile
 312   stgToDo               :: Maybe [StgToDo],  -- similarly
 313   hscTarget             :: HscTarget,
 314   hscOutName            :: String,      -- ^ Name of the output file
 315   extCoreName           :: String,      -- ^ Name of the .hcr output file
 316   verbosity             :: Int,         -- ^ Verbosity level: see "DynFlags#verbosity_levels"
 317   optLevel              :: Int,         -- ^ Optimisation level
 318   simplPhases           :: Int,         -- ^ Number of simplifier phases
 319   maxSimplIterations    :: Int,         -- ^ Max simplifier iterations
 320   shouldDumpSimplPhase  :: SimplifierMode -> Bool,
 321   ruleCheck             :: Maybe String,
 322
 323   specConstrThreshold   :: Maybe Int,   -- ^ Threshold for SpecConstr
 324   specConstrCount       :: Maybe Int,   -- ^ Max number of specialisations for any one function
 325   liberateCaseThreshold :: Maybe Int,   -- ^ Threshold for LiberateCase
 326
 327   stolen_x86_regs       :: Int,
 328   cmdlineHcIncludes     :: [String],    -- ^ @\-\#includes@
 329   importPaths           :: [FilePath],
 330   mainModIs             :: Module,
 331   mainFunIs             :: Maybe String,
 332   ctxtStkDepth          :: Int,         -- ^ Typechecker context stack depth
 333
 334   dphBackend            :: DPHBackend,
 335
 336   thisPackage           :: PackageId,   -- ^ name of package currently being compiled
 337
 338   -- ways
 339   wayNames              :: [WayName],   -- ^ Way flags from the command line
 340   buildTag              :: String,      -- ^ The global \"way\" (e.g. \"p\" for prof)
 341   rtsBuildTag           :: String,      -- ^ The RTS \"way\"
 342
 343   -- paths etc.
 344   objectDir             :: Maybe String,
 345   hiDir                 :: Maybe String,
 346   stubDir               :: Maybe String,
 347
 348   objectSuf             :: String,
 349   hcSuf                 :: String,
 350   hiSuf                 :: String,
 351
 352   outputFile            :: Maybe String,
 353   outputHi              :: Maybe String,
 354   dynLibLoader          :: DynLibLoader,
 355
 356   -- | This is set by 'DriverPipeline.runPipeline' based on where
 357   --    its output is going.
 358   dumpPrefix            :: Maybe FilePath,
 359
 360   -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
 361   --    Set by @-ddump-file-prefix@
 362   dumpPrefixForce       :: Maybe FilePath,
 363
 364   includePaths          :: [String],
 365   libraryPaths          :: [String],
 366   frameworkPaths        :: [String],    -- used on darwin only
 367   cmdlineFrameworks     :: [String],    -- ditto
 368   tmpDir                :: String,      -- no trailing '/'
 369
 370   ghcUsagePath          :: FilePath,    -- Filled in by SysTools
 371   ghciUsagePath         :: FilePath,    -- ditto
 372
 373   hpcDir                :: String,      -- ^ Path to store the .mix files
 374
 375   -- options for particular phases
 376   opt_L                 :: [String],
 377   opt_P                 :: [String],
 378   opt_F                 :: [String],
 379   opt_c                 :: [String],
 380   opt_m                 :: [String],
 381   opt_a                 :: [String],
 382   opt_l                 :: [String],
 383   opt_windres           :: [String],
 384
 385   -- commands for particular phases
 386   pgm_L                 :: String,
 387   pgm_P                 :: (String,[Option]),
 388   pgm_F                 :: String,
 389   pgm_c                 :: (String,[Option]),
 390   pgm_m                 :: (String,[Option]),
 391   pgm_s                 :: (String,[Option]),
 392   pgm_a                 :: (String,[Option]),
 393   pgm_l                 :: (String,[Option]),
 394   pgm_dll               :: (String,[Option]),
 395   pgm_T                 :: String,
 396   pgm_sysman            :: String,
 397   pgm_windres           :: String,
 398
 399   --  For ghc -M
 400   depMakefile           :: FilePath,
 401   depIncludePkgDeps     :: Bool,
 402   depExcludeMods        :: [ModuleName],
 403   depSuffixes           :: [String],
 404   depWarnings           :: Bool,
 405
 406   --  Package flags
 407   extraPkgConfs         :: [FilePath],
 408   topDir                :: FilePath,    -- filled in by SysTools
 409   systemPackageConfig   :: FilePath,    -- ditto
 410         -- ^ The @-package-conf@ flags given on the command line, in the order
 411         -- they appeared.
 412
 413   packageFlags          :: [PackageFlag],
 414         -- ^ The @-package@ and @-hide-package@ flags from the command-line
 415
 416   -- Package state
 417   -- NB. do not modify this field, it is calculated by
 418   -- Packages.initPackages and Packages.updatePackages.
 419   pkgDatabase           :: Maybe (UniqFM PackageConfig),
 420   pkgState              :: PackageState,
 421
 422   -- hsc dynamic flags
 423   flags                 :: [DynFlag],
 424
 425   -- | Message output action: use "ErrUtils" instead of this if you can
 426   log_action            :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
 427
 428   haddockOptions :: Maybe String
 429  }
 430
 431 data HscTarget
 432   = HscC
 433   | HscAsm
 434   | HscJava
 435   | HscInterpreted
 436   | HscNothing
 437   deriving (Eq, Show)
 438
 439 -- | Will this target result in an object file on the disk?
 440 isObjectTarget :: HscTarget -> Bool
 441 isObjectTarget HscC     = True
 442 isObjectTarget HscAsm   = True
 443 isObjectTarget _        = False
 444
 445 -- | The 'GhcMode' tells us whether we're doing multi-module
 446 -- compilation (controlled via the "GHC" API) or one-shot
 447 -- (single-module) compilation.  This makes a difference primarily to
 448 -- the "Finder": in one-shot mode we look for interface files for
 449 -- imported modules, but in multi-module mode we look for source files
 450 -- in order to check whether they need to be recompiled.
 451 data GhcMode
 452   = CompManager         -- ^ @\-\-make@, GHCi, etc.
 453   | OneShot             -- ^ @ghc -c Foo.hs@
 454   | MkDepend            -- ^ @ghc -M@, see "Finder" for why we need this
 455   deriving Eq
 456
 457 instance Outputable GhcMode where
 458   ppr CompManager = ptext (sLit "CompManager")
 459   ppr OneShot     = ptext (sLit "OneShot")
 460   ppr MkDepend    = ptext (sLit "MkDepend")
 461
 462 isOneShot :: GhcMode -> Bool
 463 isOneShot OneShot = True
 464 isOneShot _other  = False
 465
 466 -- | What to do in the link step, if there is one.
 467 data GhcLink
 468   = NoLink              -- ^ Don't link at all
 469   | LinkBinary          -- ^ Link object code into a binary
 470   | LinkInMemory        -- ^ Use the in-memory dynamic linker
 471   | LinkDynLib          -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
 472   deriving (Eq, Show)
 473
 474 isNoLink :: GhcLink -> Bool
 475 isNoLink NoLink = True
 476 isNoLink _      = False
 477
 478 data PackageFlag
 479   = ExposePackage  String
 480   | HidePackage    String
 481   | IgnorePackage  String
 482   deriving Eq
 483
 484 defaultHscTarget :: HscTarget
 485 defaultHscTarget = defaultObjectTarget
 486
 487 -- | The 'HscTarget' value corresponding to the default way to create
 488 -- object files on the current platform.
 489 defaultObjectTarget :: HscTarget
 490 defaultObjectTarget
 491   | cGhcWithNativeCodeGen == "YES"      =  HscAsm
 492   | otherwise                           =  HscC
 493
 494 data DynLibLoader
 495   = Deployable
 496   | Wrapped (Maybe String)
 497   | SystemDependent
 498   deriving Eq
 499
 500 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
 501 initDynFlags :: DynFlags -> IO DynFlags
 502 initDynFlags dflags = do
 503  -- someday these will be dynamic flags
 504  ways <- readIORef v_Ways
 505  build_tag <- readIORef v_Build_tag
 506  rts_build_tag <- readIORef v_RTS_Build_tag
 507  return dflags{
 508         wayNames        = ways,
 509         buildTag        = build_tag,
 510         rtsBuildTag     = rts_build_tag
 511         }
 512
 513 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
 514 -- and must be fully initialized by 'GHC.newSession' first.
 515 defaultDynFlags :: DynFlags
 516 defaultDynFlags =
 517      DynFlags {
 518         ghcMode                 = CompManager,
 519         ghcLink                 = LinkBinary,
 520         coreToDo                = Nothing,
 521         stgToDo                 = Nothing,
 522         hscTarget               = defaultHscTarget,
 523         hscOutName              = "",
 524         extCoreName             = "",
 525         verbosity               = 0,
 526         optLevel                = 0,
 527         simplPhases             = 2,
 528         maxSimplIterations      = 4,
 529         shouldDumpSimplPhase    = const False,
 530         ruleCheck               = Nothing,
 531         specConstrThreshold     = Just 200,
 532         specConstrCount         = Just 3,
 533         liberateCaseThreshold   = Just 200,
 534         stolen_x86_regs         = 4,
 535         cmdlineHcIncludes       = [],
 536         importPaths             = ["."],
 537         mainModIs               = mAIN,
 538         mainFunIs               = Nothing,
 539         ctxtStkDepth            = mAX_CONTEXT_REDUCTION_DEPTH,
 540
 541         dphBackend              = DPHPar,
 542
 543         thisPackage             = mainPackageId,
 544
 545         objectDir               = Nothing,
 546         hiDir                   = Nothing,
 547         stubDir                 = Nothing,
 548
 549         objectSuf               = phaseInputExt StopLn,
 550         hcSuf                   = phaseInputExt HCc,
 551         hiSuf                   = "hi",
 552
 553         outputFile              = Nothing,
 554         outputHi                = Nothing,
 555         dynLibLoader            = Deployable,
 556         dumpPrefix              = Nothing,
 557         dumpPrefixForce         = Nothing,
 558         includePaths            = [],
 559         libraryPaths            = [],
 560         frameworkPaths          = [],
 561         cmdlineFrameworks       = [],
 562         tmpDir                  = cDEFAULT_TMPDIR,
 563
 564         hpcDir                  = ".hpc",
 565
 566         opt_L                   = [],
 567         opt_P                   = (if opt_PIC
 568                                    then ["-D__PIC__"]
 569                                    else []),
 570         opt_F                   = [],
 571         opt_c                   = [],
 572         opt_a                   = [],
 573         opt_m                   = [],
 574         opt_l                   = [],
 575         opt_windres             = [],
 576
 577         extraPkgConfs           = [],
 578         packageFlags            = [],
 579         pkgDatabase             = Nothing,
 580         pkgState                = panic "no package state yet: call GHC.setSessionDynFlags",
 581         wayNames                = panic "defaultDynFlags: No wayNames",
 582         buildTag                = panic "defaultDynFlags: No buildTag",
 583         rtsBuildTag             = panic "defaultDynFlags: No rtsBuildTag",
 584         -- initSysTools fills all these in
 585         ghcUsagePath            = panic "defaultDynFlags: No ghciUsagePath",
 586         ghciUsagePath           = panic "defaultDynFlags: No ghciUsagePath",
 587         topDir                  = panic "defaultDynFlags: No topDir",
 588         systemPackageConfig     = panic  "no systemPackageConfig: call GHC.setSessionDynFlags",
 589         pgm_L                   = panic "defaultDynFlags: No pgm_L",
 590         pgm_P                   = panic "defaultDynFlags: No pgm_P",
 591         pgm_F                   = panic "defaultDynFlags: No pgm_F",
 592         pgm_c                   = panic "defaultDynFlags: No pgm_c",
 593         pgm_m                   = panic "defaultDynFlags: No pgm_m",
 594         pgm_s                   = panic "defaultDynFlags: No pgm_s",
 595         pgm_a                   = panic "defaultDynFlags: No pgm_a",
 596         pgm_l                   = panic "defaultDynFlags: No pgm_l",
 597         pgm_dll                 = panic "defaultDynFlags: No pgm_dll",
 598         pgm_T                   = panic "defaultDynFlags: No pgm_T",
 599         pgm_sysman              = panic "defaultDynFlags: No pgm_sysman",
 600         pgm_windres             = panic "defaultDynFlags: No pgm_windres",
 601         -- end of initSysTools values
 602         -- ghc -M values
 603         depMakefile       = "Makefile",
 604         depIncludePkgDeps = False,
 605         depExcludeMods    = [],
 606         depSuffixes       = [],
 607         depWarnings       = True,
 608         -- end of ghc -M values
 609         haddockOptions = Nothing,
 610         flags = [
 611             Opt_AutoLinkPackages,
 612             Opt_ReadUserPackageConf,
 613
 614             Opt_MonoPatBinds,   -- Experimentally, I'm making this non-standard
 615                                 -- behaviour the default, to see if anyone notices
 616                                 -- SLPJ July 06
 617
 618             Opt_ImplicitPrelude,
 619             Opt_MonomorphismRestriction,
 620
 621             Opt_MethodSharing,
 622
 623             Opt_DoAsmMangling,
 624
 625             Opt_GenManifest,
 626             Opt_EmbedManifest,
 627             Opt_PrintBindContents
 628             ]
 629             ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
 630                     -- The default -O0 options
 631             ++ standardWarnings,
 632
 633         log_action = \severity srcSpan style msg ->
 634                         case severity of
 635                           SevInfo  -> printErrs (msg style)
 636                           SevFatal -> printErrs (msg style)
 637                           _        -> do
 638                                 hPutChar stderr '\n'
 639                                 printErrs ((mkLocMessage srcSpan msg) style)
 640                      -- careful (#2302): printErrs prints in UTF-8, whereas
 641                      -- converting to string first and using hPutStr would
 642                      -- just emit the low 8 bits of each unicode char.
 643       }
 644
 645 {-
 646     #verbosity_levels#
 647     Verbosity levels:
 648
 649     0   |   print errors & warnings only
 650     1   |   minimal verbosity: print "compiling M ... done." for each module.
 651     2   |   equivalent to -dshow-passes
 652     3   |   equivalent to existing "ghc -v"
 653     4   |   "ghc -v -ddump-most"
 654     5   |   "ghc -v -ddump-all"
 655 -}
 656
 657 -- | Test whether a 'DynFlag' is set
 658 dopt :: DynFlag -> DynFlags -> Bool
 659 dopt f dflags  = f `elem` (flags dflags)
 660
 661 -- | Set a 'DynFlag'
 662 dopt_set :: DynFlags -> DynFlag -> DynFlags
 663 dopt_set dfs f = dfs{ flags = f : flags dfs }
 664
 665 -- | Unset a 'DynFlag'
 666 dopt_unset :: DynFlags -> DynFlag -> DynFlags
 667 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
 668
 669 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
 670 getOpts :: DynFlags             -- ^ 'DynFlags' to retrieve the options from
 671         -> (DynFlags -> [a])    -- ^ Relevant record accessor: one of the @opt_*@ accessors
 672         -> [a]                  -- ^ Correctly ordered extracted options
 673 getOpts dflags opts = reverse (opts dflags)
 674         -- We add to the options from the front, so we need to reverse the list
 675
 676 -- | Gets the verbosity flag for the current verbosity level. This is fed to
 677 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
 678 getVerbFlag :: DynFlags -> String
 679 getVerbFlag dflags
 680   | verbosity dflags >= 3  = "-v"
 681   | otherwise =  ""
 682
 683 setObjectDir, setHiDir, setStubDir, setOutputDir,
 684          setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
 685          setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
 686          addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres,
 687          addCmdlineFramework, addHaddockOpts
 688    :: String -> DynFlags -> DynFlags
 689 setOutputFile, setOutputHi, setDumpPrefixForce
 690    :: Maybe String -> DynFlags -> DynFlags
 691
 692 setObjectDir  f d = d{ objectDir  = Just f}
 693 setHiDir      f d = d{ hiDir      = Just f}
 694 setStubDir    f d = d{ stubDir    = Just f, includePaths = f : includePaths d }
 695   -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
 696   -- \#included from the .hc file when compiling with -fvia-C.
 697 setOutputDir  f = setObjectDir f . setHiDir f . setStubDir f
 698
 699 setObjectSuf  f d = d{ objectSuf  = f}
 700 setHiSuf      f d = d{ hiSuf      = f}
 701 setHcSuf      f d = d{ hcSuf      = f}
 702
 703 setOutputFile f d = d{ outputFile = f}
 704 setOutputHi   f d = d{ outputHi   = f}
 705
 706 parseDynLibLoaderMode f d =
 707  case splitAt 8 f of
 708    ("deploy", "")       -> d{ dynLibLoader = Deployable }
 709    ("sysdep", "")       -> d{ dynLibLoader = SystemDependent }
 710    ("wrapped", "")      -> d{ dynLibLoader = Wrapped Nothing }
 711    ("wrapped:", "hard") -> d{ dynLibLoader = Wrapped Nothing }
 712    ("wrapped:", flex)   -> d{ dynLibLoader = Wrapped (Just flex) }
 713    (_,_)                -> error "Unknown dynlib loader"
 714
 715 setDumpPrefixForce f d = d { dumpPrefixForce = f}
 716
 717 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
 718 -- Config.hs should really use Option.
 719 setPgmP   f d = let (pgm:args) = words f in d{ pgm_P   = (pgm, map Option args)}
 720
 721 setPgmL   f d = d{ pgm_L   = f}
 722 setPgmF   f d = d{ pgm_F   = f}
 723 setPgmc   f d = d{ pgm_c   = (f,[])}
 724 setPgmm   f d = d{ pgm_m   = (f,[])}
 725 setPgms   f d = d{ pgm_s   = (f,[])}
 726 setPgma   f d = d{ pgm_a   = (f,[])}
 727 setPgml   f d = d{ pgm_l   = (f,[])}
 728 setPgmdll f d = d{ pgm_dll = (f,[])}
 729 setPgmwindres f d = d{ pgm_windres = f}
 730
 731 addOptL   f d = d{ opt_L   = f : opt_L d}
 732 addOptP   f d = d{ opt_P   = f : opt_P d}
 733 addOptF   f d = d{ opt_F   = f : opt_F d}
 734 addOptc   f d = d{ opt_c   = f : opt_c d}
 735 addOptm   f d = d{ opt_m   = f : opt_m d}
 736 addOpta   f d = d{ opt_a   = f : opt_a d}
 737 addOptl   f d = d{ opt_l   = f : opt_l d}
 738 addOptwindres f d = d{ opt_windres = f : opt_windres d}
 739
 740 setDepMakefile :: FilePath -> DynFlags -> DynFlags
 741 setDepMakefile f d = d { depMakefile = deOptDep f }
 742
 743 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
 744 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
 745
 746 addDepExcludeMod :: String -> DynFlags -> DynFlags
 747 addDepExcludeMod m d
 748     = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
 749
 750 addDepSuffix :: FilePath -> DynFlags -> DynFlags
 751 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
 752
 753 setDepWarnings :: Bool -> DynFlags -> DynFlags
 754 setDepWarnings b d = d { depWarnings = b }
 755
 756 -- XXX Legacy code:
 757 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
 758 -- we need to strip the "-optdep" off of the arg
 759 deOptDep :: String -> String
 760 deOptDep x = case maybePrefixMatch "-optdep" x of
 761              Just rest -> rest
 762              Nothing -> x
 763
 764 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
 765
 766 addHaddockOpts f d = d{ haddockOptions = Just f}
 767
 768 -- -----------------------------------------------------------------------------
 769 -- Command-line options
 770
 771 -- | When invoking external tools as part of the compilation pipeline, we
 772 -- pass these a sequence of options on the command-line. Rather than
 773 -- just using a list of Strings, we use a type that allows us to distinguish
 774 -- between filepaths and 'other stuff'. The reason for this is that
 775 -- this type gives us a handle on transforming filenames, and filenames only,
 776 -- to whatever format they're expected to be on a particular platform.
 777 data Option
 778  = FileOption -- an entry that _contains_ filename(s) / filepaths.
 779               String  -- a non-filepath prefix that shouldn't be
 780                       -- transformed (e.g., "/out=")
 781               String  -- the filepath/filename portion
 782  | Option     String
 783
 784 -----------------------------------------------------------------------------
 785 -- Setting the optimisation level
 786
 787 updOptLevel :: Int -> DynFlags -> DynFlags
 788 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
 789 updOptLevel n dfs
 790   = dfs2{ optLevel = final_n }
 791   where
 792    final_n = max 0 (min 2 n)    -- Clamp to 0 <= n <= 2
 793    dfs1 = foldr (flip dopt_unset) dfs  remove_dopts
 794    dfs2 = foldr (flip dopt_set)   dfs1 extra_dopts
 795
 796    extra_dopts  = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
 797    remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
 798
 799 optLevelFlags :: [([Int], DynFlag)]
 800 optLevelFlags
 801   = [ ([0],     Opt_IgnoreInterfacePragmas)
 802     , ([0],     Opt_OmitInterfacePragmas)
 803
 804     , ([1,2],   Opt_IgnoreAsserts)
 805     , ([1,2],   Opt_EnableRewriteRules)  -- Off for -O0; see Note [Scoping for Builtin rules]
 806                                          --              in PrelRules
 807     , ([1,2],   Opt_DoEtaReduction)
 808     , ([1,2],   Opt_CaseMerge)
 809     , ([1,2],   Opt_Strictness)
 810     , ([1,2],   Opt_CSE)
 811     , ([1,2],   Opt_FullLaziness)
 812
 813     , ([2],     Opt_LiberateCase)
 814     , ([2],     Opt_SpecConstr)
 815
 816 --     , ([2],     Opt_StaticArgumentTransformation)
 817 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
 818 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
 819 -- several improvements to the heuristics, and I'm concerned that without
 820 -- those changes SAT will interfere with some attempts to write "high
 821 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
 822 -- this year. In particular, the version in HEAD lacks the tail call
 823 -- criterion, so many things that look like reasonable loops will be
 824 -- turned into functions with extra (unneccesary) thunk creation.
 825
 826     , ([0,1,2], Opt_DoLambdaEtaExpansion)
 827                 -- This one is important for a tiresome reason:
 828                 -- we want to make sure that the bindings for data
 829                 -- constructors are eta-expanded.  This is probably
 830                 -- a good thing anyway, but it seems fragile.
 831     ]
 832
 833 -- -----------------------------------------------------------------------------
 834 -- Standard sets of warning options
 835
 836 standardWarnings :: [DynFlag]
 837 standardWarnings
 838     = [ Opt_WarnWarningsDeprecations,
 839         Opt_WarnDeprecatedFlags,
 840         Opt_WarnUnrecognisedPragmas,
 841         Opt_WarnOverlappingPatterns,
 842         Opt_WarnMissingFields,
 843         Opt_WarnMissingMethods,
 844         Opt_WarnDuplicateExports,
 845         Opt_WarnDodgyForeignImports
 846       ]
 847
 848 minusWOpts :: [DynFlag]
 849 minusWOpts
 850     = standardWarnings ++
 851       [ Opt_WarnUnusedBinds,
 852         Opt_WarnUnusedMatches,
 853         Opt_WarnUnusedImports,
 854         Opt_WarnIncompletePatterns,
 855         Opt_WarnDodgyImports
 856       ]
 857
 858 minusWallOpts :: [DynFlag]
 859 minusWallOpts
 860     = minusWOpts ++
 861       [ Opt_WarnTypeDefaults,
 862         Opt_WarnNameShadowing,
 863         Opt_WarnMissingSigs,
 864         Opt_WarnHiShadows,
 865         Opt_WarnOrphans
 866       ]
 867
 868 -- minuswRemovesOpts should be every warning option
 869 minuswRemovesOpts :: [DynFlag]
 870 minuswRemovesOpts
 871     = minusWallOpts ++
 872       [Opt_WarnImplicitPrelude,
 873        Opt_WarnIncompletePatternsRecUpd,
 874        Opt_WarnSimplePatterns,
 875        Opt_WarnMonomorphism,
 876        Opt_WarnUnrecognisedPragmas,
 877        Opt_WarnTabs
 878       ]
 879
 880 -- -----------------------------------------------------------------------------
 881 -- CoreToDo:  abstraction of core-to-core passes to run.
 882
 883 data CoreToDo           -- These are diff core-to-core passes,
 884                         -- which may be invoked in any order,
 885                         -- as many times as you like.
 886
 887   = CoreDoSimplify      -- The core-to-core simplifier.
 888         SimplifierMode
 889         [SimplifierSwitch]
 890                         -- Each run of the simplifier can take a different
 891                         -- set of simplifier-specific flags.
 892   | CoreDoFloatInwards
 893   | CoreDoFloatOutwards FloatOutSwitches
 894   | CoreLiberateCase
 895   | CoreDoPrintCore
 896   | CoreDoStaticArgs
 897   | CoreDoStrictness
 898   | CoreDoWorkerWrapper
 899   | CoreDoSpecialising
 900   | CoreDoSpecConstr
 901   | CoreDoOldStrictness
 902   | CoreDoGlomBinds
 903   | CoreCSE
 904   | CoreDoRuleCheck Int{-CompilerPhase-} String -- Check for non-application of rules
 905                                                 -- matching this string
 906   | CoreDoVectorisation PackageId
 907   | CoreDoNothing                -- Useful when building up
 908   | CoreDoPasses [CoreToDo]      -- lists of these things
 909
 910 data SimplifierMode             -- See comments in SimplMonad
 911   = SimplGently
 912   | SimplPhase Int [String]
 913
 914 data SimplifierSwitch
 915   = MaxSimplifierIterations Int
 916   | NoCaseOfCase
 917
 918 data FloatOutSwitches
 919   = FloatOutSw  Bool    -- True <=> float lambdas to top level
 920                 Bool    -- True <=> float constants to top level,
 921                         --          even if they do not escape a lambda
 922
 923
 924 -- The core-to-core pass ordering is derived from the DynFlags:
 925 runWhen :: Bool -> CoreToDo -> CoreToDo
 926 runWhen True  do_this = do_this
 927 runWhen False _       = CoreDoNothing
 928
 929 runMaybe :: Maybe a -> (a -> CoreToDo) -> CoreToDo
 930 runMaybe (Just x) f = f x
 931 runMaybe Nothing  _ = CoreDoNothing
 932
 933 getCoreToDo :: DynFlags -> [CoreToDo]
 934 getCoreToDo dflags
 935   | Just todo <- coreToDo dflags = todo -- set explicitly by user
 936   | otherwise = core_todo
 937   where
 938     opt_level     = optLevel dflags
 939     phases        = simplPhases dflags
 940     max_iter      = maxSimplIterations dflags
 941     strictness    = dopt Opt_Strictness dflags
 942     full_laziness = dopt Opt_FullLaziness dflags
 943     cse           = dopt Opt_CSE dflags
 944     spec_constr   = dopt Opt_SpecConstr dflags
 945     liberate_case = dopt Opt_LiberateCase dflags
 946     rule_check    = ruleCheck dflags
 947     static_args   = dopt Opt_StaticArgumentTransformation dflags
 948
 949     maybe_rule_check phase = runMaybe rule_check (CoreDoRuleCheck phase)
 950
 951     simpl_phase phase names iter
 952       = CoreDoPasses
 953           [ CoreDoSimplify (SimplPhase phase names) [
 954               MaxSimplifierIterations iter
 955             ],
 956             maybe_rule_check phase
 957           ]
 958
 959     vectorisation
 960       = runWhen (dopt Opt_Vectorise dflags)
 961         $ CoreDoPasses [ simpl_gently, CoreDoVectorisation (dphPackage dflags) ]
 962
 963
 964                 -- By default, we have 2 phases before phase 0.
 965
 966                 -- Want to run with inline phase 2 after the specialiser to give
 967                 -- maximum chance for fusion to work before we inline build/augment
 968                 -- in phase 1.  This made a difference in 'ansi' where an
 969                 -- overloaded function wasn't inlined till too late.
 970
 971                 -- Need phase 1 so that build/augment get
 972                 -- inlined.  I found that spectral/hartel/genfft lost some useful
 973                 -- strictness in the function sumcode' if augment is not inlined
 974                 -- before strictness analysis runs
 975     simpl_phases = CoreDoPasses [ simpl_phase phase ["main"] max_iter
 976                                   | phase <- [phases, phases-1 .. 1] ]
 977
 978
 979         -- initial simplify: mk specialiser happy: minimum effort please
 980     simpl_gently = CoreDoSimplify SimplGently [
 981                         --      Simplify "gently"
 982                         -- Don't inline anything till full laziness has bitten
 983                         -- In particular, inlining wrappers inhibits floating
 984                         -- e.g. ...(case f x of ...)...
 985                         --  ==> ...(case (case x of I# x# -> fw x#) of ...)...
 986                         --  ==> ...(case x of I# x# -> case fw x# of ...)...
 987                         -- and now the redex (f x) isn't floatable any more
 988                         -- Similarly, don't apply any rules until after full
 989                         -- laziness.  Notably, list fusion can prevent floating.
 990
 991             NoCaseOfCase,       -- Don't do case-of-case transformations.
 992                                 -- This makes full laziness work better
 993             MaxSimplifierIterations max_iter
 994         ]
 995
 996     core_todo =
 997      if opt_level == 0 then
 998        [vectorisation,
 999         simpl_phase 0 ["final"] max_iter]
1000      else {- opt_level >= 1 -} [
1001
1002     -- We want to do the static argument transform before full laziness as it
1003     -- may expose extra opportunities to float things outwards. However, to fix
1004     -- up the output of the transformation we need at do at least one simplify
1005     -- after this before anything else
1006         runWhen static_args (CoreDoPasses [ simpl_gently, CoreDoStaticArgs ]),
1007
1008         -- We run vectorisation here for now, but we might also try to run
1009         -- it later
1010         vectorisation,
1011
1012         -- initial simplify: mk specialiser happy: minimum effort please
1013         simpl_gently,
1014
1015         -- Specialisation is best done before full laziness
1016         -- so that overloaded functions have all their dictionary lambdas manifest
1017         CoreDoSpecialising,
1018
1019         runWhen full_laziness (CoreDoFloatOutwards (FloatOutSw False False)),
1020
1021         CoreDoFloatInwards,
1022
1023         simpl_phases,
1024
1025                 -- Phase 0: allow all Ids to be inlined now
1026                 -- This gets foldr inlined before strictness analysis
1027
1028                 -- At least 3 iterations because otherwise we land up with
1029                 -- huge dead expressions because of an infelicity in the
1030                 -- simpifier.
1031                 --      let k = BIG in foldr k z xs
1032                 -- ==>  let k = BIG in letrec go = \xs -> ...(k x).... in go xs
1033                 -- ==>  let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
1034                 -- Don't stop now!
1035         simpl_phase 0 ["main"] (max max_iter 3),
1036
1037
1038 #ifdef OLD_STRICTNESS
1039         CoreDoOldStrictness,
1040 #endif
1041         runWhen strictness (CoreDoPasses [
1042                 CoreDoStrictness,
1043                 CoreDoWorkerWrapper,
1044                 CoreDoGlomBinds,
1045                 simpl_phase 0 ["post-worker-wrapper"] max_iter
1046                 ]),
1047
1048         runWhen full_laziness
1049           (CoreDoFloatOutwards (FloatOutSw False    -- Not lambdas
1050                                            True)),  -- Float constants
1051                 -- nofib/spectral/hartel/wang doubles in speed if you
1052                 -- do full laziness late in the day.  It only happens
1053                 -- after fusion and other stuff, so the early pass doesn't
1054                 -- catch it.  For the record, the redex is
1055                 --        f_el22 (f_el21 r_midblock)
1056
1057
1058         runWhen cse CoreCSE,
1059                 -- We want CSE to follow the final full-laziness pass, because it may
1060                 -- succeed in commoning up things floated out by full laziness.
1061                 -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
1062
1063         CoreDoFloatInwards,
1064
1065         maybe_rule_check 0,
1066
1067                 -- Case-liberation for -O2.  This should be after
1068                 -- strictness analysis and the simplification which follows it.
1069         runWhen liberate_case (CoreDoPasses [
1070             CoreLiberateCase,
1071             simpl_phase 0 ["post-liberate-case"] max_iter
1072             ]),         -- Run the simplifier after LiberateCase to vastly
1073                         -- reduce the possiblility of shadowing
1074                         -- Reason: see Note [Shadowing] in SpecConstr.lhs
1075
1076         runWhen spec_constr CoreDoSpecConstr,
1077
1078         maybe_rule_check 0,
1079
1080         -- Final clean-up simplification:
1081         simpl_phase 0 ["final"] max_iter
1082      ]
1083
1084 -- -----------------------------------------------------------------------------
1085 -- StgToDo:  abstraction of stg-to-stg passes to run.
1086
1087 data StgToDo
1088   = StgDoMassageForProfiling  -- should be (next to) last
1089   -- There's also setStgVarInfo, but its absolute "lastness"
1090   -- is so critical that it is hardwired in (no flag).
1091   | D_stg_stats
1092
1093 getStgToDo :: DynFlags -> [StgToDo]
1094 getStgToDo dflags
1095   | Just todo <- stgToDo dflags = todo -- set explicitly by user
1096   | otherwise = todo2
1097   where
1098         stg_stats = dopt Opt_StgStats dflags
1099
1100         todo1 = if stg_stats then [D_stg_stats] else []
1101
1102         todo2 | WayProf `elem` wayNames dflags
1103               = StgDoMassageForProfiling : todo1
1104               | otherwise
1105               = todo1
1106
1107 -- -----------------------------------------------------------------------------
1108 -- DynFlags parser
1109
1110 allFlags :: [String]
1111 allFlags = map ('-':) $
1112            [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1113            map ("fno-"++) flags ++
1114            map ("f"++) flags ++
1115            map ("X"++) supportedLanguages ++
1116            map ("XNo"++) supportedLanguages
1117     where ok (PrefixPred _ _) = False
1118           ok _ = True
1119           flags = [ name | (name, _, _) <- fFlags ]
1120
1121 dynamic_flags :: [Flag DynP]
1122 dynamic_flags = [
1123     Flag "n"              (NoArg  (setDynFlag Opt_DryRun)) Supported
1124   , Flag "cpp"            (NoArg  (setDynFlag Opt_Cpp)) Supported
1125   , Flag "F"              (NoArg  (setDynFlag Opt_Pp)) Supported
1126   , Flag "#include"       (HasArg (addCmdlineHCInclude)) Supported
1127   , Flag "v"              (OptIntSuffix setVerbosity) Supported
1128
1129         ------- Specific phases  --------------------------------------------
1130   , Flag "pgmL"           (HasArg (upd . setPgmL)) Supported
1131   , Flag "pgmP"           (HasArg (upd . setPgmP)) Supported
1132   , Flag "pgmF"           (HasArg (upd . setPgmF)) Supported
1133   , Flag "pgmc"           (HasArg (upd . setPgmc)) Supported
1134   , Flag "pgmm"           (HasArg (upd . setPgmm)) Supported
1135   , Flag "pgms"           (HasArg (upd . setPgms)) Supported
1136   , Flag "pgma"           (HasArg (upd . setPgma)) Supported
1137   , Flag "pgml"           (HasArg (upd . setPgml)) Supported
1138   , Flag "pgmdll"         (HasArg (upd . setPgmdll)) Supported
1139   , Flag "pgmwindres"     (HasArg (upd . setPgmwindres)) Supported
1140
1141   , Flag "optL"           (HasArg (upd . addOptL)) Supported
1142   , Flag "optP"           (HasArg (upd . addOptP)) Supported
1143   , Flag "optF"           (HasArg (upd . addOptF)) Supported
1144   , Flag "optc"           (HasArg (upd . addOptc)) Supported
1145   , Flag "optm"           (HasArg (upd . addOptm)) Supported
1146   , Flag "opta"           (HasArg (upd . addOpta)) Supported
1147   , Flag "optl"           (HasArg (upd . addOptl)) Supported
1148   , Flag "optwindres"     (HasArg (upd . addOptwindres)) Supported
1149
1150   , Flag "split-objs"
1151          (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
1152          Supported
1153
1154         -------- ghc -M -----------------------------------------------------
1155   , Flag "dep-suffix"               (HasArg (upd . addDepSuffix)) Supported
1156   , Flag "optdep-s"                 (HasArg (upd . addDepSuffix))
1157          (Deprecated "Use -dep-suffix instead")
1158   , Flag "dep-makefile"             (HasArg (upd . setDepMakefile)) Supported
1159   , Flag "optdep-f"                 (HasArg (upd . setDepMakefile))
1160          (Deprecated "Use -dep-makefile instead")
1161   , Flag "optdep-w"                 (NoArg  (upd (setDepWarnings False)))
1162          (Deprecated "-optdep-w doesn't do anything")
1163   , Flag "include-pkg-deps" (NoArg  (upd (setDepIncludePkgDeps True))) Supported
1164   , Flag "optdep--include-prelude"  (NoArg  (upd (setDepIncludePkgDeps True)))
1165          (Deprecated "Use -include-pkg-deps instead")
1166   , Flag "optdep--include-pkg-deps" (NoArg  (upd (setDepIncludePkgDeps True)))
1167          (Deprecated "Use -include-pkg-deps instead")
1168   , Flag "exclude-module"           (HasArg (upd . addDepExcludeMod)) Supported
1169   , Flag "optdep--exclude-module"   (HasArg (upd . addDepExcludeMod))
1170          (Deprecated "Use -exclude-module instead")
1171   , Flag "optdep-x"                 (HasArg (upd . addDepExcludeMod))
1172          (Deprecated "Use -exclude-module instead")
1173
1174         -------- Linking ----------------------------------------------------
1175   , Flag "c"              (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1176          Supported
1177   , Flag "no-link"        (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1178          (Deprecated "Use -c instead")
1179   , Flag "shared"         (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
1180          Supported
1181   , Flag "dynload"        (HasArg (upd . parseDynLibLoaderMode))
1182          Supported
1183
1184         ------- Libraries ---------------------------------------------------
1185   , Flag "L"              (Prefix addLibraryPath ) Supported
1186   , Flag "l"              (AnySuffix (\s -> do upd (addOptl s))) Supported
1187
1188         ------- Frameworks --------------------------------------------------
1189         -- -framework-path should really be -F ...
1190   , Flag "framework-path" (HasArg addFrameworkPath ) Supported
1191   , Flag "framework"      (HasArg (upd . addCmdlineFramework)) Supported
1192
1193         ------- Output Redirection ------------------------------------------
1194   , Flag "odir"           (HasArg (upd . setObjectDir)) Supported
1195   , Flag "o"              (SepArg (upd . setOutputFile . Just)) Supported
1196   , Flag "ohi"            (HasArg (upd . setOutputHi   . Just )) Supported
1197   , Flag "osuf"           (HasArg (upd . setObjectSuf)) Supported
1198   , Flag "hcsuf"          (HasArg (upd . setHcSuf)) Supported
1199   , Flag "hisuf"          (HasArg (upd . setHiSuf)) Supported
1200   , Flag "hidir"          (HasArg (upd . setHiDir)) Supported
1201   , Flag "tmpdir"         (HasArg (upd . setTmpDir)) Supported
1202   , Flag "stubdir"        (HasArg (upd . setStubDir)) Supported
1203   , Flag "outputdir"      (HasArg (upd . setOutputDir)) Supported
1204   , Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
1205          Supported
1206
1207         ------- Keeping temporary files -------------------------------------
1208      -- These can be singular (think ghc -c) or plural (think ghc --make)
1209   , Flag "keep-hc-file"     (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1210   , Flag "keep-hc-files"    (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1211   , Flag "keep-s-file"      (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1212   , Flag "keep-s-files"     (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1213   , Flag "keep-raw-s-file"  (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1214   , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1215      -- This only makes sense as plural
1216   , Flag "keep-tmp-files"   (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
1217
1218         ------- Miscellaneous ----------------------------------------------
1219   , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
1220   , Flag "no-hs-main"     (NoArg (setDynFlag Opt_NoHsMain)) Supported
1221   , Flag "main-is"        (SepArg setMainIs ) Supported
1222   , Flag "haddock"        (NoArg (setDynFlag Opt_Haddock)) Supported
1223   , Flag "haddock-opts"   (HasArg (upd . addHaddockOpts)) Supported
1224   , Flag "hpcdir"         (SepArg setOptHpcDir) Supported
1225
1226         ------- recompilation checker --------------------------------------
1227   , Flag "recomp"         (NoArg (unSetDynFlag Opt_ForceRecomp))
1228          (Deprecated "Use -fno-force-recomp instead")
1229   , Flag "no-recomp"      (NoArg (setDynFlag   Opt_ForceRecomp))
1230          (Deprecated "Use -fforce-recomp instead")
1231
1232         ------ HsCpp opts ---------------------------------------------------
1233   , Flag "D"              (AnySuffix (upd . addOptP)) Supported
1234   , Flag "U"              (AnySuffix (upd . addOptP)) Supported
1235
1236         ------- Include/Import Paths ----------------------------------------
1237   , Flag "I"              (Prefix    addIncludePath) Supported
1238   , Flag "i"              (OptPrefix addImportPath ) Supported
1239
1240         ------ Debugging ----------------------------------------------------
1241   , Flag "dstg-stats"     (NoArg (setDynFlag Opt_StgStats)) Supported
1242
1243   , Flag "ddump-cmm"               (setDumpFlag Opt_D_dump_cmm)
1244          Supported
1245   , Flag "ddump-cmmz"              (setDumpFlag Opt_D_dump_cmmz)
1246          Supported
1247   , Flag "ddump-cmmz-pretty"       (setDumpFlag Opt_D_dump_cmmz_pretty)
1248          Supported
1249   , Flag "ddump-cps-cmm"           (setDumpFlag Opt_D_dump_cps_cmm)
1250          Supported
1251   , Flag "ddump-cvt-cmm"           (setDumpFlag Opt_D_dump_cvt_cmm)
1252          Supported
1253   , Flag "ddump-asm"               (setDumpFlag Opt_D_dump_asm)
1254          Supported
1255   , Flag "ddump-asm-native"        (setDumpFlag Opt_D_dump_asm_native)
1256          Supported
1257   , Flag "ddump-asm-liveness"      (setDumpFlag Opt_D_dump_asm_liveness)
1258          Supported
1259   , Flag "ddump-asm-coalesce"      (setDumpFlag Opt_D_dump_asm_coalesce)
1260          Supported
1261   , Flag "ddump-asm-regalloc"      (setDumpFlag Opt_D_dump_asm_regalloc)
1262          Supported
1263   , Flag "ddump-asm-conflicts"     (setDumpFlag Opt_D_dump_asm_conflicts)
1264          Supported
1265   , Flag "ddump-asm-regalloc-stages"
1266                                  (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1267          Supported
1268   , Flag "ddump-asm-stats"         (setDumpFlag Opt_D_dump_asm_stats)
1269          Supported
1270   , Flag "ddump-cpranal"           (setDumpFlag Opt_D_dump_cpranal)
1271          Supported
1272   , Flag "ddump-deriv"             (setDumpFlag Opt_D_dump_deriv)
1273          Supported
1274   , Flag "ddump-ds"                (setDumpFlag Opt_D_dump_ds)
1275          Supported
1276   , Flag "ddump-flatC"             (setDumpFlag Opt_D_dump_flatC)
1277          Supported
1278   , Flag "ddump-foreign"           (setDumpFlag Opt_D_dump_foreign)
1279          Supported
1280   , Flag "ddump-inlinings"         (setDumpFlag Opt_D_dump_inlinings)
1281          Supported
1282   , Flag "ddump-rule-firings"      (setDumpFlag Opt_D_dump_rule_firings)
1283          Supported
1284   , Flag "ddump-occur-anal"        (setDumpFlag Opt_D_dump_occur_anal)
1285          Supported
1286   , Flag "ddump-parsed"            (setDumpFlag Opt_D_dump_parsed)
1287          Supported
1288   , Flag "ddump-rn"                (setDumpFlag Opt_D_dump_rn)
1289          Supported
1290   , Flag "ddump-simpl"             (setDumpFlag Opt_D_dump_simpl)
1291          Supported
1292   , Flag "ddump-simpl-iterations"  (setDumpFlag Opt_D_dump_simpl_iterations)
1293          Supported
1294   , Flag "ddump-simpl-phases"      (OptPrefix setDumpSimplPhases)
1295          Supported
1296   , Flag "ddump-spec"              (setDumpFlag Opt_D_dump_spec)
1297          Supported
1298   , Flag "ddump-prep"              (setDumpFlag Opt_D_dump_prep)
1299          Supported
1300   , Flag "ddump-stg"               (setDumpFlag Opt_D_dump_stg)
1301          Supported
1302   , Flag "ddump-stranal"           (setDumpFlag Opt_D_dump_stranal)
1303          Supported
1304   , Flag "ddump-tc"                (setDumpFlag Opt_D_dump_tc)
1305          Supported
1306   , Flag "ddump-types"             (setDumpFlag Opt_D_dump_types)
1307          Supported
1308   , Flag "ddump-rules"             (setDumpFlag Opt_D_dump_rules)
1309          Supported
1310   , Flag "ddump-cse"               (setDumpFlag Opt_D_dump_cse)
1311          Supported
1312   , Flag "ddump-worker-wrapper"    (setDumpFlag Opt_D_dump_worker_wrapper)
1313          Supported
1314   , Flag "ddump-rn-trace"          (setDumpFlag Opt_D_dump_rn_trace)
1315          Supported
1316   , Flag "ddump-if-trace"          (setDumpFlag Opt_D_dump_if_trace)
1317          Supported
1318   , Flag "ddump-tc-trace"          (setDumpFlag Opt_D_dump_tc_trace)
1319          Supported
1320   , Flag "ddump-splices"           (setDumpFlag Opt_D_dump_splices)
1321          Supported
1322   , Flag "ddump-rn-stats"          (setDumpFlag Opt_D_dump_rn_stats)
1323          Supported
1324   , Flag "ddump-opt-cmm"           (setDumpFlag Opt_D_dump_opt_cmm)
1325          Supported
1326   , Flag "ddump-simpl-stats"       (setDumpFlag Opt_D_dump_simpl_stats)
1327          Supported
1328   , Flag "ddump-bcos"              (setDumpFlag Opt_D_dump_BCOs)
1329          Supported
1330   , Flag "dsource-stats"           (setDumpFlag Opt_D_source_stats)
1331          Supported
1332   , Flag "dverbose-core2core"      (NoArg setVerboseCore2Core)
1333          Supported
1334   , Flag "dverbose-stg2stg"        (setDumpFlag Opt_D_verbose_stg2stg)
1335          Supported
1336   , Flag "ddump-hi"                (setDumpFlag Opt_D_dump_hi)
1337          Supported
1338   , Flag "ddump-minimal-imports"   (setDumpFlag Opt_D_dump_minimal_imports)
1339          Supported
1340   , Flag "ddump-vect"              (setDumpFlag Opt_D_dump_vect)
1341          Supported
1342   , Flag "ddump-hpc"               (setDumpFlag Opt_D_dump_hpc)
1343          Supported
1344   , Flag "ddump-mod-cycles"        (setDumpFlag Opt_D_dump_mod_cycles)
1345          Supported
1346   , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1347          Supported
1348   , Flag "ddump-to-file"           (setDumpFlag Opt_DumpToFile)
1349          Supported
1350   , Flag "ddump-hi-diffs"          (setDumpFlag Opt_D_dump_hi_diffs)
1351          Supported
1352   , Flag "ddump-rtti"              (setDumpFlag Opt_D_dump_rtti)
1353          Supported
1354
1355   , Flag "dcore-lint"              (NoArg (setDynFlag Opt_DoCoreLinting))
1356          Supported
1357   , Flag "dstg-lint"               (NoArg (setDynFlag Opt_DoStgLinting))
1358          Supported
1359   , Flag "dcmm-lint"               (NoArg (setDynFlag Opt_DoCmmLinting))
1360          Supported
1361   , Flag "dasm-lint"               (NoArg (setDynFlag Opt_DoAsmLinting))
1362          Supported
1363   , Flag "dshow-passes"
1364          (NoArg (do forceRecompile
1365                     setVerbosity (Just 2)))
1366          Supported
1367   , Flag "dfaststring-stats"       (NoArg (setDynFlag Opt_D_faststring_stats))
1368          Supported
1369
1370         ------ Machine dependant (-m<blah>) stuff ---------------------------
1371
1372   , Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
1373          Supported
1374   , Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
1375          Supported
1376   , Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
1377          Supported
1378
1379      ------ Warning opts -------------------------------------------------
1380   , Flag "W"      (NoArg (mapM_ setDynFlag   minusWOpts))
1381          Supported
1382   , Flag "Werror" (NoArg (setDynFlag         Opt_WarnIsError))
1383          Supported
1384   , Flag "Wwarn"  (NoArg (unSetDynFlag       Opt_WarnIsError))
1385          Supported
1386   , Flag "Wall"   (NoArg (mapM_ setDynFlag   minusWallOpts))
1387          Supported
1388   , Flag "Wnot"   (NoArg (mapM_ unSetDynFlag minusWallOpts))
1389          (Deprecated "Use -w instead")
1390   , Flag "w"      (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1391          Supported
1392
1393         ------ Optimisation flags ------------------------------------------
1394   , Flag "O"      (NoArg (upd (setOptLevel 1))) Supported
1395   , Flag "Onot"   (NoArg (upd (setOptLevel 0)))
1396          (Deprecated "Use -O0 instead")
1397   , Flag "Odph"   (NoArg (upd setDPHOpt)) Supported
1398   , Flag "O"      (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1399          Supported
1400                 -- If the number is missing, use 1
1401
1402   , Flag "fsimplifier-phases"
1403          (IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
1404          Supported
1405   , Flag "fmax-simplifier-iterations"
1406          (IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
1407          Supported
1408
1409   , Flag "fspec-constr-threshold"
1410          (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
1411          Supported
1412   , Flag "fno-spec-constr-threshold"
1413          (NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
1414          Supported
1415   , Flag "fspec-constr-count"
1416          (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
1417          Supported
1418   , Flag "fno-spec-constr-count"
1419          (NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
1420          Supported
1421   , Flag "fliberate-case-threshold"
1422          (IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
1423          Supported
1424   , Flag "fno-liberate-case-threshold"
1425          (NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
1426          Supported
1427
1428   , Flag "frule-check"
1429          (SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
1430          Supported
1431   , Flag "fcontext-stack"
1432          (IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
1433          Supported
1434
1435         ------ DPH flags ----------------------------------------------------
1436
1437   , Flag "fdph-seq"
1438          (NoArg (setDPHBackend DPHSeq))
1439          Supported
1440   , Flag "fdph-par"
1441          (NoArg (setDPHBackend DPHPar))
1442          Supported
1443   , Flag "fdph-this"
1444          (NoArg (setDPHBackend DPHThis))
1445          Supported
1446
1447         ------ Compiler flags -----------------------------------------------
1448
1449   , Flag "fasm"             (NoArg (setObjTarget HscAsm)) Supported
1450   , Flag "fvia-c"           (NoArg (setObjTarget HscC)) Supported
1451   , Flag "fvia-C"           (NoArg (setObjTarget HscC)) Supported
1452
1453   , Flag "fno-code"         (NoArg (setTarget HscNothing)) Supported
1454   , Flag "fbyte-code"       (NoArg (setTarget HscInterpreted)) Supported
1455   , Flag "fobject-code"     (NoArg (setTarget defaultHscTarget)) Supported
1456
1457   , Flag "fglasgow-exts"    (NoArg (mapM_ setDynFlag   glasgowExtsFlags))
1458          Supported
1459   , Flag "fno-glasgow-exts" (NoArg (mapM_ unSetDynFlag glasgowExtsFlags))
1460          Supported
1461  ]
1462  ++ map (mkFlag True  "f"    setDynFlag  ) fFlags
1463  ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
1464  ++ map (mkFlag True  "X"    setDynFlag  ) xFlags
1465  ++ map (mkFlag False "XNo"  unSetDynFlag) xFlags
1466
1467 package_flags :: [Flag DynP]
1468 package_flags = [
1469         ------- Packages ----------------------------------------------------
1470     Flag "package-conf"   (HasArg extraPkgConf_) Supported
1471   , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1472          Supported
1473   , Flag "package-name"   (HasArg (upd . setPackageName)) Supported
1474   , Flag "package"        (HasArg exposePackage) Supported
1475   , Flag "hide-package"   (HasArg hidePackage) Supported
1476   , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1477          Supported
1478   , Flag "ignore-package" (HasArg ignorePackage)
1479          Supported
1480   , Flag "syslib"         (HasArg exposePackage)
1481          (Deprecated "Use -package instead")
1482   ]
1483
1484 mkFlag :: Bool                  -- ^ True <=> it should be turned on
1485        -> String                -- ^ The flag prefix
1486        -> (DynFlag -> DynP ())
1487        -> (String, DynFlag, Bool -> Deprecated)
1488        -> Flag DynP
1489 mkFlag turnOn flagPrefix f (name, dynflag, deprecated)
1490     = Flag (flagPrefix ++ name) (NoArg (f dynflag)) (deprecated turnOn)
1491
1492 deprecatedForLanguage :: String -> Bool -> Deprecated
1493 deprecatedForLanguage lang turn_on
1494     = Deprecated ("use -X"  ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ "#-} instead")
1495     where
1496       flag | turn_on    = lang
1497            | otherwise = "No"++lang
1498
1499 useInstead :: String -> Bool -> Deprecated
1500 useInstead flag turn_on
1501   = Deprecated ("Use -f" ++ no ++ flag ++ " instead")
1502   where
1503     no = if turn_on then "" else "no-"
1504
1505 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1506 fFlags :: [(String, DynFlag, Bool -> Deprecated)]
1507 fFlags = [
1508   ( "warn-dodgy-foreign-imports",       Opt_WarnDodgyForeignImports, const Supported ),
1509   ( "warn-dodgy-imports",               Opt_WarnDodgyImports, const Supported ),
1510   ( "warn-duplicate-exports",           Opt_WarnDuplicateExports, const Supported ),
1511   ( "warn-hi-shadowing",                Opt_WarnHiShadows, const Supported ),
1512   ( "warn-implicit-prelude",            Opt_WarnImplicitPrelude, const Supported ),
1513   ( "warn-incomplete-patterns",         Opt_WarnIncompletePatterns, const Supported ),
1514   ( "warn-incomplete-record-updates",   Opt_WarnIncompletePatternsRecUpd, const Supported ),
1515   ( "warn-missing-fields",              Opt_WarnMissingFields, const Supported ),
1516   ( "warn-missing-methods",             Opt_WarnMissingMethods, const Supported ),
1517   ( "warn-missing-signatures",          Opt_WarnMissingSigs, const Supported ),
1518   ( "warn-name-shadowing",              Opt_WarnNameShadowing, const Supported ),
1519   ( "warn-overlapping-patterns",        Opt_WarnOverlappingPatterns, const Supported ),
1520   ( "warn-simple-patterns",             Opt_WarnSimplePatterns, const Supported ),
1521   ( "warn-type-defaults",               Opt_WarnTypeDefaults, const Supported ),
1522   ( "warn-monomorphism-restriction",    Opt_WarnMonomorphism, const Supported ),
1523   ( "warn-unused-binds",                Opt_WarnUnusedBinds, const Supported ),
1524   ( "warn-unused-imports",              Opt_WarnUnusedImports, const Supported ),
1525   ( "warn-unused-matches",              Opt_WarnUnusedMatches, const Supported ),
1526   ( "warn-warnings-deprecations",       Opt_WarnWarningsDeprecations, const Supported ),
1527   ( "warn-deprecations",                Opt_WarnWarningsDeprecations, const Supported ),
1528   ( "warn-deprecated-flags",            Opt_WarnDeprecatedFlags, const Supported ),
1529   ( "warn-orphans",                     Opt_WarnOrphans, const Supported ),
1530   ( "warn-tabs",                        Opt_WarnTabs, const Supported ),
1531   ( "warn-unrecognised-pragmas",        Opt_WarnUnrecognisedPragmas, const Supported ),
1532   ( "print-explicit-foralls",           Opt_PrintExplicitForalls, const Supported ),
1533   ( "strictness",                       Opt_Strictness, const Supported ),
1534   ( "static-argument-transformation",   Opt_StaticArgumentTransformation, const Supported ),
1535   ( "full-laziness",                    Opt_FullLaziness, const Supported ),
1536   ( "liberate-case",                    Opt_LiberateCase, const Supported ),
1537   ( "spec-constr",                      Opt_SpecConstr, const Supported ),
1538   ( "cse",                              Opt_CSE, const Supported ),
1539   ( "ignore-interface-pragmas",         Opt_IgnoreInterfacePragmas, const Supported ),
1540   ( "omit-interface-pragmas",           Opt_OmitInterfacePragmas, const Supported ),
1541   ( "do-lambda-eta-expansion",          Opt_DoLambdaEtaExpansion, const Supported ),
1542   ( "ignore-asserts",                   Opt_IgnoreAsserts, const Supported ),
1543   ( "do-eta-reduction",                 Opt_DoEtaReduction, const Supported ),
1544   ( "case-merge",                       Opt_CaseMerge, const Supported ),
1545   ( "unbox-strict-fields",              Opt_UnboxStrictFields, const Supported ),
1546   ( "method-sharing",                   Opt_MethodSharing, const Supported ),
1547   ( "dicts-cheap",                      Opt_DictsCheap, const Supported ),
1548   ( "excess-precision",                 Opt_ExcessPrecision, const Supported ),
1549   ( "asm-mangling",                     Opt_DoAsmMangling, const Supported ),
1550   ( "print-bind-result",                Opt_PrintBindResult, const Supported ),
1551   ( "force-recomp",                     Opt_ForceRecomp, const Supported ),
1552   ( "hpc-no-auto",                      Opt_Hpc_No_Auto, const Supported ),
1553   ( "rewrite-rules",                    Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1554   ( "enable-rewrite-rules",             Opt_EnableRewriteRules, const Supported ),
1555   ( "break-on-exception",               Opt_BreakOnException, const Supported ),
1556   ( "break-on-error",                   Opt_BreakOnError, const Supported ),
1557   ( "print-evld-with-show",             Opt_PrintEvldWithShow, const Supported ),
1558   ( "print-bind-contents",              Opt_PrintBindContents, const Supported ),
1559   ( "run-cps",                          Opt_RunCPSZ, const Supported ),
1560   ( "convert-to-zipper-and-back",       Opt_ConvertToZipCfgAndBack, const Supported ),
1561   ( "vectorise",                        Opt_Vectorise, const Supported ),
1562   ( "regs-graph",                       Opt_RegsGraph, const Supported ),
1563   ( "regs-iterative",                   Opt_RegsIterative, const Supported ),
1564   ( "th",                               Opt_TemplateHaskell,
1565     deprecatedForLanguage "TemplateHaskell" ),
1566   ( "fi",                               Opt_ForeignFunctionInterface,
1567     deprecatedForLanguage "ForeignFunctionInterface" ),
1568   ( "ffi",                              Opt_ForeignFunctionInterface,
1569     deprecatedForLanguage "ForeignFunctionInterface" ),
1570   ( "arrows",                           Opt_Arrows,
1571     deprecatedForLanguage "Arrows" ),
1572   ( "generics",                         Opt_Generics,
1573     deprecatedForLanguage "Generics" ),
1574   ( "implicit-prelude",                 Opt_ImplicitPrelude,
1575     deprecatedForLanguage "ImplicitPrelude" ),
1576   ( "bang-patterns",                    Opt_BangPatterns,
1577     deprecatedForLanguage "BangPatterns" ),
1578   ( "monomorphism-restriction",         Opt_MonomorphismRestriction,
1579     deprecatedForLanguage "MonomorphismRestriction" ),
1580   ( "mono-pat-binds",                   Opt_MonoPatBinds,
1581     deprecatedForLanguage "MonoPatBinds" ),
1582   ( "extended-default-rules",           Opt_ExtendedDefaultRules,
1583     deprecatedForLanguage "ExtendedDefaultRules" ),
1584   ( "implicit-params",                  Opt_ImplicitParams,
1585     deprecatedForLanguage "ImplicitParams" ),
1586   ( "scoped-type-variables",            Opt_ScopedTypeVariables,
1587     deprecatedForLanguage "ScopedTypeVariables" ),
1588   ( "parr",                             Opt_PArr,
1589     deprecatedForLanguage "PArr" ),
1590   ( "allow-overlapping-instances",      Opt_OverlappingInstances,
1591     deprecatedForLanguage "OverlappingInstances" ),
1592   ( "allow-undecidable-instances",      Opt_UndecidableInstances,
1593     deprecatedForLanguage "UndecidableInstances" ),
1594   ( "allow-incoherent-instances",       Opt_IncoherentInstances,
1595     deprecatedForLanguage "IncoherentInstances" ),
1596   ( "gen-manifest",                     Opt_GenManifest, const Supported ),
1597   ( "embed-manifest",                   Opt_EmbedManifest, const Supported ),
1598   ( "implicit-import-qualified",        Opt_ImplicitImportQualified, const Supported )
1599   ]
1600
1601 supportedLanguages :: [String]
1602 supportedLanguages = [ name | (name, _, _) <- xFlags ]
1603
1604 -- This may contain duplicates
1605 languageOptions :: [DynFlag]
1606 languageOptions = [ dynFlag | (_, dynFlag, _) <- xFlags ]
1607
1608 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1609 xFlags :: [(String, DynFlag, Bool -> Deprecated)]
1610 xFlags = [
1611   ( "CPP",                              Opt_Cpp, const Supported ),
1612   ( "PostfixOperators",                 Opt_PostfixOperators, const Supported ),
1613   ( "PatternGuards",                    Opt_PatternGuards, const Supported ),
1614   ( "UnicodeSyntax",                    Opt_UnicodeSyntax, const Supported ),
1615   ( "MagicHash",                        Opt_MagicHash, const Supported ),
1616   ( "PolymorphicComponents",            Opt_PolymorphicComponents, const Supported ),
1617   ( "ExistentialQuantification",        Opt_ExistentialQuantification, const Supported ),
1618   ( "KindSignatures",                   Opt_KindSignatures, const Supported ),
1619   ( "EmptyDataDecls",                   Opt_EmptyDataDecls, const Supported ),
1620   ( "ParallelListComp",                 Opt_ParallelListComp, const Supported ),
1621   ( "TransformListComp",                Opt_TransformListComp, const Supported ),
1622   ( "ForeignFunctionInterface",         Opt_ForeignFunctionInterface, const Supported ),
1623   ( "UnliftedFFITypes",                 Opt_UnliftedFFITypes, const Supported ),
1624   ( "LiberalTypeSynonyms",              Opt_LiberalTypeSynonyms, const Supported ),
1625   ( "Rank2Types",                       Opt_Rank2Types, const Supported ),
1626   ( "RankNTypes",                       Opt_RankNTypes, const Supported ),
1627   ( "ImpredicativeTypes",               Opt_ImpredicativeTypes, const Supported ),
1628   ( "TypeOperators",                    Opt_TypeOperators, const Supported ),
1629   ( "RecursiveDo",                      Opt_RecursiveDo, const Supported ),
1630   ( "Arrows",                           Opt_Arrows, const Supported ),
1631   ( "PArr",                             Opt_PArr, const Supported ),
1632   ( "TemplateHaskell",                  Opt_TemplateHaskell, const Supported ),
1633   ( "QuasiQuotes",                      Opt_QuasiQuotes, const Supported ),
1634   ( "Generics",                         Opt_Generics, const Supported ),
1635   -- On by default:
1636   ( "ImplicitPrelude",                  Opt_ImplicitPrelude, const Supported ),
1637   ( "RecordWildCards",                  Opt_RecordWildCards, const Supported ),
1638   ( "NamedFieldPuns",                   Opt_RecordPuns, const Supported ),
1639   ( "RecordPuns",                       Opt_RecordPuns,
1640     deprecatedForLanguage "NamedFieldPuns" ),
1641   ( "DisambiguateRecordFields",         Opt_DisambiguateRecordFields, const Supported ),
1642   ( "OverloadedStrings",                Opt_OverloadedStrings, const Supported ),
1643   ( "GADTs",                            Opt_GADTs, const Supported ),
1644   ( "ViewPatterns",                     Opt_ViewPatterns, const Supported ),
1645   ( "TypeFamilies",                     Opt_TypeFamilies, const Supported ),
1646   ( "BangPatterns",                     Opt_BangPatterns, const Supported ),
1647   -- On by default:
1648   ( "MonomorphismRestriction",          Opt_MonomorphismRestriction, const Supported ),
1649   -- On by default (which is not strictly H98):
1650   ( "MonoPatBinds",                     Opt_MonoPatBinds, const Supported ),
1651   ( "RelaxedPolyRec",                   Opt_RelaxedPolyRec, const Supported ),
1652   ( "ExtendedDefaultRules",             Opt_ExtendedDefaultRules, const Supported ),
1653   ( "ImplicitParams",                   Opt_ImplicitParams, const Supported ),
1654   ( "ScopedTypeVariables",              Opt_ScopedTypeVariables, const Supported ),
1655
1656   ( "PatternSignatures",                Opt_ScopedTypeVariables,
1657     deprecatedForLanguage "ScopedTypeVariables" ),
1658
1659   ( "UnboxedTuples",                    Opt_UnboxedTuples, const Supported ),
1660   ( "StandaloneDeriving",               Opt_StandaloneDeriving, const Supported ),
1661   ( "DeriveDataTypeable",               Opt_DeriveDataTypeable, const Supported ),
1662   ( "TypeSynonymInstances",             Opt_TypeSynonymInstances, const Supported ),
1663   ( "FlexibleContexts",                 Opt_FlexibleContexts, const Supported ),
1664   ( "FlexibleInstances",                Opt_FlexibleInstances, const Supported ),
1665   ( "ConstrainedClassMethods",          Opt_ConstrainedClassMethods, const Supported ),
1666   ( "MultiParamTypeClasses",            Opt_MultiParamTypeClasses, const Supported ),
1667   ( "FunctionalDependencies",           Opt_FunctionalDependencies, const Supported ),
1668   ( "GeneralizedNewtypeDeriving",       Opt_GeneralizedNewtypeDeriving, const Supported ),
1669   ( "OverlappingInstances",             Opt_OverlappingInstances, const Supported ),
1670   ( "UndecidableInstances",             Opt_UndecidableInstances, const Supported ),
1671   ( "IncoherentInstances",              Opt_IncoherentInstances, const Supported ),
1672   ( "PackageImports",                   Opt_PackageImports, const Supported ),
1673   ( "NewQualifiedOperators",            Opt_NewQualifiedOperators, const Supported )
1674   ]
1675
1676 impliedFlags :: [(DynFlag, DynFlag)]
1677 impliedFlags
1678   = [ (Opt_GADTs,               Opt_RelaxedPolyRec)  -- We want type-sig variables to
1679                                                      --      be completely rigid for GADTs
1680
1681     , (Opt_ScopedTypeVariables, Opt_RelaxedPolyRec)  -- Ditto for scoped type variables; see
1682                                                      --      Note [Scoped tyvars] in TcBinds
1683   ]
1684
1685 glasgowExtsFlags :: [DynFlag]
1686 glasgowExtsFlags = [
1687              Opt_PrintExplicitForalls
1688            , Opt_ForeignFunctionInterface
1689            , Opt_UnliftedFFITypes
1690            , Opt_GADTs
1691            , Opt_ImplicitParams
1692            , Opt_ScopedTypeVariables
1693            , Opt_UnboxedTuples
1694            , Opt_TypeSynonymInstances
1695            , Opt_StandaloneDeriving
1696            , Opt_DeriveDataTypeable
1697            , Opt_FlexibleContexts
1698            , Opt_FlexibleInstances
1699            , Opt_ConstrainedClassMethods
1700            , Opt_MultiParamTypeClasses
1701            , Opt_FunctionalDependencies
1702            , Opt_MagicHash
1703            , Opt_PolymorphicComponents
1704            , Opt_ExistentialQuantification
1705            , Opt_UnicodeSyntax
1706            , Opt_PostfixOperators
1707            , Opt_PatternGuards
1708            , Opt_LiberalTypeSynonyms
1709            , Opt_RankNTypes
1710            , Opt_ImpredicativeTypes
1711            , Opt_TypeOperators
1712            , Opt_RecursiveDo
1713            , Opt_ParallelListComp
1714            , Opt_EmptyDataDecls
1715            , Opt_KindSignatures
1716            , Opt_GeneralizedNewtypeDeriving
1717            , Opt_TypeFamilies ]
1718
1719 -- -----------------------------------------------------------------------------
1720 -- Parsing the dynamic flags.
1721
1722 -- | Parse dynamic flags from a list of command line arguments.  Returns the
1723 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1724 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1725 -- flags or missing arguments).
1726 parseDynamicFlags :: Monad m =>
1727                      DynFlags -> [Located String]
1728                   -> m (DynFlags, [Located String], [Located String])
1729                      -- ^ Updated 'DynFlags', left-over arguments, and
1730                      -- list of warnings.
1731 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1732
1733 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1734 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1735 parseDynamicNoPackageFlags :: Monad m =>
1736                      DynFlags -> [Located String]
1737                   -> m (DynFlags, [Located String], [Located String])
1738                      -- ^ Updated 'DynFlags', left-over arguments, and
1739                      -- list of warnings.
1740 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1741
1742 parseDynamicFlags_ :: Monad m =>
1743                       DynFlags -> [Located String] -> Bool
1744                   -> m (DynFlags, [Located String], [Located String])
1745 parseDynamicFlags_ dflags args pkg_flags = do
1746   -- XXX Legacy support code
1747   -- We used to accept things like
1748   --     optdep-f  -optdepdepend
1749   --     optdep-f  -optdep depend
1750   --     optdep -f -optdepdepend
1751   --     optdep -f -optdep depend
1752   -- but the spaces trip up proper argument handling. So get rid of them.
1753   let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1754       f (x : xs) = x : f xs
1755       f xs = xs
1756       args' = f args
1757
1758       -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1759       flag_spec | pkg_flags = package_flags ++ dynamic_flags
1760                 | otherwise = dynamic_flags
1761
1762   let ((leftover, errs, warns), dflags')
1763           = runCmdLine (processArgs flag_spec args') dflags
1764   when (not (null errs)) $ ghcError $ errorsToGhcException errs
1765   return (dflags', leftover, warns)
1766
1767 type DynP = CmdLineP DynFlags
1768
1769 upd :: (DynFlags -> DynFlags) -> DynP ()
1770 upd f = do
1771    dfs <- getCmdLineState
1772    putCmdLineState $! (f dfs)
1773
1774 --------------------------
1775 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1776 setDynFlag f = do { upd (\dfs -> dopt_set dfs f)
1777                   ; mapM_ setDynFlag deps }
1778   where
1779     deps = [ d | (f', d) <- impliedFlags, f' == f ]
1780         -- When you set f, set the ones it implies
1781         -- NB: use setDynFlag recursively, in case the implied flags
1782         --     implies further flags
1783         -- When you un-set f, however, we don't un-set the things it implies
1784         --      (except for -fno-glasgow-exts, which is treated specially)
1785
1786 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1787
1788 --------------------------
1789 setDumpFlag :: DynFlag -> OptKind DynP
1790 setDumpFlag dump_flag
1791   = NoArg (setDynFlag dump_flag >> when want_recomp forceRecompile)
1792   where
1793         -- Certain dumpy-things are really interested in what's going
1794         -- on during recompilation checking, so in those cases we
1795         -- don't want to turn it off.
1796     want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
1797                                        Opt_D_dump_hi_diffs]
1798
1799 forceRecompile :: DynP ()
1800 -- Whenver we -ddump, force recompilation (by switching off the
1801 -- recompilation checker), else you don't see the dump! However,
1802 -- don't switch it off in --make mode, else *everything* gets
1803 -- recompiled which probably isn't what you want
1804 forceRecompile = do { dfs <- getCmdLineState
1805                     ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
1806         where
1807           force_recomp dfs = isOneShot (ghcMode dfs)
1808
1809 setVerboseCore2Core :: DynP ()
1810 setVerboseCore2Core = do setDynFlag Opt_D_verbose_core2core
1811                          forceRecompile
1812                          upd (\s -> s { shouldDumpSimplPhase = const True })
1813
1814 setDumpSimplPhases :: String -> DynP ()
1815 setDumpSimplPhases s = do forceRecompile
1816                           upd (\s -> s { shouldDumpSimplPhase = spec })
1817   where
1818     spec :: SimplifierMode -> Bool
1819     spec = join (||)
1820          . map (join (&&) . map match . split ':')
1821          . split ','
1822          $ case s of
1823              '=' : s' -> s'
1824              _        -> s
1825
1826     join :: (Bool -> Bool -> Bool)
1827          -> [SimplifierMode -> Bool]
1828          -> SimplifierMode -> Bool
1829     join _  [] = const True
1830     join op ss = foldr1 (\f g x -> f x `op` g x) ss
1831
1832     match :: String -> SimplifierMode -> Bool
1833     match "" = const True
1834     match s  = case reads s of
1835                 [(n,"")] -> phase_num  n
1836                 _        -> phase_name s
1837
1838     phase_num :: Int -> SimplifierMode -> Bool
1839     phase_num n (SimplPhase k _) = n == k
1840     phase_num _ _                = False
1841
1842     phase_name :: String -> SimplifierMode -> Bool
1843     phase_name s SimplGently       = s == "gentle"
1844     phase_name s (SimplPhase _ ss) = s `elem` ss
1845
1846 setVerbosity :: Maybe Int -> DynP ()
1847 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
1848
1849 addCmdlineHCInclude :: String -> DynP ()
1850 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes =  a : cmdlineHcIncludes s})
1851
1852 extraPkgConf_ :: FilePath -> DynP ()
1853 extraPkgConf_  p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
1854
1855 exposePackage, hidePackage, ignorePackage :: String -> DynP ()
1856 exposePackage p =
1857   upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
1858 hidePackage p =
1859   upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
1860 ignorePackage p =
1861   upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
1862
1863 setPackageName :: String -> DynFlags -> DynFlags
1864 setPackageName p
1865   | Nothing <- unpackPackageId pid
1866   = ghcError (CmdLineError ("cannot parse \'" ++ p ++ "\' as a package identifier"))
1867   | otherwise
1868   = \s -> s{ thisPackage = pid }
1869   where
1870         pid = stringToPackageId p
1871
1872 -- If we're linking a binary, then only targets that produce object
1873 -- code are allowed (requests for other target types are ignored).
1874 setTarget :: HscTarget -> DynP ()
1875 setTarget l = upd set
1876   where
1877    set dfs
1878      | ghcLink dfs /= LinkBinary || isObjectTarget l  = dfs{ hscTarget = l }
1879      | otherwise = dfs
1880
1881 -- Changes the target only if we're compiling object code.  This is
1882 -- used by -fasm and -fvia-C, which switch from one to the other, but
1883 -- not from bytecode to object-code.  The idea is that -fasm/-fvia-C
1884 -- can be safely used in an OPTIONS_GHC pragma.
1885 setObjTarget :: HscTarget -> DynP ()
1886 setObjTarget l = upd set
1887   where
1888    set dfs
1889      | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
1890      | otherwise = dfs
1891
1892 setOptLevel :: Int -> DynFlags -> DynFlags
1893 setOptLevel n dflags
1894    | hscTarget dflags == HscInterpreted && n > 0
1895         = dflags
1896             -- not in IO any more, oh well:
1897             -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
1898    | otherwise
1899         = updOptLevel n dflags
1900
1901
1902 -- -Odph is equivalent to
1903 --
1904 --    -O2                               optimise as much as possible
1905 --    -fno-method-sharing               sharing specialisation defeats fusion
1906 --                                      sometimes
1907 --    -fdicts-cheap                     always inline dictionaries
1908 --    -fmax-simplifier-iterations20     this is necessary sometimes
1909 --    -fno-spec-constr-threshold        run SpecConstr even for big loops
1910 --    -fno-spec-constr-count            SpecConstr as much as possible
1911 --
1912 setDPHOpt :: DynFlags -> DynFlags
1913 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations  = 20
1914                                          , specConstrThreshold = Nothing
1915                                          , specConstrCount     = Nothing
1916                                          })
1917                    `dopt_set`   Opt_DictsCheap
1918                    `dopt_unset` Opt_MethodSharing
1919
1920 data DPHBackend = DPHPar
1921                 | DPHSeq
1922                 | DPHThis
1923         deriving(Eq, Ord, Enum, Show)
1924
1925 setDPHBackend :: DPHBackend -> DynP ()
1926 setDPHBackend backend
1927   = do
1928       upd $ \dflags -> dflags { dphBackend = backend }
1929       mapM_ exposePackage (dph_packages backend)
1930   where
1931     dph_packages DPHThis = []
1932     dph_packages DPHPar  = ["dph-prim-par", "dph-par"]
1933     dph_packages DPHSeq  = ["dph-prim-seq", "dph-seq"]
1934
1935 dphPackage :: DynFlags -> PackageId
1936 dphPackage dflags = case dphBackend dflags of
1937                       DPHPar  -> dphParPackageId
1938                       DPHSeq  -> dphSeqPackageId
1939                       DPHThis -> thisPackage dflags
1940
1941 setMainIs :: String -> DynP ()
1942 setMainIs arg
1943   | not (null main_fn) && isLower (head main_fn)
1944      -- The arg looked like "Foo.Bar.baz"
1945   = upd $ \d -> d{ mainFunIs = Just main_fn,
1946                    mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
1947
1948   | isUpper (head arg)  -- The arg looked like "Foo" or "Foo.Bar"
1949   = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
1950
1951   | otherwise                   -- The arg looked like "baz"
1952   = upd $ \d -> d{ mainFunIs = Just arg }
1953   where
1954     (main_mod, main_fn) = splitLongestPrefix arg (== '.')
1955
1956 -- | Get the unqualified name of the function to use as the \"main\" for the main module.
1957 -- Either returns the default name or the one configured on the command line with -main-is
1958 getMainFun :: DynFlags -> RdrName
1959 getMainFun dflags = case (mainFunIs dflags) of
1960     Just fn -> mkRdrUnqual (mkVarOccFS (mkFastString fn))
1961     Nothing -> main_RDR_Unqual
1962
1963 -----------------------------------------------------------------------------
1964 -- Paths & Libraries
1965
1966 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
1967
1968 -- -i on its own deletes the import paths
1969 addImportPath "" = upd (\s -> s{importPaths = []})
1970 addImportPath p  = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
1971
1972
1973 addLibraryPath p =
1974   upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
1975
1976 addIncludePath p =
1977   upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
1978
1979 addFrameworkPath p =
1980   upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
1981
1982 #ifndef mingw32_TARGET_OS
1983 split_marker :: Char
1984 split_marker = ':'   -- not configurable (ToDo)
1985 #endif
1986
1987 splitPathList :: String -> [String]
1988 splitPathList s = filter notNull (splitUp s)
1989                 -- empty paths are ignored: there might be a trailing
1990                 -- ':' in the initial list, for example.  Empty paths can
1991                 -- cause confusion when they are translated into -I options
1992                 -- for passing to gcc.
1993   where
1994 #ifndef mingw32_TARGET_OS
1995     splitUp xs = split split_marker xs
1996 #else
1997      -- Windows: 'hybrid' support for DOS-style paths in directory lists.
1998      --
1999      -- That is, if "foo:bar:baz" is used, this interpreted as
2000      -- consisting of three entries, 'foo', 'bar', 'baz'.
2001      -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2002      -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2003      --
2004      -- Notice that no attempt is made to fully replace the 'standard'
2005      -- split marker ':' with the Windows / DOS one, ';'. The reason being
2006      -- that this will cause too much breakage for users & ':' will
2007      -- work fine even with DOS paths, if you're not insisting on being silly.
2008      -- So, use either.
2009     splitUp []             = []
2010     splitUp (x:':':div:xs) | div `elem` dir_markers
2011                            = ((x:':':div:p): splitUp rs)
2012                            where
2013                               (p,rs) = findNextPath xs
2014           -- we used to check for existence of the path here, but that
2015           -- required the IO monad to be threaded through the command-line
2016           -- parser which is quite inconvenient.  The
2017     splitUp xs = cons p (splitUp rs)
2018                where
2019                  (p,rs) = findNextPath xs
2020
2021                  cons "" xs = xs
2022                  cons x  xs = x:xs
2023
2024     -- will be called either when we've consumed nought or the
2025     -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2026     -- finding the next split marker.
2027     findNextPath xs =
2028         case break (`elem` split_markers) xs of
2029            (p, _:ds) -> (p, ds)
2030            (p, xs)   -> (p, xs)
2031
2032     split_markers :: [Char]
2033     split_markers = [':', ';']
2034
2035     dir_markers :: [Char]
2036     dir_markers = ['/', '\\']
2037 #endif
2038
2039 -- -----------------------------------------------------------------------------
2040 -- tmpDir, where we store temporary files.
2041
2042 setTmpDir :: FilePath -> DynFlags -> DynFlags
2043 setTmpDir dir dflags = dflags{ tmpDir = normalise dir }
2044   -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2045   -- seem necessary now --SDM 7/2/2008
2046
2047 -----------------------------------------------------------------------------
2048 -- Hpc stuff
2049
2050 setOptHpcDir :: String -> DynP ()
2051 setOptHpcDir arg  = upd $ \ d -> d{hpcDir = arg}
2052
2053 -----------------------------------------------------------------------------
2054 -- Via-C compilation stuff
2055
2056 -- There are some options that we need to pass to gcc when compiling
2057 -- Haskell code via C, but are only supported by recent versions of
2058 -- gcc.  The configure script decides which of these options we need,
2059 -- and puts them in the file "extra-gcc-opts" in $topdir, which is
2060 -- read before each via-C compilation.  The advantage of having these
2061 -- in a separate file is that the file can be created at install-time
2062 -- depending on the available gcc version, and even re-generated  later
2063 -- if gcc is upgraded.
2064 --
2065 -- The options below are not dependent on the version of gcc, only the
2066 -- platform.
2067
2068 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
2069                               [String]) -- for registerised HC compilations
2070 machdepCCOpts _dflags
2071 #if alpha_TARGET_ARCH
2072         =       ( ["-w", "-mieee"
2073 #ifdef HAVE_THREADED_RTS_SUPPORT
2074                     , "-D_REENTRANT"
2075 #endif
2076                    ], [] )
2077         -- For now, to suppress the gcc warning "call-clobbered
2078         -- register used for global register variable", we simply
2079         -- disable all warnings altogether using the -w flag. Oh well.
2080
2081 #elif hppa_TARGET_ARCH
2082         -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2083         -- (very nice, but too bad the HP /usr/include files don't agree.)
2084         = ( ["-D_HPUX_SOURCE"], [] )
2085
2086 #elif m68k_TARGET_ARCH
2087       -- -fno-defer-pop : for the .hc files, we want all the pushing/
2088       --    popping of args to routines to be explicit; if we let things
2089       --    be deferred 'til after an STGJUMP, imminent death is certain!
2090       --
2091       -- -fomit-frame-pointer : *don't*
2092       --     It's better to have a6 completely tied up being a frame pointer
2093       --     rather than let GCC pick random things to do with it.
2094       --     (If we want to steal a6, then we would try to do things
2095       --     as on iX86, where we *do* steal the frame pointer [%ebp].)
2096         = ( [], ["-fno-defer-pop", "-fno-omit-frame-pointer"] )
2097
2098 #elif i386_TARGET_ARCH
2099       -- -fno-defer-pop : basically the same game as for m68k
2100       --
2101       -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2102       --   the fp (%ebp) for our register maps.
2103         =  let n_regs = stolen_x86_regs _dflags
2104                sta = opt_Static
2105            in
2106                     ( [ if sta then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
2107                       ],
2108                       [ "-fno-defer-pop",
2109                         "-fomit-frame-pointer",
2110                         -- we want -fno-builtin, because when gcc inlines
2111                         -- built-in functions like memcpy() it tends to
2112                         -- run out of registers, requiring -monly-n-regs
2113                         "-fno-builtin",
2114                         "-DSTOLEN_X86_REGS="++show n_regs ]
2115                     )
2116
2117 #elif ia64_TARGET_ARCH
2118         = ( [], ["-fomit-frame-pointer", "-G0"] )
2119
2120 #elif x86_64_TARGET_ARCH
2121         = ( [], ["-fomit-frame-pointer",
2122                  "-fno-asynchronous-unwind-tables",
2123                         -- the unwind tables are unnecessary for HC code,
2124                         -- and get in the way of -split-objs.  Another option
2125                         -- would be to throw them away in the mangler, but this
2126                         -- is easier.
2127                  "-fno-builtin"
2128                         -- calling builtins like strlen() using the FFI can
2129                         -- cause gcc to run out of regs, so use the external
2130                         -- version.
2131                 ] )
2132
2133 #elif sparc_TARGET_ARCH
2134         = ( [], ["-w"] )
2135         -- For now, to suppress the gcc warning "call-clobbered
2136         -- register used for global register variable", we simply
2137         -- disable all warnings altogether using the -w flag. Oh well.
2138
2139 #elif powerpc_apple_darwin_TARGET
2140       -- -no-cpp-precomp:
2141       --     Disable Apple's precompiling preprocessor. It's a great thing
2142       --     for "normal" programs, but it doesn't support register variable
2143       --     declarations.
2144         = ( [], ["-no-cpp-precomp"] )
2145 #else
2146         = ( [], [] )
2147 #endif
2148
2149 picCCOpts :: DynFlags -> [String]
2150 picCCOpts _dflags
2151 #if darwin_TARGET_OS
2152       -- Apple prefers to do things the other way round.
2153       -- PIC is on by default.
2154       -- -mdynamic-no-pic:
2155       --     Turn off PIC code generation.
2156       -- -fno-common:
2157       --     Don't generate "common" symbols - these are unwanted
2158       --     in dynamic libraries.
2159
2160     | opt_PIC
2161         = ["-fno-common", "-D__PIC__"]
2162     | otherwise
2163         = ["-mdynamic-no-pic"]
2164 #elif mingw32_TARGET_OS
2165       -- no -fPIC for Windows
2166     | opt_PIC
2167         = ["-D__PIC__"]
2168     | otherwise
2169         = []
2170 #else
2171     | opt_PIC
2172         = ["-fPIC", "-D__PIC__"]
2173     | otherwise
2174         = []
2175 #endif
2176
2177 -- -----------------------------------------------------------------------------
2178 -- Splitting
2179
2180 can_split :: Bool
2181 can_split = cSplitObjs == "YES"
2182
2183 -- -----------------------------------------------------------------------------
2184 -- Compiler Info
2185
2186 compilerInfo :: [(String, String)]
2187 compilerInfo = [("Project name",                cProjectName),
2188                 ("Project version",             cProjectVersion),
2189                 ("Booter version",              cBooterVersion),
2190                 ("Stage",                       cStage),
2191                 ("Interface file version",      cHscIfaceFileVersion),
2192                 ("Have interpreter",            cGhcWithInterpreter),
2193                 ("Object splitting",            cSplitObjs),
2194                 ("Have native code generator",  cGhcWithNativeCodeGen),
2195                 ("Support SMP",                 cGhcWithSMP),
2196                 ("Unregisterised",              cGhcUnregisterised),
2197                 ("Tables next to code",         cGhcEnableTablesNextToCode),
2198                 ("Win32 DLLs",                  cEnableWin32DLLs),
2199                 ("RTS ways",                    cGhcRTSWays),
2200                 ("Leading underscore",          cLeadingUnderscore),
2201                 ("Debug on",                    show debugIsOn)
2202                ]
2203