compiler/main/DynFlags.hs

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