compiler/main/DynFlags.hs

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