5 -- (c) The University of Glasgow 2005
8 -- Most flags are dynamic flags, which means they can change from
9 -- compilation to compilation using @OPTIONS_GHC@ pragmas, and in a
10 -- multi-session GHC each session can be using different dynamic
11 -- flags. Dynamic flags can also be set at the prompt in GHCi.
13 -- * Dynamic flags and associated configuration types
16 HscTarget(..), isObjectTarget, defaultObjectTarget,
17 GhcMode(..), isOneShot,
18 GhcLink(..), isNoLink,
25 -- ** Manipulating DynFlags
26 defaultDynFlags, -- DynFlags
27 initDynFlags, -- DynFlags -> IO DynFlags
29 dopt, -- DynFlag -> DynFlags -> Bool
30 dopt_set, dopt_unset, -- DynFlags -> DynFlag -> DynFlags
31 getOpts, -- DynFlags -> (DynFlags -> [a]) -> [a]
38 -- ** Parsing DynFlags
40 parseDynamicNoPackageFlags,
43 supportedLanguages, languageOptions,
45 -- ** DynFlag C compiler options
46 machdepCCOpts, picCCOpts,
48 -- * Configuration of the core-to-core passes
55 -- * Configuration of the stg-to-stg passes
59 -- * Compiler configuration suitable for display to the user
63 #include "HsVersions.h"
65 #ifndef OMIT_NATIVE_CODEGEN
70 import PrelNames ( mAIN )
71 #if defined(i386_TARGET_ARCH) || (!defined(mingw32_TARGET_OS) && !defined(darwin_TARGET_OS))
72 import StaticFlags ( opt_Static )
74 import StaticFlags ( opt_PIC, WayName(..), v_Ways, v_Build_tag,
76 import {-# SOURCE #-} Packages (PackageState)
77 import DriverPhases ( Phase(..), phaseInputExt )
80 import Constants ( mAX_CONTEXT_REDUCTION_DEPTH )
82 import UniqFM ( UniqFM )
84 import Maybes ( orElse )
89 import {-# SOURCE #-} ErrUtils ( Severity(..), Message, mkLocMessage )
92 import Control.Monad ( when )
95 import Data.List ( intersperse )
96 import System.FilePath
97 import System.IO ( stderr, hPutChar )
99 -- -----------------------------------------------------------------------------
102 -- | Enumerates the simple on-or-off dynamic flags
108 | Opt_D_dump_cmmz_pretty
112 | Opt_D_dump_asm_native
113 | Opt_D_dump_asm_liveness
114 | Opt_D_dump_asm_coalesce
115 | Opt_D_dump_asm_regalloc
116 | Opt_D_dump_asm_regalloc_stages
117 | Opt_D_dump_asm_conflicts
118 | Opt_D_dump_asm_stats
119 | Opt_D_dump_asm_expanded
125 | Opt_D_dump_inlinings
126 | Opt_D_dump_rule_firings
127 | Opt_D_dump_occur_anal
131 | Opt_D_dump_simpl_iterations
132 | Opt_D_dump_simpl_phases
141 | Opt_D_dump_worker_wrapper
142 | Opt_D_dump_rn_trace
143 | Opt_D_dump_rn_stats
145 | Opt_D_dump_simpl_stats
146 | Opt_D_dump_tc_trace
147 | Opt_D_dump_if_trace
154 | Opt_D_verbose_core2core
155 | Opt_D_verbose_stg2stg
157 | Opt_D_dump_hi_diffs
158 | Opt_D_dump_minimal_imports
159 | Opt_D_dump_mod_cycles
160 | Opt_D_dump_view_pattern_commoning
161 | Opt_D_faststring_stats
162 | Opt_DumpToFile -- ^ Append dump output to files instead of stdout.
163 | Opt_D_no_debug_output
169 | Opt_WarnIsError -- -Werror; makes warnings fatal
170 | Opt_WarnDuplicateExports
172 | Opt_WarnImplicitPrelude
173 | Opt_WarnIncompletePatterns
174 | Opt_WarnIncompletePatternsRecUpd
175 | Opt_WarnMissingFields
176 | Opt_WarnMissingMethods
177 | Opt_WarnMissingSigs
178 | Opt_WarnNameShadowing
179 | Opt_WarnOverlappingPatterns
180 | Opt_WarnSimplePatterns
181 | Opt_WarnTypeDefaults
182 | Opt_WarnMonomorphism
183 | Opt_WarnUnusedBinds
184 | Opt_WarnUnusedImports
185 | Opt_WarnUnusedMatches
186 | Opt_WarnWarningsDeprecations
187 | Opt_WarnDeprecatedFlags
188 | Opt_WarnDodgyImports
191 | Opt_WarnUnrecognisedPragmas
192 | Opt_WarnDodgyForeignImports
193 | Opt_WarnLazyUnliftedBindings
194 | Opt_WarnUnusedDoBind
195 | Opt_WarnWrongDoBind
199 | Opt_OverlappingInstances
200 | Opt_UndecidableInstances
201 | Opt_IncoherentInstances
202 | Opt_MonomorphismRestriction
205 | Opt_ExtendedDefaultRules -- Use GHC's extended rules for defaulting
206 | Opt_ForeignFunctionInterface
207 | Opt_UnliftedFFITypes
208 | Opt_GHCForeignImportPrim
209 | Opt_PArr -- Syntactic support for parallel arrays
210 | Opt_Arrows -- Arrow-notation syntax
211 | Opt_TemplateHaskell
214 | Opt_Generics -- "Derivable type classes"
215 | Opt_ImplicitPrelude
216 | Opt_ScopedTypeVariables
220 | Opt_OverloadedStrings
221 | Opt_DisambiguateRecordFields
222 | Opt_RecordWildCards
228 | Opt_StandaloneDeriving
229 | Opt_DeriveDataTypeable
231 | Opt_DeriveTraversable
234 | Opt_TypeSynonymInstances
235 | Opt_FlexibleContexts
236 | Opt_FlexibleInstances
237 | Opt_ConstrainedClassMethods
238 | Opt_MultiParamTypeClasses
239 | Opt_FunctionalDependencies
241 | Opt_PolymorphicComponents
242 | Opt_ExistentialQuantification
246 | Opt_ParallelListComp
247 | Opt_TransformListComp
248 | Opt_GeneralizedNewtypeDeriving
250 | Opt_PostfixOperators
252 | Opt_LiberalTypeSynonyms
255 | Opt_ImpredicativeTypes
258 | Opt_NewQualifiedOperators
260 | Opt_PrintExplicitForalls
265 | Opt_StaticArgumentTransformation
269 | Opt_IgnoreInterfacePragmas
270 | Opt_OmitInterfacePragmas
271 | Opt_DoLambdaEtaExpansion
275 | Opt_UnboxStrictFields
278 | Opt_InlineIfEnoughArgs
279 | Opt_EnableRewriteRules -- Apply rewrite rules during simplification
281 | Opt_RegsGraph -- do graph coloring register allocation
282 | Opt_RegsIterative -- do iterative coalescing graph coloring register allocation
285 | Opt_AutoSccsOnAllToplevs
286 | Opt_AutoSccsOnExportedToplevs
287 | Opt_AutoSccsOnIndividualCafs
295 | Opt_ExcessPrecision
296 | Opt_EagerBlackHoling
297 | Opt_ReadUserPackageConf
301 | Opt_HideAllPackages
302 | Opt_PrintBindResult
306 | Opt_BreakOnException
308 | Opt_PrintEvldWithShow
309 | Opt_PrintBindContents
312 | Opt_EmitExternalCore
317 | Opt_ConvertToZipCfgAndBack
318 | Opt_AutoLinkPackages
319 | Opt_ImplicitImportQualified
328 | Opt_KeepRawTokenStream
332 -- | Contains not only a collection of 'DynFlag's but also a plethora of
333 -- information relating to the compilation of a single file or GHC session
334 data DynFlags = DynFlags {
337 coreToDo :: Maybe [CoreToDo], -- reserved for -Ofile
338 stgToDo :: Maybe [StgToDo], -- similarly
339 hscTarget :: HscTarget,
340 hscOutName :: String, -- ^ Name of the output file
341 extCoreName :: String, -- ^ Name of the .hcr output file
342 verbosity :: Int, -- ^ Verbosity level: see "DynFlags#verbosity_levels"
343 optLevel :: Int, -- ^ Optimisation level
344 simplPhases :: Int, -- ^ Number of simplifier phases
345 maxSimplIterations :: Int, -- ^ Max simplifier iterations
346 shouldDumpSimplPhase :: SimplifierMode -> Bool,
347 ruleCheck :: Maybe String,
349 specConstrThreshold :: Maybe Int, -- ^ Threshold for SpecConstr
350 specConstrCount :: Maybe Int, -- ^ Max number of specialisations for any one function
351 liberateCaseThreshold :: Maybe Int, -- ^ Threshold for LiberateCase
353 #ifndef OMIT_NATIVE_CODEGEN
354 targetPlatform :: Platform, -- ^ The platform we're compiling for. Used by the NCG.
356 stolen_x86_regs :: Int,
357 cmdlineHcIncludes :: [String], -- ^ @\-\#includes@
358 importPaths :: [FilePath],
360 mainFunIs :: Maybe String,
361 ctxtStkDepth :: Int, -- ^ Typechecker context stack depth
363 dphBackend :: DPHBackend,
365 thisPackage :: PackageId, -- ^ name of package currently being compiled
368 wayNames :: [WayName], -- ^ Way flags from the command line
369 buildTag :: String, -- ^ The global \"way\" (e.g. \"p\" for prof)
370 rtsBuildTag :: String, -- ^ The RTS \"way\"
372 -- For object splitting
373 splitInfo :: Maybe (String,Int),
376 objectDir :: Maybe String,
377 hiDir :: Maybe String,
378 stubDir :: Maybe String,
384 outputFile :: Maybe String,
385 outputHi :: Maybe String,
386 dynLibLoader :: DynLibLoader,
388 -- | This is set by 'DriverPipeline.runPipeline' based on where
389 -- its output is going.
390 dumpPrefix :: Maybe FilePath,
392 -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.
393 -- Set by @-ddump-file-prefix@
394 dumpPrefixForce :: Maybe FilePath,
396 includePaths :: [String],
397 libraryPaths :: [String],
398 frameworkPaths :: [String], -- used on darwin only
399 cmdlineFrameworks :: [String], -- ditto
400 tmpDir :: String, -- no trailing '/'
402 ghcUsagePath :: FilePath, -- Filled in by SysTools
403 ghciUsagePath :: FilePath, -- ditto
405 hpcDir :: String, -- ^ Path to store the .mix files
407 -- options for particular phases
415 opt_windres :: [String],
417 -- commands for particular phases
419 pgm_P :: (String,[Option]),
421 pgm_c :: (String,[Option]),
422 pgm_m :: (String,[Option]),
423 pgm_s :: (String,[Option]),
424 pgm_a :: (String,[Option]),
425 pgm_l :: (String,[Option]),
426 pgm_dll :: (String,[Option]),
428 pgm_sysman :: String,
429 pgm_windres :: String,
432 depMakefile :: FilePath,
433 depIncludePkgDeps :: Bool,
434 depExcludeMods :: [ModuleName],
435 depSuffixes :: [String],
438 extraPkgConfs :: [FilePath],
439 topDir :: FilePath, -- filled in by SysTools
440 systemPackageConfig :: FilePath, -- ditto
441 -- ^ The @-package-conf@ flags given on the command line, in the order
444 packageFlags :: [PackageFlag],
445 -- ^ The @-package@ and @-hide-package@ flags from the command-line
448 -- NB. do not modify this field, it is calculated by
449 -- Packages.initPackages and Packages.updatePackages.
450 pkgDatabase :: Maybe (UniqFM PackageConfig),
451 pkgState :: PackageState,
454 -- These have to be IORefs, because the defaultCleanupHandler needs to
455 -- know what to clean when an exception happens
456 filesToClean :: IORef [FilePath],
457 dirsToClean :: IORef (FiniteMap FilePath FilePath),
462 -- | Message output action: use "ErrUtils" instead of this if you can
463 log_action :: Severity -> SrcSpan -> PprStyle -> Message -> IO (),
465 haddockOptions :: Maybe String
468 -- | The target code type of the compilation (if any).
470 -- Whenever you change the target, also make sure to set 'ghcLink' to
471 -- something sensible.
473 -- 'HscNothing' can be used to avoid generating any output, however, note
476 -- * This will not run the desugaring step, thus no warnings generated in
477 -- this step will be output. In particular, this includes warnings related
478 -- to pattern matching. You can run the desugarer manually using
479 -- 'GHC.desugarModule'.
481 -- * If a program uses Template Haskell the typechecker may try to run code
482 -- from an imported module. This will fail if no code has been generated
483 -- for this module. You can use 'GHC.needsTemplateHaskell' to detect
484 -- whether this might be the case and choose to either switch to a
485 -- different target or avoid typechecking such modules. (The latter may
486 -- preferable for security reasons.)
489 = HscC -- ^ Generate C code.
490 | HscAsm -- ^ Generate assembly using the native code generator.
491 | HscJava -- ^ Generate Java bytecode.
492 | HscInterpreted -- ^ Generate bytecode. (Requires 'LinkInMemory')
493 | HscNothing -- ^ Don't generate any code. See notes above.
496 -- | Will this target result in an object file on the disk?
497 isObjectTarget :: HscTarget -> Bool
498 isObjectTarget HscC = True
499 isObjectTarget HscAsm = True
500 isObjectTarget _ = False
502 -- | The 'GhcMode' tells us whether we're doing multi-module
503 -- compilation (controlled via the "GHC" API) or one-shot
504 -- (single-module) compilation. This makes a difference primarily to
505 -- the "Finder": in one-shot mode we look for interface files for
506 -- imported modules, but in multi-module mode we look for source files
507 -- in order to check whether they need to be recompiled.
509 = CompManager -- ^ @\-\-make@, GHCi, etc.
510 | OneShot -- ^ @ghc -c Foo.hs@
511 | MkDepend -- ^ @ghc -M@, see "Finder" for why we need this
514 instance Outputable GhcMode where
515 ppr CompManager = ptext (sLit "CompManager")
516 ppr OneShot = ptext (sLit "OneShot")
517 ppr MkDepend = ptext (sLit "MkDepend")
519 isOneShot :: GhcMode -> Bool
520 isOneShot OneShot = True
521 isOneShot _other = False
523 -- | What to do in the link step, if there is one.
525 = NoLink -- ^ Don't link at all
526 | LinkBinary -- ^ Link object code into a binary
527 | LinkInMemory -- ^ Use the in-memory dynamic linker (works for both
528 -- bytecode and object code).
529 | LinkDynLib -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
532 isNoLink :: GhcLink -> Bool
533 isNoLink NoLink = True
536 -- Is it worth evaluating this Bool and caching it in the DynFlags value
537 -- during initDynFlags?
538 doingTickyProfiling :: DynFlags -> Bool
539 doingTickyProfiling dflags = WayTicky `elem` wayNames dflags
542 = ExposePackage String
544 | IgnorePackage String
547 defaultHscTarget :: HscTarget
548 defaultHscTarget = defaultObjectTarget
550 -- | The 'HscTarget' value corresponding to the default way to create
551 -- object files on the current platform.
552 defaultObjectTarget :: HscTarget
554 | cGhcWithNativeCodeGen == "YES" = HscAsm
559 | Wrapped (Maybe String)
563 -- | Used by 'GHC.newSession' to partially initialize a new 'DynFlags' value
564 initDynFlags :: DynFlags -> IO DynFlags
565 initDynFlags dflags = do
566 -- someday these will be dynamic flags
567 ways <- readIORef v_Ways
568 build_tag <- readIORef v_Build_tag
569 rts_build_tag <- readIORef v_RTS_Build_tag
570 refFilesToClean <- newIORef []
571 refDirsToClean <- newIORef emptyFM
574 buildTag = build_tag,
575 rtsBuildTag = rts_build_tag,
576 filesToClean = refFilesToClean,
577 dirsToClean = refDirsToClean
580 -- | The normal 'DynFlags'. Note that they is not suitable for use in this form
581 -- and must be fully initialized by 'GHC.newSession' first.
582 defaultDynFlags :: DynFlags
585 ghcMode = CompManager,
586 ghcLink = LinkBinary,
589 hscTarget = defaultHscTarget,
595 maxSimplIterations = 4,
596 shouldDumpSimplPhase = const False,
598 specConstrThreshold = Just 200,
599 specConstrCount = Just 3,
600 liberateCaseThreshold = Just 200,
601 #ifndef OMIT_NATIVE_CODEGEN
602 targetPlatform = defaultTargetPlatform,
605 cmdlineHcIncludes = [],
609 ctxtStkDepth = mAX_CONTEXT_REDUCTION_DEPTH,
613 thisPackage = mainPackageId,
619 objectSuf = phaseInputExt StopLn,
620 hcSuf = phaseInputExt HCc,
623 outputFile = Nothing,
625 dynLibLoader = SystemDependent,
626 dumpPrefix = Nothing,
627 dumpPrefixForce = Nothing,
631 cmdlineFrameworks = [],
632 tmpDir = cDEFAULT_TMPDIR,
638 then ["-D__PIC__", "-U __PIC__"] -- this list is reversed
649 pkgDatabase = Nothing,
650 pkgState = panic "no package state yet: call GHC.setSessionDynFlags",
651 wayNames = panic "defaultDynFlags: No wayNames",
652 buildTag = panic "defaultDynFlags: No buildTag",
653 rtsBuildTag = panic "defaultDynFlags: No rtsBuildTag",
655 -- initSysTools fills all these in
656 ghcUsagePath = panic "defaultDynFlags: No ghciUsagePath",
657 ghciUsagePath = panic "defaultDynFlags: No ghciUsagePath",
658 topDir = panic "defaultDynFlags: No topDir",
659 systemPackageConfig = panic "no systemPackageConfig: call GHC.setSessionDynFlags",
660 pgm_L = panic "defaultDynFlags: No pgm_L",
661 pgm_P = panic "defaultDynFlags: No pgm_P",
662 pgm_F = panic "defaultDynFlags: No pgm_F",
663 pgm_c = panic "defaultDynFlags: No pgm_c",
664 pgm_m = panic "defaultDynFlags: No pgm_m",
665 pgm_s = panic "defaultDynFlags: No pgm_s",
666 pgm_a = panic "defaultDynFlags: No pgm_a",
667 pgm_l = panic "defaultDynFlags: No pgm_l",
668 pgm_dll = panic "defaultDynFlags: No pgm_dll",
669 pgm_T = panic "defaultDynFlags: No pgm_T",
670 pgm_sysman = panic "defaultDynFlags: No pgm_sysman",
671 pgm_windres = panic "defaultDynFlags: No pgm_windres",
672 -- end of initSysTools values
674 depMakefile = "Makefile",
675 depIncludePkgDeps = False,
678 -- end of ghc -M values
679 filesToClean = panic "defaultDynFlags: No filesToClean",
680 dirsToClean = panic "defaultDynFlags: No dirsToClean",
681 haddockOptions = Nothing,
683 Opt_AutoLinkPackages,
684 Opt_ReadUserPackageConf,
686 Opt_MonoPatBinds, -- Experimentally, I'm making this non-standard
687 -- behaviour the default, to see if anyone notices
691 Opt_MonomorphismRestriction,
699 Opt_PrintBindContents
701 ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]
702 -- The default -O0 options
705 log_action = \severity srcSpan style msg ->
707 SevInfo -> printErrs (msg style)
708 SevFatal -> printErrs (msg style)
711 printErrs ((mkLocMessage srcSpan msg) style)
712 -- careful (#2302): printErrs prints in UTF-8, whereas
713 -- converting to string first and using hPutStr would
714 -- just emit the low 8 bits of each unicode char.
721 0 | print errors & warnings only
722 1 | minimal verbosity: print "compiling M ... done." for each module.
723 2 | equivalent to -dshow-passes
724 3 | equivalent to existing "ghc -v"
725 4 | "ghc -v -ddump-most"
726 5 | "ghc -v -ddump-all"
729 -- | Test whether a 'DynFlag' is set
730 dopt :: DynFlag -> DynFlags -> Bool
731 dopt f dflags = f `elem` (flags dflags)
734 dopt_set :: DynFlags -> DynFlag -> DynFlags
735 dopt_set dfs f = dfs{ flags = f : flags dfs }
737 -- | Unset a 'DynFlag'
738 dopt_unset :: DynFlags -> DynFlag -> DynFlags
739 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
741 -- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
742 getOpts :: DynFlags -- ^ 'DynFlags' to retrieve the options from
743 -> (DynFlags -> [a]) -- ^ Relevant record accessor: one of the @opt_*@ accessors
744 -> [a] -- ^ Correctly ordered extracted options
745 getOpts dflags opts = reverse (opts dflags)
746 -- We add to the options from the front, so we need to reverse the list
748 -- | Gets the verbosity flag for the current verbosity level. This is fed to
749 -- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
750 getVerbFlag :: DynFlags -> String
752 | verbosity dflags >= 3 = "-v"
755 setObjectDir, setHiDir, setStubDir, setOutputDir,
756 setObjectSuf, setHiSuf, setHcSuf, parseDynLibLoaderMode,
757 setPgmP, setPgmL, setPgmF, setPgmc, setPgmm, setPgms, setPgma, setPgml, setPgmdll, setPgmwindres,
758 addOptL, addOptP, addOptF, addOptc, addOptm, addOpta, addOptl, addOptwindres,
759 addCmdlineFramework, addHaddockOpts
760 :: String -> DynFlags -> DynFlags
761 setOutputFile, setOutputHi, setDumpPrefixForce
762 :: Maybe String -> DynFlags -> DynFlags
764 setObjectDir f d = d{ objectDir = Just f}
765 setHiDir f d = d{ hiDir = Just f}
766 setStubDir f d = d{ stubDir = Just f, includePaths = f : includePaths d }
767 -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
768 -- \#included from the .hc file when compiling with -fvia-C.
769 setOutputDir f = setObjectDir f . setHiDir f . setStubDir f
771 setObjectSuf f d = d{ objectSuf = f}
772 setHiSuf f d = d{ hiSuf = f}
773 setHcSuf f d = d{ hcSuf = f}
775 setOutputFile f d = d{ outputFile = f}
776 setOutputHi f d = d{ outputHi = f}
778 parseDynLibLoaderMode f d =
780 ("deploy", "") -> d{ dynLibLoader = Deployable }
781 ("sysdep", "") -> d{ dynLibLoader = SystemDependent }
782 ("wrapped", "") -> d{ dynLibLoader = Wrapped Nothing }
783 ("wrapped:", "hard") -> d{ dynLibLoader = Wrapped Nothing }
784 ("wrapped:", flex) -> d{ dynLibLoader = Wrapped (Just flex) }
785 _ -> ghcError (CmdLineError ("Unknown dynlib loader: " ++ f))
787 setDumpPrefixForce f d = d { dumpPrefixForce = f}
789 -- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
790 -- Config.hs should really use Option.
791 setPgmP f d = let (pgm:args) = words f in d{ pgm_P = (pgm, map Option args)}
793 setPgmL f d = d{ pgm_L = f}
794 setPgmF f d = d{ pgm_F = f}
795 setPgmc f d = d{ pgm_c = (f,[])}
796 setPgmm f d = d{ pgm_m = (f,[])}
797 setPgms f d = d{ pgm_s = (f,[])}
798 setPgma f d = d{ pgm_a = (f,[])}
799 setPgml f d = d{ pgm_l = (f,[])}
800 setPgmdll f d = d{ pgm_dll = (f,[])}
801 setPgmwindres f d = d{ pgm_windres = f}
803 addOptL f d = d{ opt_L = f : opt_L d}
804 addOptP f d = d{ opt_P = f : opt_P d}
805 addOptF f d = d{ opt_F = f : opt_F d}
806 addOptc f d = d{ opt_c = f : opt_c d}
807 addOptm f d = d{ opt_m = f : opt_m d}
808 addOpta f d = d{ opt_a = f : opt_a d}
809 addOptl f d = d{ opt_l = f : opt_l d}
810 addOptwindres f d = d{ opt_windres = f : opt_windres d}
812 setDepMakefile :: FilePath -> DynFlags -> DynFlags
813 setDepMakefile f d = d { depMakefile = deOptDep f }
815 setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
816 setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }
818 addDepExcludeMod :: String -> DynFlags -> DynFlags
820 = d { depExcludeMods = mkModuleName (deOptDep m) : depExcludeMods d }
822 addDepSuffix :: FilePath -> DynFlags -> DynFlags
823 addDepSuffix s d = d { depSuffixes = deOptDep s : depSuffixes d }
826 -- We used to use "-optdep-flag -optdeparg", so for legacy applications
827 -- we need to strip the "-optdep" off of the arg
828 deOptDep :: String -> String
829 deOptDep x = case maybePrefixMatch "-optdep" x of
833 addCmdlineFramework f d = d{ cmdlineFrameworks = f : cmdlineFrameworks d}
835 addHaddockOpts f d = d{ haddockOptions = Just f}
837 -- -----------------------------------------------------------------------------
838 -- Command-line options
840 -- | When invoking external tools as part of the compilation pipeline, we
841 -- pass these a sequence of options on the command-line. Rather than
842 -- just using a list of Strings, we use a type that allows us to distinguish
843 -- between filepaths and 'other stuff'. The reason for this is that
844 -- this type gives us a handle on transforming filenames, and filenames only,
845 -- to whatever format they're expected to be on a particular platform.
847 = FileOption -- an entry that _contains_ filename(s) / filepaths.
848 String -- a non-filepath prefix that shouldn't be
849 -- transformed (e.g., "/out=")
850 String -- the filepath/filename portion
853 -----------------------------------------------------------------------------
854 -- Setting the optimisation level
856 updOptLevel :: Int -> DynFlags -> DynFlags
857 -- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
859 = dfs2{ optLevel = final_n }
861 final_n = max 0 (min 2 n) -- Clamp to 0 <= n <= 2
862 dfs1 = foldr (flip dopt_unset) dfs remove_dopts
863 dfs2 = foldr (flip dopt_set) dfs1 extra_dopts
865 extra_dopts = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]
866 remove_dopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]
868 optLevelFlags :: [([Int], DynFlag)]
870 = [ ([0], Opt_IgnoreInterfacePragmas)
871 , ([0], Opt_OmitInterfacePragmas)
873 , ([1,2], Opt_IgnoreAsserts)
874 , ([1,2], Opt_EnableRewriteRules) -- Off for -O0; see Note [Scoping for Builtin rules]
876 , ([1,2], Opt_DoEtaReduction)
877 , ([1,2], Opt_CaseMerge)
878 , ([1,2], Opt_Strictness)
880 , ([1,2], Opt_FullLaziness)
882 , ([2], Opt_LiberateCase)
883 , ([2], Opt_SpecConstr)
885 -- , ([2], Opt_StaticArgumentTransformation)
886 -- Max writes: I think it's probably best not to enable SAT with -O2 for the
887 -- 6.10 release. The version of SAT in HEAD at the moment doesn't incorporate
888 -- several improvements to the heuristics, and I'm concerned that without
889 -- those changes SAT will interfere with some attempts to write "high
890 -- performance Haskell", as we saw in some posts on Haskell-Cafe earlier
891 -- this year. In particular, the version in HEAD lacks the tail call
892 -- criterion, so many things that look like reasonable loops will be
893 -- turned into functions with extra (unneccesary) thunk creation.
895 , ([0,1,2], Opt_DoLambdaEtaExpansion)
896 -- This one is important for a tiresome reason:
897 -- we want to make sure that the bindings for data
898 -- constructors are eta-expanded. This is probably
899 -- a good thing anyway, but it seems fragile.
902 -- -----------------------------------------------------------------------------
903 -- Standard sets of warning options
905 standardWarnings :: [DynFlag]
907 = [ Opt_WarnWarningsDeprecations,
908 Opt_WarnDeprecatedFlags,
909 Opt_WarnUnrecognisedPragmas,
910 Opt_WarnOverlappingPatterns,
911 Opt_WarnMissingFields,
912 Opt_WarnMissingMethods,
913 Opt_WarnDuplicateExports,
914 Opt_WarnLazyUnliftedBindings,
915 Opt_WarnDodgyForeignImports,
919 minusWOpts :: [DynFlag]
921 = standardWarnings ++
922 [ Opt_WarnUnusedBinds,
923 Opt_WarnUnusedMatches,
924 Opt_WarnUnusedImports,
925 Opt_WarnIncompletePatterns,
929 minusWallOpts :: [DynFlag]
932 [ Opt_WarnTypeDefaults,
933 Opt_WarnNameShadowing,
940 -- minuswRemovesOpts should be every warning option
941 minuswRemovesOpts :: [DynFlag]
944 [Opt_WarnImplicitPrelude,
945 Opt_WarnIncompletePatternsRecUpd,
946 Opt_WarnSimplePatterns,
947 Opt_WarnMonomorphism,
948 Opt_WarnUnrecognisedPragmas,
952 -- -----------------------------------------------------------------------------
953 -- CoreToDo: abstraction of core-to-core passes to run.
955 data CoreToDo -- These are diff core-to-core passes,
956 -- which may be invoked in any order,
957 -- as many times as you like.
959 = CoreDoSimplify -- The core-to-core simplifier.
962 -- Each run of the simplifier can take a different
963 -- set of simplifier-specific flags.
965 | CoreDoFloatOutwards FloatOutSwitches
970 | CoreDoWorkerWrapper
973 | CoreDoOldStrictness
976 | CoreDoRuleCheck Int{-CompilerPhase-} String -- Check for non-application of rules
977 -- matching this string
978 | CoreDoVectorisation PackageId
979 | CoreDoNothing -- Useful when building up
980 | CoreDoPasses [CoreToDo] -- lists of these things
983 data SimplifierMode -- See comments in SimplMonad
985 | SimplPhase Int [String]
987 instance Outputable SimplifierMode where
988 ppr SimplGently = ptext (sLit "gentle")
989 ppr (SimplPhase n ss) = int n <+> brackets (text (concat $ intersperse "," ss))
992 data SimplifierSwitch
993 = MaxSimplifierIterations Int
997 data FloatOutSwitches = FloatOutSwitches {
998 floatOutLambdas :: Bool, -- ^ True <=> float lambdas to top level
999 floatOutConstants :: Bool -- ^ True <=> float constants to top level,
1000 -- even if they do not escape a lambda
1003 instance Outputable FloatOutSwitches where
1004 ppr = pprFloatOutSwitches
1006 pprFloatOutSwitches :: FloatOutSwitches -> SDoc
1007 pprFloatOutSwitches sw = pp_not (floatOutLambdas sw) <+> text "lambdas" <> comma
1008 <+> pp_not (floatOutConstants sw) <+> text "constants"
1011 pp_not False = text "not"
1013 -- | Switches that specify the minimum amount of floating out
1014 -- gentleFloatOutSwitches :: FloatOutSwitches
1015 -- gentleFloatOutSwitches = FloatOutSwitches False False
1017 -- | Switches that do not specify floating out of lambdas, just of constants
1018 constantsOnlyFloatOutSwitches :: FloatOutSwitches
1019 constantsOnlyFloatOutSwitches = FloatOutSwitches False True
1022 -- The core-to-core pass ordering is derived from the DynFlags:
1023 runWhen :: Bool -> CoreToDo -> CoreToDo
1024 runWhen True do_this = do_this
1025 runWhen False _ = CoreDoNothing
1027 runMaybe :: Maybe a -> (a -> CoreToDo) -> CoreToDo
1028 runMaybe (Just x) f = f x
1029 runMaybe Nothing _ = CoreDoNothing
1031 getCoreToDo :: DynFlags -> [CoreToDo]
1033 | Just todo <- coreToDo dflags = todo -- set explicitly by user
1034 | otherwise = core_todo
1036 opt_level = optLevel dflags
1037 phases = simplPhases dflags
1038 max_iter = maxSimplIterations dflags
1039 strictness = dopt Opt_Strictness dflags
1040 full_laziness = dopt Opt_FullLaziness dflags
1041 cse = dopt Opt_CSE dflags
1042 spec_constr = dopt Opt_SpecConstr dflags
1043 liberate_case = dopt Opt_LiberateCase dflags
1044 rule_check = ruleCheck dflags
1045 static_args = dopt Opt_StaticArgumentTransformation dflags
1047 maybe_rule_check phase = runMaybe rule_check (CoreDoRuleCheck phase)
1049 simpl_phase phase names iter
1051 [ CoreDoSimplify (SimplPhase phase names) [
1052 MaxSimplifierIterations iter
1054 maybe_rule_check phase
1058 = runWhen (dopt Opt_Vectorise dflags)
1059 $ CoreDoPasses [ simpl_gently, CoreDoVectorisation (dphPackage dflags) ]
1062 -- By default, we have 2 phases before phase 0.
1064 -- Want to run with inline phase 2 after the specialiser to give
1065 -- maximum chance for fusion to work before we inline build/augment
1066 -- in phase 1. This made a difference in 'ansi' where an
1067 -- overloaded function wasn't inlined till too late.
1069 -- Need phase 1 so that build/augment get
1070 -- inlined. I found that spectral/hartel/genfft lost some useful
1071 -- strictness in the function sumcode' if augment is not inlined
1072 -- before strictness analysis runs
1073 simpl_phases = CoreDoPasses [ simpl_phase phase ["main"] max_iter
1074 | phase <- [phases, phases-1 .. 1] ]
1077 -- initial simplify: mk specialiser happy: minimum effort please
1078 simpl_gently = CoreDoSimplify SimplGently [
1079 -- Simplify "gently"
1080 -- Don't inline anything till full laziness has bitten
1081 -- In particular, inlining wrappers inhibits floating
1082 -- e.g. ...(case f x of ...)...
1083 -- ==> ...(case (case x of I# x# -> fw x#) of ...)...
1084 -- ==> ...(case x of I# x# -> case fw x# of ...)...
1085 -- and now the redex (f x) isn't floatable any more
1086 -- Similarly, don't apply any rules until after full
1087 -- laziness. Notably, list fusion can prevent floating.
1089 NoCaseOfCase, -- Don't do case-of-case transformations.
1090 -- This makes full laziness work better
1091 MaxSimplifierIterations max_iter
1095 if opt_level == 0 then
1097 simpl_phase 0 ["final"] max_iter]
1098 else {- opt_level >= 1 -} [
1100 -- We want to do the static argument transform before full laziness as it
1101 -- may expose extra opportunities to float things outwards. However, to fix
1102 -- up the output of the transformation we need at do at least one simplify
1103 -- after this before anything else
1104 runWhen static_args (CoreDoPasses [ simpl_gently, CoreDoStaticArgs ]),
1106 -- We run vectorisation here for now, but we might also try to run
1110 -- initial simplify: mk specialiser happy: minimum effort please
1113 -- Specialisation is best done before full laziness
1114 -- so that overloaded functions have all their dictionary lambdas manifest
1117 runWhen full_laziness (CoreDoFloatOutwards constantsOnlyFloatOutSwitches),
1118 -- Was: gentleFloatOutSwitches
1119 -- I have no idea why, but not floating constants to top level is
1120 -- very bad in some cases.
1121 -- Notably: p_ident in spectral/rewrite
1122 -- Changing from "gentle" to "constantsOnly" improved
1123 -- rewrite's allocation by 19%, and made 0.0% difference
1124 -- to any other nofib benchmark
1130 -- Phase 0: allow all Ids to be inlined now
1131 -- This gets foldr inlined before strictness analysis
1133 -- At least 3 iterations because otherwise we land up with
1134 -- huge dead expressions because of an infelicity in the
1136 -- let k = BIG in foldr k z xs
1137 -- ==> let k = BIG in letrec go = \xs -> ...(k x).... in go xs
1138 -- ==> let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
1140 simpl_phase 0 ["main"] (max max_iter 3),
1143 #ifdef OLD_STRICTNESS
1144 CoreDoOldStrictness,
1146 runWhen strictness (CoreDoPasses [
1148 CoreDoWorkerWrapper,
1150 simpl_phase 0 ["post-worker-wrapper"] max_iter
1153 runWhen full_laziness
1154 (CoreDoFloatOutwards constantsOnlyFloatOutSwitches),
1155 -- nofib/spectral/hartel/wang doubles in speed if you
1156 -- do full laziness late in the day. It only happens
1157 -- after fusion and other stuff, so the early pass doesn't
1158 -- catch it. For the record, the redex is
1159 -- f_el22 (f_el21 r_midblock)
1162 runWhen cse CoreCSE,
1163 -- We want CSE to follow the final full-laziness pass, because it may
1164 -- succeed in commoning up things floated out by full laziness.
1165 -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
1171 -- Case-liberation for -O2. This should be after
1172 -- strictness analysis and the simplification which follows it.
1173 runWhen liberate_case (CoreDoPasses [
1175 simpl_phase 0 ["post-liberate-case"] max_iter
1176 ]), -- Run the simplifier after LiberateCase to vastly
1177 -- reduce the possiblility of shadowing
1178 -- Reason: see Note [Shadowing] in SpecConstr.lhs
1180 runWhen spec_constr CoreDoSpecConstr,
1184 -- Final clean-up simplification:
1185 simpl_phase 0 ["final"] max_iter
1188 -- -----------------------------------------------------------------------------
1189 -- StgToDo: abstraction of stg-to-stg passes to run.
1192 = StgDoMassageForProfiling -- should be (next to) last
1193 -- There's also setStgVarInfo, but its absolute "lastness"
1194 -- is so critical that it is hardwired in (no flag).
1197 getStgToDo :: DynFlags -> [StgToDo]
1199 | Just todo <- stgToDo dflags = todo -- set explicitly by user
1202 stg_stats = dopt Opt_StgStats dflags
1204 todo1 = if stg_stats then [D_stg_stats] else []
1206 todo2 | WayProf `elem` wayNames dflags
1207 = StgDoMassageForProfiling : todo1
1211 -- -----------------------------------------------------------------------------
1214 allFlags :: [String]
1215 allFlags = map ('-':) $
1216 [ flagName flag | flag <- dynamic_flags, ok (flagOptKind flag) ] ++
1217 map ("fno-"++) flags ++
1218 map ("f"++) flags ++
1219 map ("X"++) supportedLanguages ++
1220 map ("XNo"++) supportedLanguages
1221 where ok (PrefixPred _ _) = False
1223 flags = [ name | (name, _, _) <- fFlags ]
1225 dynamic_flags :: [Flag DynP]
1227 Flag "n" (NoArg (setDynFlag Opt_DryRun)) Supported
1228 , Flag "cpp" (NoArg (setDynFlag Opt_Cpp)) Supported
1229 , Flag "F" (NoArg (setDynFlag Opt_Pp)) Supported
1230 , Flag "#include" (HasArg (addCmdlineHCInclude)) Supported
1231 , Flag "v" (OptIntSuffix setVerbosity) Supported
1233 ------- Specific phases --------------------------------------------
1234 , Flag "pgmL" (HasArg (upd . setPgmL)) Supported
1235 , Flag "pgmP" (HasArg (upd . setPgmP)) Supported
1236 , Flag "pgmF" (HasArg (upd . setPgmF)) Supported
1237 , Flag "pgmc" (HasArg (upd . setPgmc)) Supported
1238 , Flag "pgmm" (HasArg (upd . setPgmm)) Supported
1239 , Flag "pgms" (HasArg (upd . setPgms)) Supported
1240 , Flag "pgma" (HasArg (upd . setPgma)) Supported
1241 , Flag "pgml" (HasArg (upd . setPgml)) Supported
1242 , Flag "pgmdll" (HasArg (upd . setPgmdll)) Supported
1243 , Flag "pgmwindres" (HasArg (upd . setPgmwindres)) Supported
1245 , Flag "optL" (HasArg (upd . addOptL)) Supported
1246 , Flag "optP" (HasArg (upd . addOptP)) Supported
1247 , Flag "optF" (HasArg (upd . addOptF)) Supported
1248 , Flag "optc" (HasArg (upd . addOptc)) Supported
1249 , Flag "optm" (HasArg (upd . addOptm)) Supported
1250 , Flag "opta" (HasArg (upd . addOpta)) Supported
1251 , Flag "optl" (HasArg (upd . addOptl)) Supported
1252 , Flag "optwindres" (HasArg (upd . addOptwindres)) Supported
1255 (NoArg (if can_split then setDynFlag Opt_SplitObjs else return ()))
1258 -------- ghc -M -----------------------------------------------------
1259 , Flag "dep-suffix" (HasArg (upd . addDepSuffix)) Supported
1260 , Flag "optdep-s" (HasArg (upd . addDepSuffix))
1261 (Deprecated "Use -dep-suffix instead")
1262 , Flag "dep-makefile" (HasArg (upd . setDepMakefile)) Supported
1263 , Flag "optdep-f" (HasArg (upd . setDepMakefile))
1264 (Deprecated "Use -dep-makefile instead")
1265 , Flag "optdep-w" (NoArg (return ()))
1266 (Deprecated "-optdep-w doesn't do anything")
1267 , Flag "include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True))) Supported
1268 , Flag "optdep--include-prelude" (NoArg (upd (setDepIncludePkgDeps True)))
1269 (Deprecated "Use -include-pkg-deps instead")
1270 , Flag "optdep--include-pkg-deps" (NoArg (upd (setDepIncludePkgDeps True)))
1271 (Deprecated "Use -include-pkg-deps instead")
1272 , Flag "exclude-module" (HasArg (upd . addDepExcludeMod)) Supported
1273 , Flag "optdep--exclude-module" (HasArg (upd . addDepExcludeMod))
1274 (Deprecated "Use -exclude-module instead")
1275 , Flag "optdep-x" (HasArg (upd . addDepExcludeMod))
1276 (Deprecated "Use -exclude-module instead")
1278 -------- Linking ----------------------------------------------------
1279 , Flag "c" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1281 , Flag "no-link" (NoArg (upd $ \d -> d{ ghcLink=NoLink } ))
1282 (Deprecated "Use -c instead")
1283 , Flag "shared" (NoArg (upd $ \d -> d{ ghcLink=LinkDynLib } ))
1285 , Flag "dynload" (HasArg (upd . parseDynLibLoaderMode))
1288 ------- Libraries ---------------------------------------------------
1289 , Flag "L" (Prefix addLibraryPath ) Supported
1290 , Flag "l" (AnySuffix (\s -> do upd (addOptl s))) Supported
1292 ------- Frameworks --------------------------------------------------
1293 -- -framework-path should really be -F ...
1294 , Flag "framework-path" (HasArg addFrameworkPath ) Supported
1295 , Flag "framework" (HasArg (upd . addCmdlineFramework)) Supported
1297 ------- Output Redirection ------------------------------------------
1298 , Flag "odir" (HasArg (upd . setObjectDir)) Supported
1299 , Flag "o" (SepArg (upd . setOutputFile . Just)) Supported
1300 , Flag "ohi" (HasArg (upd . setOutputHi . Just )) Supported
1301 , Flag "osuf" (HasArg (upd . setObjectSuf)) Supported
1302 , Flag "hcsuf" (HasArg (upd . setHcSuf)) Supported
1303 , Flag "hisuf" (HasArg (upd . setHiSuf)) Supported
1304 , Flag "hidir" (HasArg (upd . setHiDir)) Supported
1305 , Flag "tmpdir" (HasArg (upd . setTmpDir)) Supported
1306 , Flag "stubdir" (HasArg (upd . setStubDir)) Supported
1307 , Flag "outputdir" (HasArg (upd . setOutputDir)) Supported
1308 , Flag "ddump-file-prefix" (HasArg (upd . setDumpPrefixForce . Just))
1311 ------- Keeping temporary files -------------------------------------
1312 -- These can be singular (think ghc -c) or plural (think ghc --make)
1313 , Flag "keep-hc-file" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1314 , Flag "keep-hc-files" (NoArg (setDynFlag Opt_KeepHcFiles)) Supported
1315 , Flag "keep-s-file" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1316 , Flag "keep-s-files" (NoArg (setDynFlag Opt_KeepSFiles)) Supported
1317 , Flag "keep-raw-s-file" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1318 , Flag "keep-raw-s-files" (NoArg (setDynFlag Opt_KeepRawSFiles)) Supported
1319 -- This only makes sense as plural
1320 , Flag "keep-tmp-files" (NoArg (setDynFlag Opt_KeepTmpFiles)) Supported
1322 ------- Miscellaneous ----------------------------------------------
1323 , Flag "no-auto-link-packages" (NoArg (unSetDynFlag Opt_AutoLinkPackages)) Supported
1324 , Flag "no-hs-main" (NoArg (setDynFlag Opt_NoHsMain)) Supported
1325 , Flag "main-is" (SepArg setMainIs ) Supported
1326 , Flag "haddock" (NoArg (setDynFlag Opt_Haddock)) Supported
1327 , Flag "haddock-opts" (HasArg (upd . addHaddockOpts)) Supported
1328 , Flag "hpcdir" (SepArg setOptHpcDir) Supported
1330 ------- recompilation checker --------------------------------------
1331 , Flag "recomp" (NoArg (unSetDynFlag Opt_ForceRecomp))
1332 (Deprecated "Use -fno-force-recomp instead")
1333 , Flag "no-recomp" (NoArg (setDynFlag Opt_ForceRecomp))
1334 (Deprecated "Use -fforce-recomp instead")
1336 ------ HsCpp opts ---------------------------------------------------
1337 , Flag "D" (AnySuffix (upd . addOptP)) Supported
1338 , Flag "U" (AnySuffix (upd . addOptP)) Supported
1340 ------- Include/Import Paths ----------------------------------------
1341 , Flag "I" (Prefix addIncludePath) Supported
1342 , Flag "i" (OptPrefix addImportPath ) Supported
1344 ------ Debugging ----------------------------------------------------
1345 , Flag "dstg-stats" (NoArg (setDynFlag Opt_StgStats)) Supported
1347 , Flag "ddump-cmm" (setDumpFlag Opt_D_dump_cmm)
1349 , Flag "ddump-cmmz" (setDumpFlag Opt_D_dump_cmmz)
1351 , Flag "ddump-cmmz-pretty" (setDumpFlag Opt_D_dump_cmmz_pretty)
1353 , Flag "ddump-cps-cmm" (setDumpFlag Opt_D_dump_cps_cmm)
1355 , Flag "ddump-cvt-cmm" (setDumpFlag Opt_D_dump_cvt_cmm)
1357 , Flag "ddump-asm" (setDumpFlag Opt_D_dump_asm)
1359 , Flag "ddump-asm-native" (setDumpFlag Opt_D_dump_asm_native)
1361 , Flag "ddump-asm-liveness" (setDumpFlag Opt_D_dump_asm_liveness)
1363 , Flag "ddump-asm-coalesce" (setDumpFlag Opt_D_dump_asm_coalesce)
1365 , Flag "ddump-asm-regalloc" (setDumpFlag Opt_D_dump_asm_regalloc)
1367 , Flag "ddump-asm-conflicts" (setDumpFlag Opt_D_dump_asm_conflicts)
1369 , Flag "ddump-asm-regalloc-stages"
1370 (setDumpFlag Opt_D_dump_asm_regalloc_stages)
1372 , Flag "ddump-asm-stats" (setDumpFlag Opt_D_dump_asm_stats)
1374 , Flag "ddump-asm-expanded" (setDumpFlag Opt_D_dump_asm_expanded)
1376 , Flag "ddump-cpranal" (setDumpFlag Opt_D_dump_cpranal)
1378 , Flag "ddump-deriv" (setDumpFlag Opt_D_dump_deriv)
1380 , Flag "ddump-ds" (setDumpFlag Opt_D_dump_ds)
1382 , Flag "ddump-flatC" (setDumpFlag Opt_D_dump_flatC)
1384 , Flag "ddump-foreign" (setDumpFlag Opt_D_dump_foreign)
1386 , Flag "ddump-inlinings" (setDumpFlag Opt_D_dump_inlinings)
1388 , Flag "ddump-rule-firings" (setDumpFlag Opt_D_dump_rule_firings)
1390 , Flag "ddump-occur-anal" (setDumpFlag Opt_D_dump_occur_anal)
1392 , Flag "ddump-parsed" (setDumpFlag Opt_D_dump_parsed)
1394 , Flag "ddump-rn" (setDumpFlag Opt_D_dump_rn)
1396 , Flag "ddump-simpl" (setDumpFlag Opt_D_dump_simpl)
1398 , Flag "ddump-simpl-iterations" (setDumpFlag Opt_D_dump_simpl_iterations)
1400 , Flag "ddump-simpl-phases" (OptPrefix setDumpSimplPhases)
1402 , Flag "ddump-spec" (setDumpFlag Opt_D_dump_spec)
1404 , Flag "ddump-prep" (setDumpFlag Opt_D_dump_prep)
1406 , Flag "ddump-stg" (setDumpFlag Opt_D_dump_stg)
1408 , Flag "ddump-stranal" (setDumpFlag Opt_D_dump_stranal)
1410 , Flag "ddump-tc" (setDumpFlag Opt_D_dump_tc)
1412 , Flag "ddump-types" (setDumpFlag Opt_D_dump_types)
1414 , Flag "ddump-rules" (setDumpFlag Opt_D_dump_rules)
1416 , Flag "ddump-cse" (setDumpFlag Opt_D_dump_cse)
1418 , Flag "ddump-worker-wrapper" (setDumpFlag Opt_D_dump_worker_wrapper)
1420 , Flag "ddump-rn-trace" (setDumpFlag Opt_D_dump_rn_trace)
1422 , Flag "ddump-if-trace" (setDumpFlag Opt_D_dump_if_trace)
1424 , Flag "ddump-tc-trace" (setDumpFlag Opt_D_dump_tc_trace)
1426 , Flag "ddump-splices" (setDumpFlag Opt_D_dump_splices)
1428 , Flag "ddump-rn-stats" (setDumpFlag Opt_D_dump_rn_stats)
1430 , Flag "ddump-opt-cmm" (setDumpFlag Opt_D_dump_opt_cmm)
1432 , Flag "ddump-simpl-stats" (setDumpFlag Opt_D_dump_simpl_stats)
1434 , Flag "ddump-bcos" (setDumpFlag Opt_D_dump_BCOs)
1436 , Flag "dsource-stats" (setDumpFlag Opt_D_source_stats)
1438 , Flag "dverbose-core2core" (NoArg setVerboseCore2Core)
1440 , Flag "dverbose-stg2stg" (setDumpFlag Opt_D_verbose_stg2stg)
1442 , Flag "ddump-hi" (setDumpFlag Opt_D_dump_hi)
1444 , Flag "ddump-minimal-imports" (setDumpFlag Opt_D_dump_minimal_imports)
1446 , Flag "ddump-vect" (setDumpFlag Opt_D_dump_vect)
1448 , Flag "ddump-hpc" (setDumpFlag Opt_D_dump_hpc)
1450 , Flag "ddump-mod-cycles" (setDumpFlag Opt_D_dump_mod_cycles)
1452 , Flag "ddump-view-pattern-commoning" (setDumpFlag Opt_D_dump_view_pattern_commoning)
1454 , Flag "ddump-to-file" (setDumpFlag Opt_DumpToFile)
1456 , Flag "ddump-hi-diffs" (setDumpFlag Opt_D_dump_hi_diffs)
1458 , Flag "ddump-rtti" (setDumpFlag Opt_D_dump_rtti)
1461 , Flag "dcore-lint" (NoArg (setDynFlag Opt_DoCoreLinting))
1463 , Flag "dstg-lint" (NoArg (setDynFlag Opt_DoStgLinting))
1465 , Flag "dcmm-lint" (NoArg (setDynFlag Opt_DoCmmLinting))
1467 , Flag "dasm-lint" (NoArg (setDynFlag Opt_DoAsmLinting))
1469 , Flag "dshow-passes"
1470 (NoArg (do forceRecompile
1471 setVerbosity (Just 2)))
1473 , Flag "dfaststring-stats" (NoArg (setDynFlag Opt_D_faststring_stats))
1476 ------ Machine dependant (-m<blah>) stuff ---------------------------
1478 , Flag "monly-2-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 2}) ))
1480 , Flag "monly-3-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 3}) ))
1482 , Flag "monly-4-regs" (NoArg (upd (\s -> s{stolen_x86_regs = 4}) ))
1485 ------ Warning opts -------------------------------------------------
1486 , Flag "W" (NoArg (mapM_ setDynFlag minusWOpts))
1488 , Flag "Werror" (NoArg (setDynFlag Opt_WarnIsError))
1490 , Flag "Wwarn" (NoArg (unSetDynFlag Opt_WarnIsError))
1492 , Flag "Wall" (NoArg (mapM_ setDynFlag minusWallOpts))
1494 , Flag "Wnot" (NoArg (mapM_ unSetDynFlag minusWallOpts))
1495 (Deprecated "Use -w instead")
1496 , Flag "w" (NoArg (mapM_ unSetDynFlag minuswRemovesOpts))
1499 ------ Optimisation flags ------------------------------------------
1500 , Flag "O" (NoArg (upd (setOptLevel 1))) Supported
1501 , Flag "Onot" (NoArg (upd (setOptLevel 0)))
1502 (Deprecated "Use -O0 instead")
1503 , Flag "Odph" (NoArg (upd setDPHOpt)) Supported
1504 , Flag "O" (OptIntSuffix (\mb_n -> upd (setOptLevel (mb_n `orElse` 1))))
1506 -- If the number is missing, use 1
1508 , Flag "fsimplifier-phases"
1509 (IntSuffix (\n -> upd (\dfs -> dfs{ simplPhases = n })))
1511 , Flag "fmax-simplifier-iterations"
1512 (IntSuffix (\n -> upd (\dfs -> dfs{ maxSimplIterations = n })))
1515 , Flag "fspec-constr-threshold"
1516 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrThreshold = Just n })))
1518 , Flag "fno-spec-constr-threshold"
1519 (NoArg (upd (\dfs -> dfs{ specConstrThreshold = Nothing })))
1521 , Flag "fspec-constr-count"
1522 (IntSuffix (\n -> upd (\dfs -> dfs{ specConstrCount = Just n })))
1524 , Flag "fno-spec-constr-count"
1525 (NoArg (upd (\dfs -> dfs{ specConstrCount = Nothing })))
1527 , Flag "fliberate-case-threshold"
1528 (IntSuffix (\n -> upd (\dfs -> dfs{ liberateCaseThreshold = Just n })))
1530 , Flag "fno-liberate-case-threshold"
1531 (NoArg (upd (\dfs -> dfs{ liberateCaseThreshold = Nothing })))
1534 , Flag "frule-check"
1535 (SepArg (\s -> upd (\dfs -> dfs{ ruleCheck = Just s })))
1537 , Flag "fcontext-stack"
1538 (IntSuffix $ \n -> upd $ \dfs -> dfs{ ctxtStkDepth = n })
1541 ------ Profiling ----------------------------------------------------
1543 -- XXX Should the -f* flags be deprecated?
1544 -- They don't seem to be documented
1545 , Flag "fauto-sccs-on-all-toplevs"
1546 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1549 (NoArg (setDynFlag Opt_AutoSccsOnAllToplevs))
1551 , Flag "no-auto-all"
1552 (NoArg (unSetDynFlag Opt_AutoSccsOnAllToplevs))
1554 , Flag "fauto-sccs-on-exported-toplevs"
1555 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1558 (NoArg (setDynFlag Opt_AutoSccsOnExportedToplevs))
1561 (NoArg (unSetDynFlag Opt_AutoSccsOnExportedToplevs))
1563 , Flag "fauto-sccs-on-individual-cafs"
1564 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1567 (NoArg (setDynFlag Opt_AutoSccsOnIndividualCafs))
1570 (NoArg (unSetDynFlag Opt_AutoSccsOnIndividualCafs))
1573 ------ DPH flags ----------------------------------------------------
1576 (NoArg (setDPHBackend DPHSeq))
1579 (NoArg (setDPHBackend DPHPar))
1582 (NoArg (setDPHBackend DPHThis))
1585 ------ Compiler flags -----------------------------------------------
1587 , Flag "fasm" (NoArg (setObjTarget HscAsm)) Supported
1588 , Flag "fvia-c" (NoArg (setObjTarget HscC)) Supported
1589 , Flag "fvia-C" (NoArg (setObjTarget HscC)) Supported
1591 , Flag "fno-code" (NoArg (setTarget HscNothing)) Supported
1592 , Flag "fbyte-code" (NoArg (setTarget HscInterpreted)) Supported
1593 , Flag "fobject-code" (NoArg (setTarget defaultHscTarget)) Supported
1595 , Flag "fglasgow-exts" (NoArg (mapM_ setDynFlag glasgowExtsFlags))
1597 , Flag "fno-glasgow-exts" (NoArg (mapM_ unSetDynFlag glasgowExtsFlags))
1600 ++ map (mkFlag True "f" setDynFlag ) fFlags
1601 ++ map (mkFlag False "fno-" unSetDynFlag) fFlags
1602 ++ map (mkFlag True "X" setDynFlag ) xFlags
1603 ++ map (mkFlag False "XNo" unSetDynFlag) xFlags
1605 package_flags :: [Flag DynP]
1607 ------- Packages ----------------------------------------------------
1608 Flag "package-conf" (HasArg extraPkgConf_) Supported
1609 , Flag "no-user-package-conf" (NoArg (unSetDynFlag Opt_ReadUserPackageConf))
1611 , Flag "package-name" (HasArg (upd . setPackageName)) Supported
1612 , Flag "package" (HasArg exposePackage) Supported
1613 , Flag "hide-package" (HasArg hidePackage) Supported
1614 , Flag "hide-all-packages" (NoArg (setDynFlag Opt_HideAllPackages))
1616 , Flag "ignore-package" (HasArg ignorePackage)
1618 , Flag "syslib" (HasArg exposePackage)
1619 (Deprecated "Use -package instead")
1622 mkFlag :: Bool -- ^ True <=> it should be turned on
1623 -> String -- ^ The flag prefix
1624 -> (DynFlag -> DynP ())
1625 -> (String, DynFlag, Bool -> Deprecated)
1627 mkFlag turnOn flagPrefix f (name, dynflag, deprecated)
1628 = Flag (flagPrefix ++ name) (NoArg (f dynflag)) (deprecated turnOn)
1630 deprecatedForLanguage :: String -> Bool -> Deprecated
1631 deprecatedForLanguage lang turn_on
1632 = Deprecated ("use -X" ++ flag ++ " or pragma {-# LANGUAGE " ++ flag ++ "#-} instead")
1634 flag | turn_on = lang
1635 | otherwise = "No"++lang
1637 useInstead :: String -> Bool -> Deprecated
1638 useInstead flag turn_on
1639 = Deprecated ("Use -f" ++ no ++ flag ++ " instead")
1641 no = if turn_on then "" else "no-"
1643 -- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
1644 fFlags :: [(String, DynFlag, Bool -> Deprecated)]
1646 ( "warn-dodgy-foreign-imports", Opt_WarnDodgyForeignImports, const Supported ),
1647 ( "warn-dodgy-imports", Opt_WarnDodgyImports, const Supported ),
1648 ( "warn-duplicate-exports", Opt_WarnDuplicateExports, const Supported ),
1649 ( "warn-hi-shadowing", Opt_WarnHiShadows, const Supported ),
1650 ( "warn-implicit-prelude", Opt_WarnImplicitPrelude, const Supported ),
1651 ( "warn-incomplete-patterns", Opt_WarnIncompletePatterns, const Supported ),
1652 ( "warn-incomplete-record-updates", Opt_WarnIncompletePatternsRecUpd, const Supported ),
1653 ( "warn-missing-fields", Opt_WarnMissingFields, const Supported ),
1654 ( "warn-missing-methods", Opt_WarnMissingMethods, const Supported ),
1655 ( "warn-missing-signatures", Opt_WarnMissingSigs, const Supported ),
1656 ( "warn-name-shadowing", Opt_WarnNameShadowing, const Supported ),
1657 ( "warn-overlapping-patterns", Opt_WarnOverlappingPatterns, const Supported ),
1658 ( "warn-simple-patterns", Opt_WarnSimplePatterns, const Supported ),
1659 ( "warn-type-defaults", Opt_WarnTypeDefaults, const Supported ),
1660 ( "warn-monomorphism-restriction", Opt_WarnMonomorphism, const Supported ),
1661 ( "warn-unused-binds", Opt_WarnUnusedBinds, const Supported ),
1662 ( "warn-unused-imports", Opt_WarnUnusedImports, const Supported ),
1663 ( "warn-unused-matches", Opt_WarnUnusedMatches, const Supported ),
1664 ( "warn-warnings-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1665 ( "warn-deprecations", Opt_WarnWarningsDeprecations, const Supported ),
1666 ( "warn-deprecated-flags", Opt_WarnDeprecatedFlags, const Supported ),
1667 ( "warn-orphans", Opt_WarnOrphans, const Supported ),
1668 ( "warn-tabs", Opt_WarnTabs, const Supported ),
1669 ( "warn-unrecognised-pragmas", Opt_WarnUnrecognisedPragmas, const Supported ),
1670 ( "warn-lazy-unlifted-bindings", Opt_WarnLazyUnliftedBindings,
1671 const $ Deprecated "lazy unlifted bindings will be an error in GHC 6.14, and this flag will no longer exist"),
1672 ( "warn-unused-do-bind", Opt_WarnUnusedDoBind, const Supported ),
1673 ( "warn-wrong-do-bind", Opt_WarnWrongDoBind, const Supported ),
1674 ( "print-explicit-foralls", Opt_PrintExplicitForalls, const Supported ),
1675 ( "strictness", Opt_Strictness, const Supported ),
1676 ( "static-argument-transformation", Opt_StaticArgumentTransformation, const Supported ),
1677 ( "full-laziness", Opt_FullLaziness, const Supported ),
1678 ( "liberate-case", Opt_LiberateCase, const Supported ),
1679 ( "spec-constr", Opt_SpecConstr, const Supported ),
1680 ( "cse", Opt_CSE, const Supported ),
1681 ( "ignore-interface-pragmas", Opt_IgnoreInterfacePragmas, const Supported ),
1682 ( "omit-interface-pragmas", Opt_OmitInterfacePragmas, const Supported ),
1683 ( "do-lambda-eta-expansion", Opt_DoLambdaEtaExpansion, const Supported ),
1684 ( "ignore-asserts", Opt_IgnoreAsserts, const Supported ),
1685 ( "do-eta-reduction", Opt_DoEtaReduction, const Supported ),
1686 ( "case-merge", Opt_CaseMerge, const Supported ),
1687 ( "unbox-strict-fields", Opt_UnboxStrictFields, const Supported ),
1688 ( "method-sharing", Opt_MethodSharing, const Supported ),
1689 ( "dicts-cheap", Opt_DictsCheap, const Supported ),
1690 ( "inline-if-enough-args", Opt_InlineIfEnoughArgs, const Supported ),
1691 ( "excess-precision", Opt_ExcessPrecision, const Supported ),
1692 ( "eager-blackholing", Opt_EagerBlackHoling, const Supported ),
1693 ( "asm-mangling", Opt_DoAsmMangling, const Supported ),
1694 ( "print-bind-result", Opt_PrintBindResult, const Supported ),
1695 ( "force-recomp", Opt_ForceRecomp, const Supported ),
1696 ( "hpc-no-auto", Opt_Hpc_No_Auto, const Supported ),
1697 ( "rewrite-rules", Opt_EnableRewriteRules, useInstead "enable-rewrite-rules" ),
1698 ( "enable-rewrite-rules", Opt_EnableRewriteRules, const Supported ),
1699 ( "break-on-exception", Opt_BreakOnException, const Supported ),
1700 ( "break-on-error", Opt_BreakOnError, const Supported ),
1701 ( "print-evld-with-show", Opt_PrintEvldWithShow, const Supported ),
1702 ( "print-bind-contents", Opt_PrintBindContents, const Supported ),
1703 ( "run-cps", Opt_RunCPS, const Supported ),
1704 ( "run-cpsz", Opt_RunCPSZ, const Supported ),
1705 ( "new-codegen", Opt_TryNewCodeGen, const Supported ),
1706 ( "convert-to-zipper-and-back", Opt_ConvertToZipCfgAndBack, const Supported ),
1707 ( "vectorise", Opt_Vectorise, const Supported ),
1708 ( "regs-graph", Opt_RegsGraph, const Supported ),
1709 ( "regs-iterative", Opt_RegsIterative, const Supported ),
1710 ( "th", Opt_TemplateHaskell,
1711 deprecatedForLanguage "TemplateHaskell" ),
1712 ( "fi", Opt_ForeignFunctionInterface,
1713 deprecatedForLanguage "ForeignFunctionInterface" ),
1714 ( "ffi", Opt_ForeignFunctionInterface,
1715 deprecatedForLanguage "ForeignFunctionInterface" ),
1716 ( "arrows", Opt_Arrows,
1717 deprecatedForLanguage "Arrows" ),
1718 ( "generics", Opt_Generics,
1719 deprecatedForLanguage "Generics" ),
1720 ( "implicit-prelude", Opt_ImplicitPrelude,
1721 deprecatedForLanguage "ImplicitPrelude" ),
1722 ( "bang-patterns", Opt_BangPatterns,
1723 deprecatedForLanguage "BangPatterns" ),
1724 ( "monomorphism-restriction", Opt_MonomorphismRestriction,
1725 deprecatedForLanguage "MonomorphismRestriction" ),
1726 ( "mono-pat-binds", Opt_MonoPatBinds,
1727 deprecatedForLanguage "MonoPatBinds" ),
1728 ( "extended-default-rules", Opt_ExtendedDefaultRules,
1729 deprecatedForLanguage "ExtendedDefaultRules" ),
1730 ( "implicit-params", Opt_ImplicitParams,
1731 deprecatedForLanguage "ImplicitParams" ),
1732 ( "scoped-type-variables", Opt_ScopedTypeVariables,
1733 deprecatedForLanguage "ScopedTypeVariables" ),
1735 deprecatedForLanguage "PArr" ),
1736 ( "allow-overlapping-instances", Opt_OverlappingInstances,
1737 deprecatedForLanguage "OverlappingInstances" ),
1738 ( "allow-undecidable-instances", Opt_UndecidableInstances,
1739 deprecatedForLanguage "UndecidableInstances" ),
1740 ( "allow-incoherent-instances", Opt_IncoherentInstances,
1741 deprecatedForLanguage "IncoherentInstances" ),
1742 ( "gen-manifest", Opt_GenManifest, const Supported ),
1743 ( "embed-manifest", Opt_EmbedManifest, const Supported ),
1744 ( "ext-core", Opt_EmitExternalCore, const Supported ),
1745 ( "implicit-import-qualified", Opt_ImplicitImportQualified, const Supported )
1748 supportedLanguages :: [String]
1749 supportedLanguages = [ name | (name, _, _) <- xFlags ]
1751 -- This may contain duplicates
1752 languageOptions :: [DynFlag]
1753 languageOptions = [ dynFlag | (_, dynFlag, _) <- xFlags ]
1755 -- | These -X<blah> flags can all be reversed with -XNo<blah>
1756 xFlags :: [(String, DynFlag, Bool -> Deprecated)]
1758 ( "CPP", Opt_Cpp, const Supported ),
1759 ( "PostfixOperators", Opt_PostfixOperators, const Supported ),
1760 ( "PatternGuards", Opt_PatternGuards, const Supported ),
1761 ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ),
1762 ( "MagicHash", Opt_MagicHash, const Supported ),
1763 ( "PolymorphicComponents", Opt_PolymorphicComponents, const Supported ),
1764 ( "ExistentialQuantification", Opt_ExistentialQuantification, const Supported ),
1765 ( "KindSignatures", Opt_KindSignatures, const Supported ),
1766 ( "EmptyDataDecls", Opt_EmptyDataDecls, const Supported ),
1767 ( "ParallelListComp", Opt_ParallelListComp, const Supported ),
1768 ( "TransformListComp", Opt_TransformListComp, const Supported ),
1769 ( "ForeignFunctionInterface", Opt_ForeignFunctionInterface, const Supported ),
1770 ( "UnliftedFFITypes", Opt_UnliftedFFITypes, const Supported ),
1771 ( "GHCForeignImportPrim", Opt_GHCForeignImportPrim, const Supported ),
1772 ( "LiberalTypeSynonyms", Opt_LiberalTypeSynonyms, const Supported ),
1773 ( "Rank2Types", Opt_Rank2Types, const Supported ),
1774 ( "RankNTypes", Opt_RankNTypes, const Supported ),
1775 ( "ImpredicativeTypes", Opt_ImpredicativeTypes, const Supported ),
1776 ( "TypeOperators", Opt_TypeOperators, const Supported ),
1777 ( "RecursiveDo", Opt_RecursiveDo, const Supported ),
1778 ( "Arrows", Opt_Arrows, const Supported ),
1779 ( "PArr", Opt_PArr, const Supported ),
1780 ( "TemplateHaskell", Opt_TemplateHaskell, const Supported ),
1781 ( "QuasiQuotes", Opt_QuasiQuotes, const Supported ),
1782 ( "Generics", Opt_Generics, const Supported ),
1784 ( "ImplicitPrelude", Opt_ImplicitPrelude, const Supported ),
1785 ( "RecordWildCards", Opt_RecordWildCards, const Supported ),
1786 ( "NamedFieldPuns", Opt_RecordPuns, const Supported ),
1787 ( "RecordPuns", Opt_RecordPuns,
1788 deprecatedForLanguage "NamedFieldPuns" ),
1789 ( "DisambiguateRecordFields", Opt_DisambiguateRecordFields, const Supported ),
1790 ( "OverloadedStrings", Opt_OverloadedStrings, const Supported ),
1791 ( "GADTs", Opt_GADTs, const Supported ),
1792 ( "ViewPatterns", Opt_ViewPatterns, const Supported ),
1793 ( "TypeFamilies", Opt_TypeFamilies, const Supported ),
1794 ( "BangPatterns", Opt_BangPatterns, const Supported ),
1796 ( "MonomorphismRestriction", Opt_MonomorphismRestriction, const Supported ),
1797 -- On by default (which is not strictly H98):
1798 ( "MonoPatBinds", Opt_MonoPatBinds, const Supported ),
1799 ( "MonoLocalBinds", Opt_MonoLocalBinds, const Supported ),
1800 ( "RelaxedPolyRec", Opt_RelaxedPolyRec, const Supported ),
1801 ( "ExtendedDefaultRules", Opt_ExtendedDefaultRules, const Supported ),
1802 ( "ImplicitParams", Opt_ImplicitParams, const Supported ),
1803 ( "ScopedTypeVariables", Opt_ScopedTypeVariables, const Supported ),
1805 ( "PatternSignatures", Opt_ScopedTypeVariables,
1806 deprecatedForLanguage "ScopedTypeVariables" ),
1808 ( "UnboxedTuples", Opt_UnboxedTuples, const Supported ),
1809 ( "StandaloneDeriving", Opt_StandaloneDeriving, const Supported ),
1810 ( "DeriveDataTypeable", Opt_DeriveDataTypeable, const Supported ),
1811 ( "DeriveFunctor", Opt_DeriveFunctor, const Supported ),
1812 ( "DeriveTraversable", Opt_DeriveTraversable, const Supported ),
1813 ( "DeriveFoldable", Opt_DeriveFoldable, const Supported ),
1814 ( "TypeSynonymInstances", Opt_TypeSynonymInstances, const Supported ),
1815 ( "FlexibleContexts", Opt_FlexibleContexts, const Supported ),
1816 ( "FlexibleInstances", Opt_FlexibleInstances, const Supported ),
1817 ( "ConstrainedClassMethods", Opt_ConstrainedClassMethods, const Supported ),
1818 ( "MultiParamTypeClasses", Opt_MultiParamTypeClasses, const Supported ),
1819 ( "FunctionalDependencies", Opt_FunctionalDependencies, const Supported ),
1820 ( "GeneralizedNewtypeDeriving", Opt_GeneralizedNewtypeDeriving, const Supported ),
1821 ( "OverlappingInstances", Opt_OverlappingInstances, const Supported ),
1822 ( "UndecidableInstances", Opt_UndecidableInstances, const Supported ),
1823 ( "IncoherentInstances", Opt_IncoherentInstances, const Supported ),
1824 ( "PackageImports", Opt_PackageImports, const Supported ),
1825 ( "NewQualifiedOperators", Opt_NewQualifiedOperators, const Supported )
1828 impliedFlags :: [(DynFlag, DynFlag)]
1830 = [ (Opt_GADTs, Opt_RelaxedPolyRec) -- We want type-sig variables to
1831 -- be completely rigid for GADTs
1833 , (Opt_TypeFamilies, Opt_RelaxedPolyRec) -- Trac #2944 gives a nice example
1834 , (Opt_TypeFamilies, Opt_KindSignatures) -- Type families use kind signatures
1835 -- all over the place
1837 , (Opt_ScopedTypeVariables, Opt_RelaxedPolyRec) -- Ditto for scoped type variables; see
1838 -- Note [Scoped tyvars] in TcBinds
1839 , (Opt_ImpredicativeTypes, Opt_RankNTypes)
1842 glasgowExtsFlags :: [DynFlag]
1843 glasgowExtsFlags = [
1844 Opt_PrintExplicitForalls
1845 , Opt_ForeignFunctionInterface
1846 , Opt_UnliftedFFITypes
1848 , Opt_ImplicitParams
1849 , Opt_ScopedTypeVariables
1851 , Opt_TypeSynonymInstances
1852 , Opt_StandaloneDeriving
1853 , Opt_DeriveDataTypeable
1855 , Opt_DeriveFoldable
1856 , Opt_DeriveTraversable
1857 , Opt_FlexibleContexts
1858 , Opt_FlexibleInstances
1859 , Opt_ConstrainedClassMethods
1860 , Opt_MultiParamTypeClasses
1861 , Opt_FunctionalDependencies
1863 , Opt_PolymorphicComponents
1864 , Opt_ExistentialQuantification
1866 , Opt_PostfixOperators
1868 , Opt_LiberalTypeSynonyms
1872 , Opt_ParallelListComp
1873 , Opt_EmptyDataDecls
1874 , Opt_KindSignatures
1875 , Opt_GeneralizedNewtypeDeriving
1876 , Opt_TypeFamilies ]
1878 -- -----------------------------------------------------------------------------
1879 -- Parsing the dynamic flags.
1881 -- | Parse dynamic flags from a list of command line arguments. Returns the
1882 -- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
1883 -- Throws a 'UsageError' if errors occurred during parsing (such as unknown
1884 -- flags or missing arguments).
1885 parseDynamicFlags :: Monad m =>
1886 DynFlags -> [Located String]
1887 -> m (DynFlags, [Located String], [Located String])
1888 -- ^ Updated 'DynFlags', left-over arguments, and
1889 -- list of warnings.
1890 parseDynamicFlags dflags args = parseDynamicFlags_ dflags args True
1892 -- | Like 'parseDynamicFlags' but does not allow the package flags (-package,
1893 -- -hide-package, -ignore-package, -hide-all-packages, -package-conf).
1894 parseDynamicNoPackageFlags :: Monad m =>
1895 DynFlags -> [Located String]
1896 -> m (DynFlags, [Located String], [Located String])
1897 -- ^ Updated 'DynFlags', left-over arguments, and
1898 -- list of warnings.
1899 parseDynamicNoPackageFlags dflags args = parseDynamicFlags_ dflags args False
1901 parseDynamicFlags_ :: Monad m =>
1902 DynFlags -> [Located String] -> Bool
1903 -> m (DynFlags, [Located String], [Located String])
1904 parseDynamicFlags_ dflags args pkg_flags = do
1905 -- XXX Legacy support code
1906 -- We used to accept things like
1907 -- optdep-f -optdepdepend
1908 -- optdep-f -optdep depend
1909 -- optdep -f -optdepdepend
1910 -- optdep -f -optdep depend
1911 -- but the spaces trip up proper argument handling. So get rid of them.
1912 let f (L p "-optdep" : L _ x : xs) = (L p ("-optdep" ++ x)) : f xs
1913 f (x : xs) = x : f xs
1917 -- Note: -ignore-package (package_flags) must precede -i* (dynamic_flags)
1918 flag_spec | pkg_flags = package_flags ++ dynamic_flags
1919 | otherwise = dynamic_flags
1921 let ((leftover, errs, warns), dflags')
1922 = runCmdLine (processArgs flag_spec args') dflags
1923 when (not (null errs)) $ ghcError $ errorsToGhcException errs
1924 return (dflags', leftover, warns)
1926 type DynP = CmdLineP DynFlags
1928 upd :: (DynFlags -> DynFlags) -> DynP ()
1930 dfs <- getCmdLineState
1931 putCmdLineState $! (f dfs)
1933 --------------------------
1934 setDynFlag, unSetDynFlag :: DynFlag -> DynP ()
1935 setDynFlag f = do { upd (\dfs -> dopt_set dfs f)
1936 ; mapM_ setDynFlag deps }
1938 deps = [ d | (f', d) <- impliedFlags, f' == f ]
1939 -- When you set f, set the ones it implies
1940 -- NB: use setDynFlag recursively, in case the implied flags
1941 -- implies further flags
1942 -- When you un-set f, however, we don't un-set the things it implies
1943 -- (except for -fno-glasgow-exts, which is treated specially)
1945 unSetDynFlag f = upd (\dfs -> dopt_unset dfs f)
1947 --------------------------
1948 setDumpFlag :: DynFlag -> OptKind DynP
1949 setDumpFlag dump_flag
1950 = NoArg (setDynFlag dump_flag >> when want_recomp forceRecompile)
1952 -- Certain dumpy-things are really interested in what's going
1953 -- on during recompilation checking, so in those cases we
1954 -- don't want to turn it off.
1955 want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,
1956 Opt_D_dump_hi_diffs]
1958 forceRecompile :: DynP ()
1959 -- Whenver we -ddump, force recompilation (by switching off the
1960 -- recompilation checker), else you don't see the dump! However,
1961 -- don't switch it off in --make mode, else *everything* gets
1962 -- recompiled which probably isn't what you want
1963 forceRecompile = do { dfs <- getCmdLineState
1964 ; when (force_recomp dfs) (setDynFlag Opt_ForceRecomp) }
1966 force_recomp dfs = isOneShot (ghcMode dfs)
1968 setVerboseCore2Core :: DynP ()
1969 setVerboseCore2Core = do setDynFlag Opt_D_verbose_core2core
1971 upd (\s -> s { shouldDumpSimplPhase = const True })
1973 setDumpSimplPhases :: String -> DynP ()
1974 setDumpSimplPhases s = do forceRecompile
1975 upd (\s -> s { shouldDumpSimplPhase = spec })
1977 spec :: SimplifierMode -> Bool
1979 . map (join (&&) . map match . split ':')
1985 join :: (Bool -> Bool -> Bool)
1986 -> [SimplifierMode -> Bool]
1987 -> SimplifierMode -> Bool
1988 join _ [] = const True
1989 join op ss = foldr1 (\f g x -> f x `op` g x) ss
1991 match :: String -> SimplifierMode -> Bool
1992 match "" = const True
1993 match s = case reads s of
1994 [(n,"")] -> phase_num n
1997 phase_num :: Int -> SimplifierMode -> Bool
1998 phase_num n (SimplPhase k _) = n == k
1999 phase_num _ _ = False
2001 phase_name :: String -> SimplifierMode -> Bool
2002 phase_name s SimplGently = s == "gentle"
2003 phase_name s (SimplPhase _ ss) = s `elem` ss
2005 setVerbosity :: Maybe Int -> DynP ()
2006 setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })
2008 addCmdlineHCInclude :: String -> DynP ()
2009 addCmdlineHCInclude a = upd (\s -> s{cmdlineHcIncludes = a : cmdlineHcIncludes s})
2011 extraPkgConf_ :: FilePath -> DynP ()
2012 extraPkgConf_ p = upd (\s -> s{ extraPkgConfs = p : extraPkgConfs s })
2014 exposePackage, hidePackage, ignorePackage :: String -> DynP ()
2016 upd (\s -> s{ packageFlags = ExposePackage p : packageFlags s })
2018 upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })
2020 upd (\s -> s{ packageFlags = IgnorePackage p : packageFlags s })
2022 setPackageName :: String -> DynFlags -> DynFlags
2024 | Nothing <- unpackPackageId pid
2025 = ghcError (CmdLineError ("cannot parse \'" ++ p ++ "\' as a package identifier"))
2027 = \s -> s{ thisPackage = pid }
2029 pid = stringToPackageId p
2031 -- If we're linking a binary, then only targets that produce object
2032 -- code are allowed (requests for other target types are ignored).
2033 setTarget :: HscTarget -> DynP ()
2034 setTarget l = upd set
2037 | ghcLink dfs /= LinkBinary || isObjectTarget l = dfs{ hscTarget = l }
2040 -- Changes the target only if we're compiling object code. This is
2041 -- used by -fasm and -fvia-C, which switch from one to the other, but
2042 -- not from bytecode to object-code. The idea is that -fasm/-fvia-C
2043 -- can be safely used in an OPTIONS_GHC pragma.
2044 setObjTarget :: HscTarget -> DynP ()
2045 setObjTarget l = upd set
2048 | isObjectTarget (hscTarget dfs) = dfs { hscTarget = l }
2051 setOptLevel :: Int -> DynFlags -> DynFlags
2052 setOptLevel n dflags
2053 | hscTarget dflags == HscInterpreted && n > 0
2055 -- not in IO any more, oh well:
2056 -- putStr "warning: -O conflicts with --interactive; -O ignored.\n"
2058 = updOptLevel n dflags
2061 -- -Odph is equivalent to
2063 -- -O2 optimise as much as possible
2064 -- -fno-method-sharing sharing specialisation defeats fusion
2066 -- -fdicts-cheap always inline dictionaries
2067 -- -fmax-simplifier-iterations20 this is necessary sometimes
2068 -- -fsimplifier-phases=3 we use an additional simplifier phase
2070 -- -fno-spec-constr-threshold run SpecConstr even for big loops
2071 -- -fno-spec-constr-count SpecConstr as much as possible
2072 -- -finline-enough-args hack to prevent excessive inlining
2074 setDPHOpt :: DynFlags -> DynFlags
2075 setDPHOpt dflags = setOptLevel 2 (dflags { maxSimplIterations = 20
2077 , specConstrThreshold = Nothing
2078 , specConstrCount = Nothing
2080 `dopt_set` Opt_DictsCheap
2081 `dopt_unset` Opt_MethodSharing
2082 `dopt_set` Opt_InlineIfEnoughArgs
2084 data DPHBackend = DPHPar
2087 deriving(Eq, Ord, Enum, Show)
2089 setDPHBackend :: DPHBackend -> DynP ()
2090 setDPHBackend backend
2092 upd $ \dflags -> dflags { dphBackend = backend }
2093 mapM_ exposePackage (dph_packages backend)
2095 dph_packages DPHThis = []
2096 dph_packages DPHPar = ["dph-prim-par", "dph-par"]
2097 dph_packages DPHSeq = ["dph-prim-seq", "dph-seq"]
2099 dphPackage :: DynFlags -> PackageId
2100 dphPackage dflags = case dphBackend dflags of
2101 DPHPar -> dphParPackageId
2102 DPHSeq -> dphSeqPackageId
2103 DPHThis -> thisPackage dflags
2105 setMainIs :: String -> DynP ()
2107 | not (null main_fn) && isLower (head main_fn)
2108 -- The arg looked like "Foo.Bar.baz"
2109 = upd $ \d -> d{ mainFunIs = Just main_fn,
2110 mainModIs = mkModule mainPackageId (mkModuleName main_mod) }
2112 | isUpper (head arg) -- The arg looked like "Foo" or "Foo.Bar"
2113 = upd $ \d -> d{ mainModIs = mkModule mainPackageId (mkModuleName arg) }
2115 | otherwise -- The arg looked like "baz"
2116 = upd $ \d -> d{ mainFunIs = Just arg }
2118 (main_mod, main_fn) = splitLongestPrefix arg (== '.')
2120 -----------------------------------------------------------------------------
2121 -- Paths & Libraries
2123 addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()
2125 -- -i on its own deletes the import paths
2126 addImportPath "" = upd (\s -> s{importPaths = []})
2127 addImportPath p = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})
2131 upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})
2134 upd (\s -> s{includePaths = includePaths s ++ splitPathList p})
2136 addFrameworkPath p =
2137 upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})
2139 #ifndef mingw32_TARGET_OS
2140 split_marker :: Char
2141 split_marker = ':' -- not configurable (ToDo)
2144 splitPathList :: String -> [String]
2145 splitPathList s = filter notNull (splitUp s)
2146 -- empty paths are ignored: there might be a trailing
2147 -- ':' in the initial list, for example. Empty paths can
2148 -- cause confusion when they are translated into -I options
2149 -- for passing to gcc.
2151 #ifndef mingw32_TARGET_OS
2152 splitUp xs = split split_marker xs
2154 -- Windows: 'hybrid' support for DOS-style paths in directory lists.
2156 -- That is, if "foo:bar:baz" is used, this interpreted as
2157 -- consisting of three entries, 'foo', 'bar', 'baz'.
2158 -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
2159 -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
2161 -- Notice that no attempt is made to fully replace the 'standard'
2162 -- split marker ':' with the Windows / DOS one, ';'. The reason being
2163 -- that this will cause too much breakage for users & ':' will
2164 -- work fine even with DOS paths, if you're not insisting on being silly.
2167 splitUp (x:':':div:xs) | div `elem` dir_markers
2168 = ((x:':':div:p): splitUp rs)
2170 (p,rs) = findNextPath xs
2171 -- we used to check for existence of the path here, but that
2172 -- required the IO monad to be threaded through the command-line
2173 -- parser which is quite inconvenient. The
2174 splitUp xs = cons p (splitUp rs)
2176 (p,rs) = findNextPath xs
2181 -- will be called either when we've consumed nought or the
2182 -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
2183 -- finding the next split marker.
2185 case break (`elem` split_markers) xs of
2186 (p, _:ds) -> (p, ds)
2189 split_markers :: [Char]
2190 split_markers = [':', ';']
2192 dir_markers :: [Char]
2193 dir_markers = ['/', '\\']
2196 -- -----------------------------------------------------------------------------
2197 -- tmpDir, where we store temporary files.
2199 setTmpDir :: FilePath -> DynFlags -> DynFlags
2200 setTmpDir dir dflags = dflags{ tmpDir = normalise dir }
2201 -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
2202 -- seem necessary now --SDM 7/2/2008
2204 -----------------------------------------------------------------------------
2207 setOptHpcDir :: String -> DynP ()
2208 setOptHpcDir arg = upd $ \ d -> d{hpcDir = arg}
2210 -----------------------------------------------------------------------------
2211 -- Via-C compilation stuff
2213 -- There are some options that we need to pass to gcc when compiling
2214 -- Haskell code via C, but are only supported by recent versions of
2215 -- gcc. The configure script decides which of these options we need,
2216 -- and puts them in the file "extra-gcc-opts" in $topdir, which is
2217 -- read before each via-C compilation. The advantage of having these
2218 -- in a separate file is that the file can be created at install-time
2219 -- depending on the available gcc version, and even re-generated later
2220 -- if gcc is upgraded.
2222 -- The options below are not dependent on the version of gcc, only the
2225 machdepCCOpts :: DynFlags -> ([String], -- flags for all C compilations
2226 [String]) -- for registerised HC compilations
2227 machdepCCOpts _dflags
2228 #if alpha_TARGET_ARCH
2230 #ifdef HAVE_THREADED_RTS_SUPPORT
2234 -- For now, to suppress the gcc warning "call-clobbered
2235 -- register used for global register variable", we simply
2236 -- disable all warnings altogether using the -w flag. Oh well.
2238 #elif hppa_TARGET_ARCH
2239 -- ___HPUX_SOURCE, not _HPUX_SOURCE, is #defined if -ansi!
2240 -- (very nice, but too bad the HP /usr/include files don't agree.)
2241 = ( ["-D_HPUX_SOURCE"], [] )
2243 #elif m68k_TARGET_ARCH
2244 -- -fno-defer-pop : for the .hc files, we want all the pushing/
2245 -- popping of args to routines to be explicit; if we let things
2246 -- be deferred 'til after an STGJUMP, imminent death is certain!
2248 -- -fomit-frame-pointer : *don't*
2249 -- It's better to have a6 completely tied up being a frame pointer
2250 -- rather than let GCC pick random things to do with it.
2251 -- (If we want to steal a6, then we would try to do things
2252 -- as on iX86, where we *do* steal the frame pointer [%ebp].)
2253 = ( [], ["-fno-defer-pop", "-fno-omit-frame-pointer"] )
2255 #elif i386_TARGET_ARCH
2256 -- -fno-defer-pop : basically the same game as for m68k
2258 -- -fomit-frame-pointer : *must* in .hc files; because we're stealing
2259 -- the fp (%ebp) for our register maps.
2260 = let n_regs = stolen_x86_regs _dflags
2263 ( [ if sta then "-DDONT_WANT_WIN32_DLL_SUPPORT" else ""
2266 "-fomit-frame-pointer",
2267 -- we want -fno-builtin, because when gcc inlines
2268 -- built-in functions like memcpy() it tends to
2269 -- run out of registers, requiring -monly-n-regs
2271 "-DSTOLEN_X86_REGS="++show n_regs ]
2274 #elif ia64_TARGET_ARCH
2275 = ( [], ["-fomit-frame-pointer", "-G0"] )
2277 #elif x86_64_TARGET_ARCH
2279 #if darwin_TARGET_OS
2284 ["-fomit-frame-pointer",
2285 "-fno-asynchronous-unwind-tables",
2286 -- the unwind tables are unnecessary for HC code,
2287 -- and get in the way of -split-objs. Another option
2288 -- would be to throw them away in the mangler, but this
2291 -- calling builtins like strlen() using the FFI can
2292 -- cause gcc to run out of regs, so use the external
2296 #elif sparc_TARGET_ARCH
2298 -- For now, to suppress the gcc warning "call-clobbered
2299 -- register used for global register variable", we simply
2300 -- disable all warnings altogether using the -w flag. Oh well.
2302 #elif powerpc_apple_darwin_TARGET
2304 -- Disable Apple's precompiling preprocessor. It's a great thing
2305 -- for "normal" programs, but it doesn't support register variable
2307 = ( [], ["-no-cpp-precomp"] )
2312 picCCOpts :: DynFlags -> [String]
2314 #if darwin_TARGET_OS
2315 -- Apple prefers to do things the other way round.
2316 -- PIC is on by default.
2317 -- -mdynamic-no-pic:
2318 -- Turn off PIC code generation.
2320 -- Don't generate "common" symbols - these are unwanted
2321 -- in dynamic libraries.
2324 = ["-fno-common", "-U __PIC__","-D__PIC__"]
2326 = ["-mdynamic-no-pic"]
2327 #elif mingw32_TARGET_OS
2328 -- no -fPIC for Windows
2330 = ["-U __PIC__","-D__PIC__"]
2334 | opt_PIC || not opt_Static
2335 = ["-fPIC", "-U __PIC__", "-D__PIC__"]
2340 -- -----------------------------------------------------------------------------
2344 can_split = cSplitObjs == "YES"
2346 -- -----------------------------------------------------------------------------
2349 compilerInfo :: [(String, String)]
2350 compilerInfo = [("Project name", cProjectName),
2351 ("Project version", cProjectVersion),
2352 ("Booter version", cBooterVersion),
2354 ("Interface file version", cHscIfaceFileVersion),
2355 ("Have interpreter", cGhcWithInterpreter),
2356 ("Object splitting", cSplitObjs),
2357 ("Have native code generator", cGhcWithNativeCodeGen),
2358 ("Support SMP", cGhcWithSMP),
2359 ("Unregisterised", cGhcUnregisterised),
2360 ("Tables next to code", cGhcEnableTablesNextToCode),
2361 ("Win32 DLLs", cEnableWin32DLLs),
2362 ("RTS ways", cGhcRTSWays),
2363 ("Leading underscore", cLeadingUnderscore),
2364 ("Debug on", show debugIsOn)